Hi, my name is Marius and I have spent this
Summer of HPC at the Cyprus Institute trying
to enable lattice QCD simulations on GPUs.
So what is QCD?
Well, in school you have been taught that
an atom is made of electrons, protons and
neutrons and while you can split the atom
itself, these particles happen to be elementary.
Unfortunately, this only happens to be true
for electrons.
Protons and neutrons are compound particles
as well and made of quarks, which bind together
really strong doing so by means of the strong
interaction.
This interaction is described by quantum chromodynamics.
Chromo, because it's transmitted by three
color charges instead of for example the one
electric charge of the electromagnetic force.
So how do we calculate this?
Well, first we have the fermionic action - quarks
are fermions like nucleons are - which looks
like this.
Then we also need to consider the gluonic
action.
Gluons are the interaction particles of QCD,
like photons in the electromagnetic force.
So the QCD action is the sum of these.
Then, we can measure an observable like in
any quantum field theory via a path integral.
Looking at this, you might realize that this
is nothing you want to solve on paper, in
fact, there isn't even an analytical solution.
Even perturbation theory fails to work here,
since the coupling constant is too large.
So what should we do?
Well, we now get to simulate the whole thing
on a four dimensional space time lattice.
To do so, we start by setting all the fields
to random numbers and then letting them evolve
according to the equations from earlier.
We do this step-by-step to get something we
call a trajectory or Markov chain of gauge
configurations, which then can be used to
run some measurements.
We take the whole chain for this, since a
single configuration tends to be a bit noisy.
So what did we actually do to speed up the
calculation?
Well, the most expensive part happens to be
the inversion of the Dirac matrix, which is
just enormously large, it includes the interaction
between any two points on the lattice.
Luckily, we can apply a little trick here:
The inversion is done by a Conjugate Gradient
algorithm, which runs faster for large eigenvalues.
So we simply rescale.
This had of course already been done in tmLQCD,
the lattice QCD package used by the group
here in Cyprus, but the calculations could
not be done on GPUs yet.
Additionally, this trick adds some new parameters,
which need and have been tuned to make the
code run properly fast.
So how does our code scale with the number
of available GPUs?
Well, pretty bad for small lattices!
There's even a dip at eight GPUs, since we
have to open up a new MPI dimension here!
But lo and behold, we have larger lattices!
For a medium size, this already looks pretty
good.
And for an even larger size, we can see a
little more improvement, but unfortunately
this one was not dividable by twelve GPUs
any more.
And last but not least, our measurements.
We took a look at pion correlators instead
of protons, since they happen to be easier
to calculate.
And of course, these correlators should not
be at the order of 10 to the 4, ther's simply
a normalization factor missing.
So, if we have the correlator, we can perform
a simple exponential fit to extract the pion
mass, which gives us about 260 MeV.
Now if you know the actual pion mass or look
it up, you will notice, that this is not that
close to the physical 140 MeV.
But this is fine, since we were using a larger-than-physical
quark mass to begin with and that way our
result is about what we expected.
So, I hope you enjoyed this video as well
as I did this summer and see you around Europe!
