CSC 5001– High Performance Systems

We're going to modify the scrollup kernel of EasyPAP in order to provoke some cache faults and observe their impact on performance.

1. Duplicate the function compute_seq() by naming it scrollup_compute_ji(), and specify __attribute__((optimize("-O1"))) to prevent the compiler from vectorizing the function:
   unsigned scrollup_compute_ji (unsigned nb_iter) __attribute__((optimize("-O1"))); unsigned scrollup_compute_ji (unsigned nb_iter) { for (unsigned it = 1; it <= nb_iter; it++) { for (int i = 0; i < DIM; i++) { int src = (i < DIM - 1) ? i + 1 : 0; for (int j = 0; j < DIM; j++) next_img (DIM - 1, j) = cur_img (0, j); } swap_images (); } return 0; }
   Next, invert the order of loops that iterate over i and j. Also, compute the last line of the image out of the loop. Remove the test and put after the loop the following code:
   for (int j = 0; j < DIM; j++) next_img (DIM - 1, j) = cur_img (0, j);
2. Use the image shibuya.png to check the result. Compare visually the fluidity of the animation obtained by the seq and ji versions of the scrollup kernel:
   srun --x11 --account=csc_5001 --partition=starfighter --qos=normal --time=00:05:00 --cpus-per-task=1 --mem=8G ./run --load-image data/img/shibuya.png --kernel scrollup --variant ji
3. Use the script plots/run-xp-scrollup.py to run a series of experiments that will vary the image size and the number of iterations to maintain a constant computation time. The number of iteration is defined as: nb_iterations = (4096 * 4096) / (DIM * DIM).
   export SLURM_PARAMS="--account=csc_5001 --partition=starfighter --qos=normal --time=00:05:00 --cpus-per-task=1 --mem=8G" # tell easypap how to use slurm uv run plots/run-xp-scrollup.py
   You may have to install uv, create a virtual environment, and install dependencies before running the script:

   wget -qO- https://astral.sh/uv/install.sh | sh # install uv source ~/.bashrc # uv installs in ~/.local/bin and update .bashrc to add this directory to PATH. uv pip install pandas seaborn # install dependencies

5. Use the following command in order to generate curve:
   uv run ./plots/easyplot.py -y time -x size --yscale log --xscale log --delete iterations -if scrollup.csv
6. Interpret the figure knowing that a pixel is encoded on 4 bytes and that the cache size of your machine is given by the command lstopo.
7. Implement a tiled version of the initial row-major path. Play with the tile dimension. Compare performance.

This exercise deals with the optimization of sequential code and vectorisation.

The blur kernel blurs an image by calculating, for each pixel, the average value of the pixels located in its immediate neighbourhood. However, two different pixels may have a different number of neighbours depending on their position in the image. Here is a code that treats all cases in the same way.

The spin kernel, which performs a few simple trigonometric calculations, gives the compiler a hard time, as it is unable to vectorize it automatically. So we're going to manually vectorize the calculations using intrinsics.