jadot-bp/fastsum_gpu

Repository for the "FAST" FASTSUM Analysis Software Tools prepared during the 2024 DiRAC GPU Workshop.

fastsum-gpu

This repository is for the "FAST" FASTSUM Analysis Software Tools prepared during the 2024 DiRAC GPU Workshop.

---

Pre-commit notes

pre-commit will be installed. Activate the conda environment (below) and run pre-commit install

Conda Notes

Install your favourite conda solution, such as https://docs.conda.io/en/latest/miniconda.html

Switch to a faster environment solver

This is optional, but likely will solve the dependencies much much faster. See https://www.anaconda.com/blog/a-faster-conda-for-a-growing-community conda update -n base conda conda install -n base conda-libmamba-solver conda config --set solver libmamba

Install Environment

conda env create -f linux_environment.yml

Activate/Use

conda activate fastsum

Update (w. new packages)

1. Edit environment.yml
2. Deactivate conda environment with conda deactivate
3. Update conda environment with conda env update -f=linux_environment.yml

fastsum_gpu's Issues

`memcpy` issue in `readC.c`

There currently appears to be an issue with the memcpy call in readC.c when the memory required exceeds a certain size. Currently, the code supports at least 64x32^3 lattices and should support up to 128x32^3, but encounters a segmentation fault when provided a 64x48^3 128x48^3 lattice.

Generic Wilson Loop/Line

My thought is that transitioning to takes a list of positions, and a list of directions and then multiplies those together is likely to make doing arbitrary wilson loops easier. I.e. feed the function the path and then it goes and calculates.

One would pre-calculate the path, and then i.e. each thread on a GPU/CPU would calculate the wilson line along the path.

This would also be useful for staples if we wanted those for some reason.

Two main requirements:

• A function which takes a path
  • Paired lists/vectors/etc of 4-dimensional position and direction
  • Fetches the links, multiplies them together, returns a SU(3) matrix
• A function or series of functions to calculate the paths
  • At first step, manually hard-coding the plaquette is probably viable.

To do a Wilson Loop, one would probably call a Wilson Line function twice on forward and backward paths (conjugate at end).

Do either of you have any thoughts on this approach?

RxT Wilson loops crash for both RxT > 1

The RxT wilson loop code crashes (when trying to evaluate the path) for both R and T > 1. It works fine for large R, T =1 and large T, R =1. I tested multiple sizes on the smallest conf (8x24^3), and R or T = 1 (other = NT or NS) on a 256x24^3.

The crash is a segfault.

The code is sufficiently slow that we should see improvement on GPU even with these constraints (200s for R=24, NT=1 for 256x24^3)

Non-Parallel Timers

The timer gives the core*real time, i.e. the amount of processor time. This is not really what we want.

This is particularly evident in the openMP branches. I am unsure about the parallel CPP branch. Unfortunately, this might be a thing that needs to be fixed across every different paradigm?