GPGPU chapter done

Examples/cuda_sum_vec.cu

+#include <iostream>
+#include <vector>
+
+constexpr size_t kVecSize = 100000;
+
+__device__ constexpr size_t getIdx() {
+    return blockDim.x * blockIdx.x + threadIdx.x;
+}
+
+__global__ void sumVectors(float *a, float *b, float *c) {
+    size_t idx = getIdx();
+    if (idx < kVecSize) {
+        c[idx] = a[idx] + b[idx];
+    }
+}
+
+int main() {
+    constexpr size_t kBytes = sizeof(float) * kVecSize;
+
+    // Host initialization
+    float *host_vec_a = nullptr;
+    float *host_vec_b = nullptr;
+    float *host_vec_c = nullptr;
+    cudaMallocHost(&host_vec_a, kBytes);
+    cudaMallocHost(&host_vec_b, kBytes);
+    cudaMallocHost(&host_vec_c, kBytes);
+
+    for (size_t i = 0; i < kVecSize; i++) {
+        host_vec_a[i] = static_cast<float>(i);
+        host_vec_b[i] = 2.0 * static_cast<float>(i);
+    }
+
+    // Device initialization
+    float *dev_vec_a = nullptr;
+    float *dev_vec_b = nullptr;
+    float *dev_vec_c = nullptr;
+    cudaMalloc(&dev_vec_a, kBytes);
+    cudaMalloc(&dev_vec_b, kBytes);
+    cudaMalloc(&dev_vec_c, kBytes);
+
+    // Copy host vectors on device
+    cudaMemcpy(dev_vec_a, host_vec_a, kBytes, cudaMemcpyHostToDevice);
+    cudaMemcpy(dev_vec_b, host_vec_b, kBytes, cudaMemcpyHostToDevice);
+
+    // Compute device execution parameters
+    constexpr size_t kThreadPerBlock = 256;
+    constexpr size_t kBlockPerGrid = kVecSize / kThreadPerBlock + ((kVecSize % kThreadPerBlock) != 0 ? 1 : 0);
+
+    // Run kernel
+    sumVectors<<<kBlockPerGrid, kThreadPerBlock>>>(dev_vec_a,
+                                                   dev_vec_b,
+                                                   dev_vec_c);
+
+    // Get back the resulting vector to host
+    cudaMemcpy(host_vec_c, dev_vec_c, kBytes, cudaMemcpyDeviceToHost);
+
+    constexpr float tol = 1e-5;
+    bool is_correct = true;
+    for (size_t i = 0; i < kVecSize; i++) {
+        float expected = 3.0 * static_cast<float>(i);
+        if (std::abs(host_vec_c[i] - expected) > tol) {
+            is_correct = false;
+            break;
+        }
+    }
+    std::cout << "The sum of the two vector is ";
+    if (is_correct) {
+        std::cout << "correct";
+    } else {
+        std::cout << "wrong";
+    }
+    std::cout << std::endl;
+
+    // Host cleanup
+    cudaFreeHost(host_vec_a);
+    cudaFreeHost(host_vec_b);
+    cudaFreeHost(host_vec_c);
+
+    // Device cleanup
+    cudaFree(dev_vec_a);
+    cudaFree(dev_vec_b);
+    cudaFree(dev_vec_c);
+}
\ No newline at end of file

Examples/makefile

@@ -5,13 +5,16 @@ FLAGS=--std=c++20 -stdpar=gpu
 INCLUDES_WARNINGS:=--diag_suppress useless_using_declaration
 
 
-all: artefacts/future
+all: artefacts/future artefacts/cuda_sum_vec
 
-artefacts/future: artefacts/future.o
+artefacts/%: artefacts/%.o
 	$(CC) $(FLAGS) $^ -o $@
 
 artefacts/%.o: %.cpp
 	$(CC) $(FLAGS) $(INCLUDES_WARNINGS) -c $^ -o $@
 
+artefacts/%.o: %.cu
+	$(CC) $(FLAGS) $(INCLUDES_WARNINGS) -c $^ -o $@
+
 clean:
 	rm -vf artefacts/**
\ No newline at end of file

GPGPU.typ

+// https://polylux.dev/book/polylux.html
+// https://typst.app/docs
+#import "@preview/polylux:0.3.1": *
+#import themes.metropolis : *
+
+#show: metropolis-theme.with(aspect-ratio: "16-9", footer: "Parallel STL - HPC 2024")
+
+#set text(font: "Fira Sans", weight: "light", size: 20pt)
+#show math.equation: set text(font: "Fira Math")
+
+#title-slide(
+  title: "Algorithmes parallèles STL avec C++ 20",
+  subtitle: "GPGPU",
+  author: "Michaël El Kharroubi",
+  date: "27.02.2024",
+  extra: "HPC 2024 - HEPIA",
+)
+
+#new-section-slide("Introduction")
+
+#slide(
+  title: "Définition",
+)[
+  Le terme "_general-purpose computing on graphics processing units_" (GPGPU)
+  désigne l'ensemble des programmmes qui ne sont pas graphiques et qu'on réalise
+  sur GPU.
+
+  Par exemple :
+  - Simulation de phénomènes physiques
+  - IA et Machine learning
+  - Minage de crypto-monnaie
+]
+
+#slide(
+  title: "Pourquoi a-t-on besoin de GPU?",
+)[
+  Un CPU est conçu pour suivre une série d'instructions séquentiellement (ce qui
+  n'est plus le cas, dans une moindre mesure, avec les instructions vectorielles
+  ex: AVX).
+
+  #box(columns(2, gutter: 22pt)[
+    == Adapté :
+    - Ordonancer des tâches
+    - Accéder aux périphériques
+      - Réseau
+      - Disque
+      - Clavier/souris
+    #colbreak()
+    == Moins adapté :
+    - Calcul vectoriel
+    - Calcul matriciel
+  ])
+
+  Les GPU apportent une réponse à ces problèmes.
+]
+
+#slide(
+  title: "CPU vs GPU",
+)[
+  Un GPU est un processeur vectoriel, son objectif est d'effectuer massivement des
+  calculs en parallèle.
+
+  #figure(
+    image("assets/cpu-gpu.svg", width: 70%),
+    caption: [NVIDIA CUDA Programming Guide version 3.0 - 2010],
+  )
+
+  #link("https://youtu.be/-P28LKWTzrI")[Partenariat Myth Busters & NVidia]
+]
+
+#new-section-slide("La programmation sur GPU")
+
+#slide(
+  title: "CUDA",
+)[
+  CUDA est le kit de développement de NVIDIA pour faire du GPGPU. C'est le kit le
+  plus populaire de développement GPGPU.
+
+  CUDA permet d'écrire du code en C/C++ et de le compiler pour qu'il soit exécuté
+  sur des GPU de NVidia.
+
+  Dans la concurrence, on peut également citer OpenCL (multi-plateforme), ROCm
+  pour AMD ou OneAPI pour Intel.
+]
+
+#slide(title: "Déroulement classique d'un programmme GPGPU")[
+  + Le CPU envoie les données à traiter au GPU #pause
+  + Le GPU applique un kernel sur les données #pause
+  + Le CPU récupère le résultat #pause
+]
+
+#new-section-slide("Exemple de code CUDA et notions à retenir")
+
+#slide(title: "Notions essentielles à retenir")[
+  - Le CPU et le GPU sont deux périphériques distincts
+  - Le GPU est prévu pour effectuer massivement des calculs
+  - La mémoire n'est pas partagée
+  - On parle de *Host* pour le CPU et de *Device* pour le GPU
+]
+
+#new-section-slide("Questions ?")
\ No newline at end of file

intro.typ

@@ -3,20 +3,17 @@
 #import "@preview/polylux:0.3.1": *
 #import themes.metropolis : *
 
-#show: metropolis-theme.with(
-  aspect-ratio: "16-9", 
-  footer: "Parallel STL - HPC 2024"
-)
+#show: metropolis-theme.with(aspect-ratio: "16-9", footer: "Parallel STL - HPC 2024")
 
 #set text(font: "Fira Sans", weight: "light", size: 20pt)
 #show math.equation: set text(font: "Fira Math")
 
 #title-slide(
   title: "Algorithmes parallèles STL avec C++ 20",
-  subtitle: "HPC 2024",
+  subtitle: "Introduction",
   author: "Michaël El Kharroubi",
   date: "27.02.2024",
-  extra: "HEPIA",
+  extra: "HPC 2024 - HEPIA",
 )
 
 //#slide(title: "Table des matières")[
@@ -25,38 +22,45 @@
 
 #new-section-slide("Introduction")
 
-#slide(title: "Objectif du cours")[
-Dans ce cours, nous verrons comment exécuter du code sur GPU de façon moderne avec C++.
+#slide(
+  title: "Objectif du cours",
+)[
+  Dans ce cours, nous verrons comment exécuter du code sur GPU de façon moderne
+  avec C++.
 
-Nous utiliserons le kit de développement HPC de Nvidia, en particulier le compilateur _nvc++_.
+  Nous utiliserons le kit de développement HPC de Nvidia, en particulier le
+  compilateur _nvc++_.
 
-Le but de ce cours est de vous donner une courte introduction au calcul générique sur processeur graphique (GPGPU).
+  Le but de ce cours est de vous donner une courte introduction au calcul
+  générique sur processeur graphique (GPGPU).
 ]
 
 #slide(title: "Contenu du cours")[
- #box(
-  columns(1)[
-  Dans ce cours nous verrons les concepts suivants :
-
-  + Qu'est-ce que le GPGPU, et pour quel usage s'en sert-on?
-    + Comment fait-on du GPGPU de manière classique
-    + La problématique de la mémoire en GPGPU                 #pause
-  + Les itérateurs C++
-  + Les vecteurs, les tableaux et les spans
-  + Les captures
-  + Les algorithmes STL                                       #pause
-  + Présentation du kit HPC Nvidia
-    + Le compilateur nvc++
-    + Comment paralléliser son code avec nvc++
-  + Le futur du paradigme STL avec les mdspans et les views
-  ]
- )
+  #box(columns(1)[
+    Dans ce cours nous verrons les concepts suivants :
+
+    + Qu'est-ce que le GPGPU, et pour quel usage s'en sert-on?
+      + Comment fait-on du GPGPU de manière classique
+      + La problématique de la mémoire en GPGPU #pause
+    + Les itérateurs C++
+    + Les vecteurs, les tableaux et les spans
+    + Les captures
+    + Les algorithmes STL #pause
+    + Présentation du kit HPC Nvidia
+      + Le compilateur nvc++
+      + Comment paralléliser son code avec nvc++
+    + Le futur du paradigme STL avec les mdspans et les views
+  ])
 ]
 
-#slide(title: "Planning du cours")[
-  Le cours sera donné sur une semaine (5 périodes). Nous ferons 2 périodes de théorie et 3 périodes de pratique.
+#slide(
+  title: "Planning du cours",
+)[
+  Le cours sera donné sur une semaine (5 périodes). Nous ferons 2 périodes de
+  théorie et 3 périodes de pratique.
 
-  Pour la partie pratique, nous implémenterons le calcul des équations de la chaleur sur GPU. 
+  Pour la partie pratique, nous implémenterons le calcul des équations de la
+  chaleur sur GPU.
 ]
 
 #new-section-slide("Questions ?")
\ No newline at end of file