Calcul Québec - Université Laval. Atelier CUDA/GPU
|
|
|
- Raoul Renaud
- il y a 8 ans
- Total affichages :
Transcription
1 Atelier CUDA/GPU Maxime Boissonneault Université Laval - Octobre 2014 Adaptation du "CUDA/GPU Workshop", par Dan Mazur <dan.mazur@calculquebec.ca>, Université McGill 1
2 2 Prérequis Connaissance de base d'un système Linux Connexion à distance avec SSH Éditeur texte (VIM, emacs, nano) Bonne connaissance du langage C Syntaxe Compilateur GCC Familiarité avec les fils d'exécutions (threads)
3 3 Postes fixes Windows/Linux Pour se connecter sur les postes Nom d utilisateur : formation Mot de passe : «Automne14»
4 4 Plan Vue d'ensemble du GPGPU Terminologie et architecture Connexion et préparation de l'environnement Introduction à CUDA-C Exemples Mémoire globale Blocs et fils d'exécutions Syntaxe courante Gestion des erreurs Mémoire partagée et synchronisation Mémoire unifiée (Cuda 6) Multi-GPU
5 V1.0 Vue d'ensemble du GPGPU 5
6 6 Qu'est-ce qu'un GPU Dispositif servant à résoudre des calculs coûteux en temps (accélérateur) Grand nombre de coeurs peu coûteux Énergie $$ Vitesse de calcul théorique impressionnante : plusieurs Teraflops Modèle hybride de programmation : CPU et GPU en même temps
7 7 Historique 1980s Premiers contrôleurs graphiques (Intel, TI, IBM) 1990s Premiers GPUs 2D et 3D Gaming Introduction de CUDA Révisions des compute capabilities... OpenCL OpenACC K20, Titan compute capability 3.5
8 8 Applications connues ABAQUS, Amber, GROMACS, LAMMPS, MATLAB, PETSc, OpenFOAM (certains solvers)
9 9 Librairies CuBLAS Magma CuFFT Thrust
10 10 Programmation CUDA-{C,Fortran Compute Unified Device Architecture OpenCL OpenACC
11 11 Rappel : C et les pointeurs int x = 1; int *p; p = &x; *p = 0; printf( x=%d\n,x); Quel sera l'affichage à l'écran? A)x=1 B)x=0 C)x=0x7ffff957 D)Erreur ou SEGFAULT
12 11 Rappel : C et les pointeurs int x = 1; int *p; p = &x; *p = 0; printf( x=%d\n,x); Quel sera l'affichage à l'écran? A)x=1 B)x=0 C)x=0x7ffff957 D)Erreur ou SEGFAULT On assigne 0 à la mémoire vers laquelle pointe p
13 V1.0 Terminologie et architecture 12
14 13 GPU
15 coeurs fp32 Calcul flotant 32 bits Calcul entier (simple) 32 bits 64 coeurs fp64 32 SFU Multiplications d'entier, etc. sin, cos, LD/ST Chargement / rapatriement de la mémoire 16 TEX Textures SM (GK110)
16 15 Connexion et préparation de l'environnement $ ssh userx@helios.calculquebec.ca password: [~]$ prepare_formation cuda [~]$ prepare_formation job [user41@gpu-k20-02 ~]$ cd ~/ formation/cuda/formation Noeuds de formation fournis par :
![ca password: [~]$ prepare_formation cuda [~]$](/docs-images/44/3940402/images/page_16.jpg "prepare_formation job [user41@gpu-k20-02 ~]$ cd ~/")
17 16 Structure des exercices formation]$ ls -lh total 36K drwxr-xr-x 2 mboisson clumeq 4,0K 7 oct 10:58 1-compilation drwxr-xr-x 3 mboisson clumeq 4,0K 9 oct 14:59 3-remplir-vecteur drwxr-xr-x 3 mboisson clumeq 4,0K 9 oct 15:10 4-multiplications-matrices drwxr-xr-x 3 mboisson clumeq 4,0K 7 oct 10:58 5-erreurs drwxr-xr-x 3 mboisson clumeq 4,0K 8 oct 16:05 7-produit-scalaire drwxr-xr-x 3 mboisson clumeq 4,0K 8 oct 16:04 8-multiplications-matricecuda6 drwxr-xr-x 3 mboisson clumeq 4,0K 20 oct 10:08 9-multiples-gpus -rw-r--r-- 1 mboisson clumeq oct 15:30 makefile-levels.mk -rw-r--r-- 1 mboisson clumeq oct 10:59 makefile.mk
18 17 Code minimal global void foo() { int main() { foo<<<1,1>>>(); printf("cuda error: %s\n", cudageterrorstring(cudagetlasterror())); return 0; trivial.cu
19 18 Compilation $ nvcc <fichier.cu> -o <exe> $./<exe>
20 19 Exercice 1 : compilation Fichier trivial.cu Description Compiler et exécuter un programme CUDA-C
21 19 Exercice 1 : compilation Fichier Description trivial.cu Compiler et exécuter un programme CUDA-C Indice : Utilisez "nvcc" comme compilateur
22 20 Exercice 1 : solution $ nvcc trivial.cu -o trivial $./trivial CUDA error: no error $
23 20 Exercice 1 : solution $ nvcc trivial.cu -o trivial $./trivial CUDA error: no error $ «Compilateur» à utiliser
24 21 Exercice 1 : solution (alternative) $ nvcc -arch=sm_12 trivial.cu -o trivial $./trivial CUDA error: no error $
25 21 Exercice 1 : solution (alternative) $ nvcc -arch=sm_12 trivial.cu -o trivial $./trivial CUDA error: no error $ Important pour avoir accès à des opérations atomiques de base.
26 22 Exercice 1 : restant des exercices $ make nvcc -arch=sm_12 -c trivial.cu -o trivial.o nvcc trivial.o -o trivial $./trivial CUDA error: no error $
27 23 Code minimal global void foo() { int main() { foo<<<1,1>>>(); printf("cuda error: %s\n", cudageterrorstring(cudagetlasterror())); return 0;
28 23 Code minimal Kernel global void foo() { int main() { foo<<<1,1>>>(); printf("cuda error: %s\n", cudageterrorstring(cudagetlasterror())); return 0;
29 23 Portée de la fonction(kernel). Code minimal Kernel global void foo() { int main() { foo<<<1,1>>>(); printf("cuda error: %s\n", cudageterrorstring(cudagetlasterror())); return 0;
30 23 Portée de la fonction(kernel). Code minimal Kernel global void foo() { int main() { foo<<<1,1>>>(); printf("cuda error: %s\n", cudageterrorstring(cudagetlasterror())); return 0; Paramètres d exécution du kernel.
31 24 Exemples CUDA $CUDA_HOME/samples Contient : Exemples de programmes (utilitaires, imagerie, finance, simulations, librairies) Documentation Outils de gestion (nvidia-smi)
32 25 Exercice 2 : exemples CUDA Répertoire $CUDA_HOME/samples/1_Utilities/deviceQuery/ Description Copier, compiler et exécuter le programme devicequery
33 26 Sortie de devicequery Detected 1 CUDA Capable device(s) Device 0 : "GeForce GT 330M" CUDA Driver Version / Runtime Version 5.5 / 5.5 CUDA Capability Major/Minor version number: 1.2 Total amount of global memory: 256 MBytes ( bytes) ( 6) Multiprocessors x ( 8) CUDA Cores/MP: 48 CUDA Cores Total amount of shared memory per block: bytes Maximum number of threads per block: 512 Maximum sizes of each dimension of a block: 512 x 512 x 64 Maximum sizes of each dimension of a grid: x x 1
34 26 Sortie de devicequery Detected 1 CUDA Capable device(s) Device 0 : "GeForce GT 330M" Nombre de carte(s) CUDA Driver Version / Runtime Version 5.5 / 5.5 CUDA Capability Major/Minor version number: 1.2 Total amount of global memory: 256 MBytes ( bytes) ( 6) Multiprocessors x ( 8) CUDA Cores/MP: 48 CUDA Cores Total amount of shared memory per block: bytes Maximum number of threads per block: 512 Maximum sizes of each dimension of a block: 512 x 512 x 64 Maximum sizes of each dimension of a grid: x x 1
35 26 Sortie de devicequery Detected 1 CUDA Capable device(s) Device 0 : "GeForce GT 330M" CUDA Driver Version / Runtime Version 5.5 / 5.5 CUDA Capability Major/Minor version number: 1.2 Numéro de la carte Total amount of global memory: 256 MBytes ( bytes) ( 6) Multiprocessors x ( 8) CUDA Cores/MP: 48 CUDA Cores Total amount of shared memory per block: bytes Maximum number of threads per block: 512 Maximum sizes of each dimension of a block: 512 x 512 x 64 Maximum sizes of each dimension of a grid: x x 1
36 26 Sortie de devicequery Detected 1 CUDA Capable device(s) Device 0 : "GeForce GT 330M" CUDA Driver Version / Runtime Version 5.5 / 5.5 CUDA Capability Major/Minor Version version de number: 1.2 Total amount of global memory: CUDA ( bytes) 256 MBytes ( 6) Multiprocessors x ( 8) CUDA Cores/MP: 48 CUDA Cores Total amount of shared memory per block: bytes Maximum number of threads per block: 512 Maximum sizes of each dimension of a block: 512 x 512 x 64 Maximum sizes of each dimension of a grid: x x 1
37 26 Sortie de devicequery Detected 1 CUDA Capable device(s) Device 0 : "GeForce GT 330M" CUDA Driver Version /"Capability" Runtime Version 5.5 / 5.5 CUDA Capability Major/Minor version number: 1.2 Total amount of global memory: 256 MBytes ( bytes) ( 6) Multiprocessors x ( 8) CUDA Cores/MP: 48 CUDA Cores Total amount of shared memory per block: bytes Maximum number of threads per block: 512 Maximum sizes of each dimension of a block: 512 x 512 x 64 Maximum sizes of each dimension of a grid: x x 1
38 26 Sortie de devicequery Detected 1 CUDA Capable device(s) Device 0 : "GeForce GT 330M" CUDA Driver Version / Runtime Version 5.5 / 5.5 CUDA Capability Major/Minor version number: 1.2 Total amount of global memory: 256 MBytes ( bytes) ( 6) Multiprocessors Mémoire x ( 8) CUDA Cores/MP: 48 CUDA Cores Total amount of shared totale memory per block: bytes Maximum number of threads per block: 512 Maximum sizes of each dimension of a block: 512 x 512 x 64 Maximum sizes of each dimension of a grid: x x 1
39 26 Sortie de devicequery Detected 1 CUDA Capable device(s) Device 0 : "GeForce GT 330M" CUDA Driver Version / Runtime Version 5.5 / 5.5 CUDA Capability Major/Minor version number: 1.2 Total amount of global memory: 256 MBytes ( bytes) ( 6) Multiprocessors x ( 8) CUDA Cores/MP: 48 CUDA Cores Total amount of shared Nombre memory de per block: bytes coeurs Maximum number of threads per block: 512 Maximum sizes of each dimension of a block: 512 x 512 x 64 Maximum sizes of each dimension of a grid: x x 1
40 26 Sortie de devicequery Detected 1 CUDA Capable device(s) Device 0 : "GeForce GT 330M" CUDA Driver Version / Runtime Version 5.5 / 5.5 CUDA Capability Major/Minor version number: 1.2 Total amount of global memory: 256 MBytes ( bytes) Mémoire ( 6) Multiprocessors x ( partagée 8) CUDA Cores/MP: 48 CUDA Cores Total amount of shared memory per block: bytes Maximum number of threads per block: 512 Maximum sizes of each dimension of a block: 512 x 512 x 64 Maximum sizes of each dimension of a grid: x x 1
41 26 Sortie de devicequery Detected 1 CUDA Capable device(s) Device 0 : "GeForce GT 330M" CUDA Driver Version / Runtime Version 5.5 / 5.5 CUDA Capability Major/Minor version number: 1.2 Total amount of global memory: 256 MBytes ( bytes) ( 6) Multiprocessors Nombre x ( 8) de CUDA fils Cores/MP: 48 CUDA Cores Total amount of max. shared par memory bloc per block: bytes Maximum number of threads per block: 512 Maximum sizes of each dimension of a block: 512 x 512 x 64 Maximum sizes of each dimension of a grid: x x 1
42 26 Sortie de devicequery Detected 1 CUDA Capable device(s) Device 0 : "GeForce GT 330M" CUDA Driver Version / Runtime Version 5.5 / 5.5 CUDA Capability Major/Minor version number: 1.2 Total amount of global memory: 256 MBytes ( bytes) ( 6) Multiprocessors x ( 8) CUDA Cores/MP: 48 CUDA Cores Total amount of Dimensions shared memory per block: bytes Maximum number of threads per block: 512 maximales Maximum sizes of each dimension of a block: 512 x 512 x 64 Maximum sizes of each dimension of a grid: x x 1
43 27 Flot d'exécution CUDA Code série
44 27 Flot d'exécution CUDA Code série Allocation de mémoire sur le GPU Copie de données vers le GPU Lancement du "kernel"
45 27 Flot d'exécution CUDA Code série Allocation de mémoire sur le GPU Copie de données vers le GPU Lancement du "kernel" Code parallèle Exécution du noyau
46 27 Flot d'exécution CUDA Code série Allocation de mémoire sur le GPU Copie de données vers le GPU Lancement du "kernel" Code parallèle Exécution du noyau Code série Copie des résultats vers l'hôte Libération de la mémoire du GPU
47 V1.0 Gestion de mémoire 28
48 29 Gestion de mémoire
49 29 Gestion de mémoire cudamalloc(void ** devptr, size_t size) Équivalent de malloc en C (new en C++)
50 29 Gestion de mémoire cudamalloc(void ** devptr, size_t size) Équivalent de malloc en C (new en C++) cudafree(void * devptr); Équivalent de free en C (delete en C++)
51 29 Gestion de mémoire cudamalloc(void ** devptr, size_t size) Équivalent de malloc en C (new en C++) cudafree(void * devptr); Équivalent de free en C (delete en C++) cudamemcpy(void * dst, const void * src, size_t size, enum cudamemcpykind kind); cudamemcpyhosttohost cudamemcpyhosttodevice cudamemcpydevicetohost
52 V1.0 Quiz sur les pointeurs et la gestion de mémoire 30
53 31 Sortie 1 de 3 global void add2(int *a) { *a = *a + 2; int main( void ) { int *data_h, *data_d; cudamalloc((void**)&data_d, sizeof(int)); data_h = (int *)malloc(sizeof(int)); *data_h = 5; cudamemcpy(data_d, data_h, sizeof(int), cudamemcpyhosttodevice); add2<<<1,1>>>(data_d); cudamemcpy(data_h, data_d, sizeof(int), cudamemcpydevicetohost); printf("data: %d\n", *data_h); free(data_h); cudafree(data_d); return 0; A. data: 5 B. data: 7 C. Erreur ou segfault D. Ne compile pas E. Autre
54 31 Sortie 1 de 3 global void add2(int *a) { *a = *a + 2; int main( void ) { int *data_h, *data_d; cudamalloc((void**)&data_d, sizeof(int)); data_h = (int *)malloc(sizeof(int)); *data_h = 5; cudamemcpy(data_d, data_h, sizeof(int), cudamemcpyhosttodevice); add2<<<1,1>>>(data_d); cudamemcpy(data_h, data_d, sizeof(int), cudamemcpydevicetohost); printf("data: %d\n", *data_h); free(data_h); cudafree(data_d); return 0; A. data: 5 B. data: 7 C. Erreur ou segfault D. Ne compile pas E. Autre
55 31 Sortie 1 de 3 global void add2(int *a) { *a = *a + 2; int main( void ) { int *data_h, *data_d; cudamalloc((void**)&data_d, sizeof(int)); data_h = (int *)malloc(sizeof(int)); *data_h = 5; cudamemcpy(data_d, data_h, sizeof(int), cudamemcpyhosttodevice); add2<<<1,1>>>(data_d); cudamemcpy(data_h, data_d, sizeof(int), cudamemcpydevicetohost); printf("data: %d\n", *data_h); free(data_h); cudafree(data_d); return 0; A. data: 5 B. data: 7 C. Erreur ou segfault D. Ne compile pas E. Autre
56 31 Sortie 1 de 3 global void add2(int *a) { *a = *a + 2; int main( void ) { int *data_h, *data_d; cudamalloc((void**)&data_d, sizeof(int)); data_h = (int *)malloc(sizeof(int)); *data_h = 5; cudamemcpy(data_d, data_h, sizeof(int), cudamemcpyhosttodevice); add2<<<1,1>>>(data_d); cudamemcpy(data_h, data_d, sizeof(int), cudamemcpydevicetohost); printf("data: %d\n", *data_h); free(data_h); cudafree(data_d); return 0; A. data: 5 B. data: 7 C. Erreur ou segfault D. Ne compile pas E. Autre
57 31 Sortie 1 de 3 global void add2(int *a) { *a = *a + 2; int main( void ) { int *data_h, *data_d; cudamalloc((void**)&data_d, sizeof(int)); data_h = (int *)malloc(sizeof(int)); *data_h = 5; cudamemcpy(data_d, data_h, sizeof(int), cudamemcpyhosttodevice); add2<<<1,1>>>(data_d); cudamemcpy(data_h, data_d, sizeof(int), cudamemcpydevicetohost); printf("data: %d\n", *data_h); free(data_h); cudafree(data_d); return 0; A. data: 5 B. data: 7 C. Erreur ou segfault D. Ne compile pas E. Autre
58 31 Sortie 1 de 3 global void add2(int *a) { *a = *a + 2; int main( void ) { int *data_h, *data_d; cudamalloc((void**)&data_d, sizeof(int)); data_h = (int *)malloc(sizeof(int)); *data_h = 5; cudamemcpy(data_d, data_h, sizeof(int), cudamemcpyhosttodevice); add2<<<1,1>>>(data_d); cudamemcpy(data_h, data_d, sizeof(int), cudamemcpydevicetohost); printf("data: %d\n", *data_h); free(data_h); cudafree(data_d); return 0; A. data: 5 B. data: 7 C. Erreur ou segfault D. Ne compile pas E. Autre
59 31 Sortie 1 de 3 global void add2(int *a) { *a = *a + 2; int main( void ) { int *data_h, *data_d; cudamalloc((void**)&data_d, sizeof(int)); data_h = (int *)malloc(sizeof(int)); *data_h = 5; cudamemcpy(data_d, data_h, sizeof(int), cudamemcpyhosttodevice); add2<<<1,1>>>(data_d); cudamemcpy(data_h, data_d, sizeof(int), cudamemcpydevicetohost); printf("data: %d\n", *data_h); free(data_h); cudafree(data_d); return 0; A. data: 5 B. data: 7 C. Erreur ou segfault D. Ne compile pas E. Autre
60 31 Sortie 1 de 3 global void add2(int *a) { *a = *a + 2; int main( void ) { int *data_h, *data_d; cudamalloc((void**)&data_d, sizeof(int)); data_h = (int *)malloc(sizeof(int)); *data_h = 5; cudamemcpy(data_d, data_h, sizeof(int), cudamemcpyhosttodevice); add2<<<1,1>>>(data_d); cudamemcpy(data_h, data_d, sizeof(int), cudamemcpydevicetohost); printf("data: %d\n", *data_h); free(data_h); cudafree(data_d); return 0; A. data: 5 B. B. data: 77 C. Erreur ou segfault D. Ne compile pas E. Autre
61 32 Sortie 2 de 3 global void add2(int *a) { *a = *a + 2; int main( void ) { int *data_h, *data_d; cudamalloc((void**)&data_d, sizeof(int)); data_h = (int *)malloc(sizeof(int)); *data_h = 5; /* cudamemcpy(data_d, data_h, sizeof(int), cudamemcpyhosttodevice); */ add2<<<1,1>>>(data_d); cudamemcpy(data_h, data_d, sizeof(int), cudamemcpydevicetohost); printf("data: %d\n", *data_h); free(data_h); cudafree(data_d); return 0; A. data: 5 B. data: 7 C. Erreur ou segfault D. Ne compile pas E. Autre
62 32 Sortie 2 de 3 global void add2(int *a) { *a = *a + 2; int main( void ) { int *data_h, *data_d; cudamalloc((void**)&data_d, sizeof(int)); data_h = (int *)malloc(sizeof(int)); *data_h = 5; /* cudamemcpy(data_d, data_h, sizeof(int), cudamemcpyhosttodevice); */ add2<<<1,1>>>(data_d); cudamemcpy(data_h, data_d, sizeof(int), cudamemcpydevicetohost); printf("data: %d\n", *data_h); free(data_h); cudafree(data_d); return 0; A. data: 5 B. data: 7 C. Erreur ou segfault D. Ne compile pas E. Autre E. Autre
63 33 Sortie 3 de 3 global void add2(int *a) { *a = *a + 2; int main( void ) { int *data_h, *data_d; cudamalloc((void**)&data_d, sizeof(int)); data_h = (int *)malloc(sizeof(int)); *data_h = 5; cudamemcpy(data_d, data_h, sizeof(int), cudamemcpyhosttodevice); add2<<<1,1>>>(data_d); cudamemcpy(data_h, data_d, sizeof(int), cudamemcpydevicetohost); printf("data: %d\n", *data_d); free(data_h); cudafree(data_d); return 0; A. data: 5 B. data: 7 C. Erreur ou segfault D. Ne compile pas E. Autre
64 33 Sortie 3 de 3 global void add2(int *a) { *a = *a + 2; int main( void ) { int *data_h, *data_d; cudamalloc((void**)&data_d, sizeof(int)); data_h = (int *)malloc(sizeof(int)); *data_h = 5; cudamemcpy(data_d, data_h, sizeof(int), cudamemcpyhosttodevice); add2<<<1,1>>>(data_d); cudamemcpy(data_h, data_d, sizeof(int), cudamemcpydevicetohost); printf("data: %d\n", *data_d); free(data_h); cudafree(data_d); return 0; A. data: 5 B. data: 7 C. Erreur ou segfault D. Ne compile pas E. Autre
65 V1.0 Calcul d'index 34
66 35 Code minimal global void foo() { int main() { foo<<< 1, 1 >>>();
67 35 Code minimal global void foo() {? int main() { foo<<< 1, 1 >>>();
68 35 Code minimal global void foo() { int main() { foo<<< 1, 1 >>>(); Taille de la grille (nombre de blocs)
69 35 Code minimal global void foo() { int main() { foo<<< 1, 1 >>>(); Taille d un bloc (nombre de threads)
70 36 Grille? Bloc?
71 36 Grille? Bloc? Kernel = grille de blocs de threads (dimensions fixes)
72 36 Grille? Bloc? Kernel = grille de blocs de threads (dimensions fixes) Grille = tableau 3D de blocs uniformes
73 36 Grille? Bloc? Kernel = grille de blocs de threads (dimensions fixes) Grille = tableau 3D de blocs uniformes Bloc = tableau 3D de threads
74 36 Grille? Bloc? Kernel = grille de blocs de threads (dimensions fixes) Grille = tableau 3D de blocs uniformes Bloc = tableau 3D de threads 1 bloc = max 1024 threads
75 36 Grille? Bloc? Kernel = grille de blocs de threads (dimensions fixes) Grille = tableau 3D de blocs uniformes Bloc = tableau 3D de threads 1 bloc = max 1024 threads 1 bloc = 1 SM (streaming multiprocessor), plusieurs «warps»
76 36 Grille? Bloc? Kernel = grille de blocs de threads (dimensions fixes) Grille = tableau 3D de blocs uniformes Bloc = tableau 3D de threads 1 bloc = max 1024 threads 1 bloc = 1 SM (streaming multiprocessor), plusieurs «warps» 1 warp = SIMD (single instruction, multiple data)
77 37 Calcul d'index Le programmeur défini le nombre de bloc dans la grille, puis le nombre de threads par bloc Le code du kernel connait son identifiant de thread, son identifiant de bloc et la taille de ce dernier thread ID Block 0 Block 1 Block 2 Taille d'un block: 6 kernel<<<3, 6>>> ()
78 38 Calcul d'index thread ID Taille d'un block: 6 Block 0 Block 1 Block 2 kernel<<<3, 6>>> ()
79 38 Calcul d'index thread ID Block 0 Block 1 Block 2 Taille d'un block: 6 kernel<<<3, 6>>> () threadidx.x Numéro du fil d'exécution dans le block
80 38 Calcul d'index thread ID Taille d'un block: 6 Block 0 Block 1 Block 2 blockidx.x Numéro du block kernel<<<3, 6>>> () threadidx.x Numéro du fil d'exécution dans le block
81 38 Calcul d'index thread ID Taille d'un block: 6 Block 0 Block 1 Block 2 blockdim.x Dimension d'un block (équivalent au nombre de thread par block) blockidx.x Numéro du block kernel<<<3, 6>>> () threadidx.x Numéro du fil d'exécution dans le block
82 39 Calcul d'index Quelle expression permet de calculer l'index (unique) pour chaque fil d'exécution? A. idx = threadidx.x + blockidx.x B. idx = threadidx.x * blockidx.x C. idx = threadidx.x * blockdim.x + blockidx.x D. idx = threadidx.x + blockdim.x * blockidx.x
83 39 Calcul d'index Quelle expression permet de calculer l'index (unique) pour chaque fil d'exécution? A. idx = threadidx.x + blockidx.x B. idx = threadidx.x * blockidx.x C. idx = threadidx.x * blockdim.x + blockidx.x D. idx = threadidx.x + blockdim.x * blockidx.x
84 40 Exercice 3 : remplir un vecteur Fichier Description integers.cu Déplacer le code pour remplir un vecteur du CPU vers le GPU
85 40 Exercice 3 : remplir un vecteur Fichier Description integers.cu Déplacer le code pour remplir un vecteur du CPU vers le GPU Indice : N'oubliez-pas de copier les résultats vers l'hôte
86 41 Exercice 3 : remplir un vecteur Solution 1 #define BLOCK_SIZE 1 const int N = 100; fillarray<<<n, BLOCK_SIZE>>>( );
87 41 Exercice 3 : remplir un vecteur? Solution 1 #define BLOCK_SIZE 1 const int N = 100; const uint32_t N = ; fillarray<<<n, BLOCK_SIZE>>>( );
88 41 Exercice 3 : remplir un vecteur Solution 1 #define BLOCK_SIZE 1 const int N = 100; const uint32_t N = ; fillarray<<<n, BLOCK_SIZE>>>( ); Maximum sizes of each dimension of a grid: x x /deviceQuery
89 42 Exercice 3 : remplir un vecteur Solution 2 #define BLOCK_SIZE 128 const int N = 100; fillarray<<<n/block_size, BLOCK_SIZE>>>( );
90 42 Exercice 3 : remplir un vecteur Solution 2 #define BLOCK_SIZE 128 const int N = 100; fillarray<<<n/block_size, BLOCK_SIZE>>>( ); $./integers integers: integers.cu:39: int main(int, char**): Assertion `data[i] == i' failed. Abandon (core dumped)?
91 42 Exercice 3 : remplir un vecteur Solution 2 N/BLOCK_SIZE est une division entière #define BLOCK_SIZE 128 const int N = 100; fillarray<<<n/block_size, BLOCK_SIZE>>>( ); $./integers integers: integers.cu:39: int main(int, char**): Assertion `data[i] == i' failed. Abandon (core dumped)
92 43 Exercice 3 : remplir un vecteur Solution 3 #define BLOCK_SIZE 128 global void fillarray(int *data, int N) { int idx = threadidx.x + blockidx.x*blockdim.x; data[idx] = idx; const int N = 100; fillarray<<<(n+block_size-1)/block_size, BLOCK_SIZE>>>( );
93 43 Exercice 3 : remplir un vecteur Solution 3 #define BLOCK_SIZE 128 global void fillarray(int *data, int N) { int idx = threadidx.x + blockidx.x*blockdim.x; data[idx] = idx; const int N = 100; fillarray<<<(n+block_size-1)/block_size, BLOCK_SIZE>>>( ); A. $./integers B. Correct! Vraiment?
94 43 Exercice 3 : remplir un vecteur Solution 3 #define BLOCK_SIZE 128 global void fillarray(int *data, int N) { int idx = threadidx.x + blockidx.x*blockdim.x; data[idx] = idx; idx = {0 128 idx > 99 écrase de la mémoire qui ne nous appartient pas. const int N = 100; fillarray<<<(n+block_size-1)/block_size, BLOCK_SIZE>>>( ); A. $./integers B. Correct!
95 44 Exercice 3 : remplir un vecteur Solution 4 (valide) #define BLOCK_SIZE 128 global void fillarray(int *data, int N) { int idx = threadidx.x + blockidx.x*blockdim.x; if (idx < N) { data[idx] = idx; const int N = 100; fillarray<<<(n+block_size-1)/block_size, BLOCK_SIZE>>>( );
96 45 Exercice 4 : multiplication de matrices Fichiers matrixmul.cu matrixmul_med.cu matrixmul_adv.cu Description Compléter, à l'aide des fonctions CUDA, le programme de multiplication de matrices
97 46 Division de la grille dim3 dimblock(block_size,block_size); dim3 dimgrid(msize/block_size,msize/block_size); MatMulKernel<<<dimGrid,dimBlock>>>(d_A, d_b, d_c);
98 47 Exercice 4 : algorithme Thread 0, Block 0, idx = 0, idy=0, MSIZE = for (int i = 0; i < MSIZE; ++i) { Cvalue += A[row * MSIZE + i] * B[i * MSIZE + col]; C[row * MSIZE + col] = Cvalue; Thread 3, Block 1, idx = 1, idy=1, MSIZE =
99 47 Exercice 4 : algorithme Thread 0, Block 0, idx = 0, idy=0, MSIZE = for (int i = 0; i < MSIZE; ++i) { Cvalue += A[row * MSIZE + i] * B[i * MSIZE + col]; C[row * MSIZE + col] = Cvalue; Thread 3, Block 1, idx = 1, idy=1, MSIZE =
100 47 Exercice 4 : algorithme Thread 0, Block 0, idx = 0, idy=0, MSIZE = for (int i = 0; i < MSIZE; ++i) { Cvalue += A[row * MSIZE + i] * B[i * MSIZE + col]; C[row * MSIZE + col] = Cvalue; Thread 3, Block 1, idx = 1, idy=1, MSIZE =
101 47 Exercice 4 : algorithme Thread 0, Block 0, idx = 0, idy=0, MSIZE = for (int i = 0; i < MSIZE; ++i) { Cvalue += A[row * MSIZE + i] * B[i * MSIZE + col]; C[row * MSIZE + col] = Cvalue; Thread 3, Block 1, idx = 1, idy=1, MSIZE =
102 47 Exercice 4 : algorithme Thread 0, Block 0, idx = 0, idy=0, MSIZE = for (int i = 0; i < MSIZE; ++i) { Cvalue += A[row * MSIZE + i] * B[i * MSIZE + col]; C[row * MSIZE + col] = Cvalue; Thread 3, Block 1, idx = 1, idy=1, MSIZE =
103 47 Exercice 4 : algorithme Thread 0, Block 0, idx = 0, idy=0, MSIZE = for (int i = 0; i < MSIZE; ++i) { Cvalue += A[row * MSIZE + i] * B[i * MSIZE + col]; C[row * MSIZE + col] = Cvalue; Thread 3, Block 1, idx = 1, idy=1, MSIZE =
104 47 Exercice 4 : algorithme Thread 0, Block 0, idx = 0, idy=0, MSIZE = for (int i = 0; i < MSIZE; ++i) { Cvalue += A[row * MSIZE + i] * B[i * MSIZE + col]; C[row * MSIZE + col] = Cvalue; Thread 3, Block 1, idx = 1, idy=1, MSIZE =
105 48 Exercice 4 : multiplication de matrices global void MatMulKernel(float* A, float* B, float* C) { int col = threadidx.x + blockidx.x * blockdim.x; int row = threadidx.y + blockidx.y * blockdim.y; // Compute the row and column for (int i = 0; i < MSIZE; ++i) { Cvalue += A[row * MSIZE + i] * B[i * MSIZE + col]; C[row*MSIZE+col] = Cvalue;
106 V1.0 Vérification des erreurs 49
107 50 Vérification des erreurs Toutes les fonctions Cuda retournent un «cudaerror_t» Doit être égal à «cudasuccess» pour être sans erreur cudagetlasterror() retourne la dernière erreur (pour les kernels) Appeler cudadevicesynchronize() pour attendre après un kernel
108 51 Exercice 5 : vérification des erreurs Fichier Description errorcheck.cu Ajouter des vérifications d'erreurs CUDA dans le code. Corriger les erreurs.
109 51 Exercice 5 : vérification des erreurs Fichier Description errorcheck.cu Ajouter des vérifications d'erreurs CUDA dans le code. Corriger les erreurs. Indice : À première vue, ce programme compile et s'exécute sans erreur. Vérifiez bien tous les retours d'appels CUDA-C.
110 52 Exercice 5 : solution int main(void) { int *data_d = 0, *data_h = 0; cudaerror_t err; if ((err = cudamalloc((void**)&data_d, sizeof(int)))!= cudasuccess) { printf("could not allocate that much memory. \n%s",cudageterrorstring(err)); exit(1); setdata<<<1,1>>>(0); cudadevicesynchronize(); err = cudagetlasterror(); if (err!= cudasuccess) { printf("error calling setdata. \n%s",cudageterrorstring(err)); goto cleanup; cleanup: if ((err = cudafree(data_d))!= cudasuccess) { printf("could not free memory (free #1) \n%s",cudageterrorstring(err)); exit(1);
111 52 Initialisation des pointeurs à 0 Exercice 5 : solution int main(void) { int *data_d = 0, *data_h = 0; cudaerror_t err; if ((err = cudamalloc((void**)&data_d, sizeof(int)))!= cudasuccess) { printf("could not allocate that much memory. \n%s",cudageterrorstring(err)); exit(1); setdata<<<1,1>>>(0); cudadevicesynchronize(); err = cudagetlasterror(); if (err!= cudasuccess) { printf("error calling setdata. \n%s",cudageterrorstring(err)); goto cleanup; cleanup: if ((err = cudafree(data_d))!= cudasuccess) { printf("could not free memory (free #1) \n%s",cudageterrorstring(err)); exit(1);
112 52 Exercice 5 : solution int main(void) { int *data_d = 0, *data_h = 0; cudaerror_t err; Type de retour des fonctions CUDA if ((err = cudamalloc((void**)&data_d, sizeof(int)))!= cudasuccess) { printf("could not allocate that much memory. \n%s",cudageterrorstring(err)); exit(1); setdata<<<1,1>>>(0); cudadevicesynchronize(); err = cudagetlasterror(); if (err!= cudasuccess) { printf("error calling setdata. \n%s",cudageterrorstring(err)); goto cleanup; cleanup: if ((err = cudafree(data_d))!= cudasuccess) { printf("could not free memory (free #1) \n%s",cudageterrorstring(err)); exit(1);
113 52 Exercice 5 : solution int main(void) { int *data_d = 0, *data_h = 0; cudaerror_t err; if ((err = cudamalloc((void**)&data_d, sizeof(int)))!= cudasuccess) { printf("could not allocate that much memory. \n%s",cudageterrorstring(err)); exit(1); setdata<<<1,1>>>(0); cudadevicesynchronize(); err = cudagetlasterror(); if (err!= cudasuccess) { printf("error calling setdata. \n%s",cudageterrorstring(err)); goto cleanup; Valeur toujours attendue cleanup: if ((err = cudafree(data_d))!= cudasuccess) { printf("could not free memory (free #1) \n%s",cudageterrorstring(err)); exit(1);
114 52 Exercice 5 : solution int main(void) { int *data_d = 0, *data_h = 0; cudaerror_t err; if ((err = cudamalloc((void**)&data_d, sizeof(int)))!= cudasuccess) { printf("could not allocate that much memory. \n%s",cudageterrorstring(err)); exit(1); setdata<<<1,1>>>(0); cudadevicesynchronize(); err = cudagetlasterror(); if (err!= cudasuccess) { printf("error calling setdata. \n%s",cudageterrorstring(err)); goto cleanup; Important après l appel d un kernel pour vérifier les erreurs cleanup: if ((err = cudafree(data_d))!= cudasuccess) { printf("could not free memory (free #1) \n%s",cudageterrorstring(err)); exit(1);
115 52 Exercice 5 : solution int main(void) { int *data_d = 0, *data_h = 0; cudaerror_t err; if ((err = cudamalloc((void**)&data_d, sizeof(int)))!= cudasuccess) { printf("could not allocate that much memory. \n%s",cudageterrorstring(err)); exit(1); setdata<<<1,1>>>(0); cudadevicesynchronize(); err = cudagetlasterror(); if (err!= cudasuccess) { printf("error calling setdata. \n%s",cudageterrorstring(err)); goto cleanup; Erreur précédente cleanup: if ((err = cudafree(data_d))!= cudasuccess) { printf("could not free memory (free #1) \n%s",cudageterrorstring(err)); exit(1);
116 53 Exercice 6 : produit scalaire Fichier Description Aucun Penser un algorithme parallèle de produit scalaire Lister les problèmes rencontrés
117 53 Exercice 6 : produit scalaire Fichier Description Aucun Penser un algorithme parallèle de produit scalaire Lister les problèmes rencontrés Pseudocode global void dot( float *a, float *b, float *c) { c = a0b0 + a 1 b1 + a2b anbn;
118 54 Solution possible global void dot( float *a, float *b, float *c) { if(threadidx.x + blockidx.x*blockdim.x == 0) { for(int i = 0; i < N; i++) { *c += a[i]*b[i];
119 54 Solution possible global void dot( float *a, float *b, float *c) { if(threadidx.x + blockidx.x*blockdim.x == 0) { for(int i = 0; i < N; i++) { *c += a[i]*b[i]; Problème 1 : N'utilise pas le parallélisme
120 54 Solution possible global void dot( float *a, float *b, float *c) { if(threadidx.x + blockidx.x*blockdim.x == 0) { for(int i = 0; i < N; i++) { *c += a[i]*b[i]; Problème 1 : N'utilise pas le parallélisme Problème 2 : Comment stocker les valeurs intermédiaires
121 54 Solution possible global void dot( float *a, float *b, float *c) { if(threadidx.x + blockidx.x*blockdim.x == 0) { for(int i = 0; i < N; i++) { *c += a[i]*b[i]; Problème 1 : N'utilise pas le parallélisme Problème 2 : Comment stocker les valeurs intermédiaires Problème 3 : Comment effectuer la somme (réduction)
122 55 Rappel : réduction La réduction consiste à appliquer une fonction d'aggrégation (exemple: sum) à un ensemble de valeurs pour en retirer une seule valeur de retour.
123 56 Types de mémoire
124 57 Types de mémoire Type Bande Visibilité Notes Exemple passante Mémoire Lente, latence Tous les fils cudamalloc() device float data[n]; globale élevée d'exécution Mémoire Lente, avec Tous les fils Lecture seule constant float constante cache d'exécution data[n]; Mémoire 150x plus Fils d'exécution Durée de vie shared data[n]; partagée rapide que la d'un même bloc limitée. 50kb/ mémoire bloc globale Registre Plus rapide, Fil d'exécution Limité float data[n]; pas de latence courant (visibilité, espace, durée)
125 58 Stratégie de réduction Multiplications parallèles Réductions successives (additions)
126 59 Types de mémoire Type Bande Visibilité Notes Exemple passante Mémoire Lente, latence Tous les fils cudamalloc() device float data[n]; globale élevée d'exécution Mémoire Lente, avec Tous les fils Lecture seule constant float constante cache d'exécution data[n]; Mémoire 150x plus Fils d'exécution Durée de vie shared data[n]; partagée rapide que la d'un même bloc limitée. 50kb/ mémoire bloc globale Registre Plus rapide, Fil d'exécution Limité float data[n]; pas de latence courant (visibilité, espace, durée)
127 60 Rappel : race condition Deux ou plusieurs fils sont en concurrence pour mettre à jour une valeur partagée 1. #define ARRAY_SIZE global shiftl(int *array) { 3. int idx = threadidx.x; 4. tmp = array[idx]; 5. if (idx == 0) 6. array[array_size-1] = tmp; 7. else 8. array[idx-1] = tmp; 9.
128 61 Rappel : race condition 1. #define ARRAY_SIZE global shiftl(int *array) { 3. int idx = threadidx.x; 4. tmp = array[idx]; 5. if (idx == 0) 6. array[array_size-1] = tmp; 7. else 8. array[idx-1] = tmp; 9. Fil d'exécution 0 Fil d'exécution 1 Fil d'exécution 2 Note Calcul d'index Copie de la valeur dans un registre Écriture de la nouvelle valeur
129 61 Rappel : race condition 1. #define ARRAY_SIZE global shiftl(int *array) { 3. int idx = threadidx.x; 4. tmp = array[idx]; 5. if (idx == 0) 6. array[array_size-1] = tmp; 7. else 8. array[idx-1] = tmp; 9. Fil d'exécution 0 Fil d'exécution 1 Fil d'exécution 2 Note Calcul d'index Copie de la valeur dans un registre Écriture de la nouvelle valeur
130 61 Rappel : race condition 1. #define ARRAY_SIZE global shiftl(int *array) { 3. int idx = threadidx.x; 4. tmp = array[idx]; 5. if (idx == 0) 6. array[array_size-1] = tmp; 7. else 8. array[idx-1] = tmp; 9. Fil d'exécution 0 Fil d'exécution 1 Fil d'exécution 2 Note Calcul d'index Copie de la valeur dans un registre Écriture de la nouvelle valeur
131 61 Rappel : race condition 1. #define ARRAY_SIZE global shiftl(int *array) { 3. int idx = threadidx.x; 4. tmp = array[idx]; 5. if (idx == 0) 6. array[array_size-1] = tmp; 7. else 8. array[idx-1] = tmp; 9. Fil d'exécution 0 Fil d'exécution 1 Fil d'exécution 2 Note Calcul d'index Copie de la valeur dans un registre Écriture de la nouvelle valeur
132 62 Rappel : race condition 1. #define ARRAY_SIZE global shiftl(int *array) { 3. int idx = threadidx.x; 4. tmp = array[idx]; 5. if (idx == 0) 6. array[array_size-1] = tmp; 7. else 8. array[idx-1] = tmp; 9. Fil d'exécution 1 Fil d'exécution 2 Note Calcul d'index 4. Copie de la valeur dans un registre (fil 2) 8. Écriture de la nouvelle valeur (fil 2) 4. Copie de la (mauvaise) valeur dans un registre (fil 1) 8. Écriture de la (mauvaise) nouvelle valeur (fil 1)
133 62 Rappel : race condition 1. #define ARRAY_SIZE global shiftl(int *array) { 3. int idx = threadidx.x; 4. tmp = array[idx]; 5. if (idx == 0) 6. array[array_size-1] = tmp; 7. else 8. array[idx-1] = tmp; 9. Fil d'exécution 1 Fil d'exécution 2 Note Calcul d'index 4. Copie de la valeur dans un registre (fil 2) 8. Écriture de la nouvelle valeur (fil 2) 4. Copie de la (mauvaise) valeur dans un registre (fil 1) 8. Écriture de la (mauvaise) nouvelle valeur (fil 1) 1,2
134 62 Rappel : race condition 1. #define ARRAY_SIZE global shiftl(int *array) { 3. int idx = threadidx.x; 4. tmp = array[idx]; 5. if (idx == 0) 6. array[array_size-1] = tmp; 7. else 8. array[idx-1] = tmp; Fil d'exécution 1 Fil d'exécution 2 Note Calcul d'index 4. Copie de la valeur dans un registre (fil 2) 8. Écriture de la nouvelle valeur (fil 2) 4. Copie de la (mauvaise) valeur dans un registre (fil 1) 8. Écriture de la (mauvaise) nouvelle valeur (fil 1)
135 62 Rappel : race condition 1. #define ARRAY_SIZE global shiftl(int *array) { 3. int idx = threadidx.x; 4. tmp = array[idx]; 5. if (idx == 0) 6. array[array_size-1] = tmp; 7. else 8. array[idx-1] = tmp; Fil d'exécution 1 Fil d'exécution 2 Note Calcul d'index 4. Copie de la valeur dans un registre (fil 2) 8. Écriture de la nouvelle valeur (fil 2) 4. Copie de la (mauvaise) valeur dans un registre (fil 1) 8. Écriture de la (mauvaise) nouvelle valeur (fil 1)
136 62 Rappel : race condition 1. #define ARRAY_SIZE global shiftl(int *array) { 3. int idx = threadidx.x; 4. tmp = array[idx]; 5. if (idx == 0) 6. array[array_size-1] = tmp; 7. else 8. array[idx-1] = tmp; 9. 1 Fil d'exécution 1 Fil d'exécution 2 Note Calcul d'index 4. Copie de la valeur dans un registre (fil 2) 8. Écriture de la nouvelle valeur (fil 2) 4. Copie de la (mauvaise) valeur dans un registre (fil 1) 8. Écriture de la (mauvaise) nouvelle valeur (fil 1)
137 62 Rappel : race condition 1. #define ARRAY_SIZE global shiftl(int *array) { 3. int idx = threadidx.x; 4. tmp = array[idx]; 5. if (idx == 0) 6. array[array_size-1] = tmp; 7. else 8. array[idx-1] = tmp; 9. 1 Fil d'exécution 1 Fil d'exécution 2 Note Calcul d'index 4. Copie de la valeur dans un registre (fil 2) 8. Écriture de la nouvelle valeur (fil 2) 4. Copie de la (mauvaise) valeur dans un registre (fil 1) 8. Écriture de la (mauvaise) nouvelle valeur (fil 1)
138 63 Solution?
139 63 Solution? Utiliser un point de synchronisation syncthreads();
140 64 Point de synchronisation, mais où? 1. #define ARRAY_SIZE global shiftl(int *array) { 3. int idx = threadidx.x; 4. tmp = array[idx]; 5. if (idx == 0) 6. array[array_size-1] = tmp; 7. else 8. array[idx-1] = tmp; 9.
141 64 Point de synchronisation, mais où? 1. #define ARRAY_SIZE global shiftl(int *array) { 3. int idx = threadidx.x; 4. tmp = array[idx]; 5. if (idx == 0) 6. array[array_size-1] = tmp; 7. else 8. array[idx-1] = tmp; 9.
142 65 Rappel : race condition 1. #define ARRAY_SIZE global shiftl(int *array) { 3. int idx = threadidx.x; 4. tmp = array[idx]; 5. syncthreads(); 6. if (idx == 0) 7. array[array_size-1] = tmp; 8. else 9. array[idx-1] = tmp; Fil d'exécution 1 Fil d'exécution 2 Note Calcul d'index 4. Copie de la valeur dans un registre (fil 2) 5. Point de synchronisation 4. Copie de la (bonne) valeur dans un registre (fil 1) 5. Point de synchronisation Écriture de la (bonne) nouvelle valeur (fil 1 et 2)
143 65 Rappel : race condition 1. #define ARRAY_SIZE global shiftl(int *array) { 3. int idx = threadidx.x; 4. tmp = array[idx]; 5. syncthreads(); 6. if (idx == 0) 7. array[array_size-1] = tmp; 8. else 9. array[idx-1] = tmp; Fil d'exécution 1 Fil d'exécution 2 Note Calcul d'index 4. Copie de la valeur dans un registre (fil 2) 5. Point de synchronisation 4. Copie de la (bonne) valeur dans un registre (fil 1) 5. Point de synchronisation Écriture de la (bonne) nouvelle valeur (fil 1 et 2) 1,2
144 65 Rappel : race condition 1. #define ARRAY_SIZE global shiftl(int *array) { 3. int idx = threadidx.x; 4. tmp = array[idx]; 5. syncthreads(); 6. if (idx == 0) 7. array[array_size-1] = tmp; 8. else 9. array[idx-1] = tmp; 1 2 Fil d'exécution 1 Fil d'exécution 2 Note Calcul d'index 4. Copie de la valeur dans un registre (fil 2) 5. Point de synchronisation 4. Copie de la (bonne) valeur dans un registre (fil 1) 5. Point de synchronisation Écriture de la (bonne) nouvelle valeur (fil 1 et 2)
145 65 Rappel : race condition 1. #define ARRAY_SIZE global shiftl(int *array) { 3. int idx = threadidx.x; 4. tmp = array[idx]; 5. syncthreads(); 6. if (idx == 0) 7. array[array_size-1] = tmp; 8. else 9. array[idx-1] = tmp; 1 2 Fil d'exécution 1 Fil d'exécution 2 Note Calcul d'index 4. Copie de la valeur dans un registre (fil 2) 5. Point de synchronisation 4. Copie de la (bonne) valeur dans un registre (fil 1) 5. Point de synchronisation Écriture de la (bonne) nouvelle valeur (fil 1 et 2)
146 65 Rappel : race condition 1. #define ARRAY_SIZE global shiftl(int *array) { 3. int idx = threadidx.x; 4. tmp = array[idx]; 5. syncthreads(); 6. if (idx == 0) 7. array[array_size-1] = tmp; 8. else 9. array[idx-1] = tmp; 1 2 Fil d'exécution 1 Fil d'exécution 2 Note Calcul d'index 4. Copie de la valeur dans un registre (fil 2) 5. Point de synchronisation 4. Copie de la (bonne) valeur dans un registre (fil 1) 5. Point de synchronisation Écriture de la (bonne) nouvelle valeur (fil 1 et 2)
147 65 Rappel : race condition 1. #define ARRAY_SIZE global shiftl(int *array) { 3. int idx = threadidx.x; 4. tmp = array[idx]; 5. syncthreads(); 6. if (idx == 0) 7. array[array_size-1] = tmp; 8. else 9. array[idx-1] = tmp; Fil d'exécution 1 Fil d'exécution 2 Note Calcul d'index 4. Copie de la valeur dans un registre (fil 2) 5. Point de synchronisation 4. Copie de la (bonne) valeur dans un registre (fil 1) 5. Point de synchronisation Écriture de la (bonne) nouvelle valeur (fil 1 et 2) 1,2
148 65 Rappel : race condition 1. #define ARRAY_SIZE global shiftl(int *array) { 3. int idx = threadidx.x; 4. tmp = array[idx]; 5. syncthreads(); 6. if (idx == 0) 7. array[array_size-1] = tmp; 8. else 9. array[idx-1] = tmp; 1 2 Fil d'exécution 1 Fil d'exécution 2 Note Calcul d'index 4. Copie de la valeur dans un registre (fil 2) 5. Point de synchronisation 4. Copie de la (bonne) valeur dans un registre (fil 1) 5. Point de synchronisation Écriture de la (bonne) nouvelle valeur (fil 1 et 2)
149 66 Stratégie de réduction
150 66 Stratégie de réduction Points de synchronisations
151 66 Stratégie de réduction Points de synchronisations
152 67 Exercice 7 : implémenter le dot product Fichier Description dotproduct.cu Implémenter l'algorithme parallèle de produit scalaire.
153 67 Exercice 7 : implémenter le dot product Fichier Description dotproduct.cu Implémenter l'algorithme parallèle de produit scalaire. Indice 1 : Utilisez la mémoire partagée (performance)
154 67 Exercice 7 : implémenter le dot product Fichier Description dotproduct.cu Implémenter l'algorithme parallèle de produit scalaire. Indice 1 : Utilisez la mémoire partagée (performance) Indice 2 : N'oubliez-pas la synchronisation
155 68 Exercice 7 : implémenter le dot product global void dotproduct(float *a, float *b, float *c, float *result, int N) { // At best, our K20 card can handle bytes of // shared storage (see devicequery output) // That means 49152/sizeof(float) elements, which is shared float cache[block_size]; int idx = threadidx.x + blockidx.x*blockdim.x; cache[threadidx.x] = (idx < N)? a[idx]*b[idx] : 0.0f; syncthreads(); for (int i = blockdim.x/2; i > 0; i /= 2) { if (threadidx.x < i) { cache[threadidx.x] += cache[threadidx.x+i]; syncthreads(); Filename if (threadidx.x == 0) { c[blockidx.x] = cache[0];
156 68 Exercice 7 : implémenter le dot product global void dotproduct(float *a, float *b, float *c, float *result, int N) { // At best, our K20 card can handle bytes of // shared storage (see devicequery output) // That means 49152/sizeof(float) elements, which is shared float cache[block_size]; int idx = threadidx.x + blockidx.x*blockdim.x; cache[threadidx.x] = (idx < N)? a[idx]*b[idx] : 0.0f; syncthreads(); Filename for (int i = blockdim.x/2; i > 0; i /= 2) { if (threadidx.x < i) { cache[threadidx.x] += cache[threadidx.x+i]; syncthreads(); if (threadidx.x == 0) { c[blockidx.x] = cache[0]; Est-ce que c est complet? Qu arrive-t-il s il y a plusieurs blocs?
157 69 Exercice 7 : implémenter le dot product global void dotproduct(float *a, float *b, float *c, float *result, int N) {... if (threadidx.x == 0) { c[blockidx.x] = cache[0]; Filename syncthreads(); for (int i=0; i<blockdim.x; i++) c[0] += c[i];
158 69 Exercice 7 : implémenter le dot product global void dotproduct(float *a, float *b, float *c, float *result, int N) {... if (threadidx.x == 0) { c[blockidx.x] = cache[0]; Filename syncthreads(); for (int i=0; i<blockdim.x; i++) c[0] += c[i]; Est-ce que ça marcherait?
159 69 Exercice 7 : implémenter le dot product global void dotproduct(float *a, float *b, float *c, float *result, int N) {... if (threadidx.x == 0) { c[blockidx.x] = cache[0]; Filename syncthreads(); for (int i=0; i<blockdim.x; i++) c[0] += c[i]; Est-ce que ça marcherait? Aucune synchronisation possible entre deux blocs à l intérieur d un kernel. La seule façon de synchroniser deux blocs est de lancer deux kernels. => doit finir le calcul sur le CPU ou lancer un autre kernel.
160 V1.0 Cuda 6 : Mémoire unifiée 70
161 71 Cuda 6 : Mémoire unifiée Permet d utiliser le même pointeur sur l hôte et sur le GPU Requiert cartes récentes (Kepler+) On doit compiler avec -arch=sm_35 cudamalloc(void **,size_t); cudamemcpy(h_c,d_c,size_t,cudamemcpydevicet ohost); => cudamallocmanaged(void **,size_t)
162 72 Exercice 8 : multiplication matricielle + mémoire unifiée Fichier Description matrixmul.cu Allouer la mémoire avec cudamallocmanaged et modifier MatMul pour en tenir compte
163 73 Solution (partie 1) // Allocate space for the matrices mata = (float *) malloc(size); matb = (float *) malloc(size); matc = (float *) malloc(size);... free(matc); free(matb); free(mata); // Allocate space for the matrices cudamallocmanaged(mata,size); cudamallocmanaged(matb,size); cudamallocmanaged(matc,size);... cudafree(matc); cudafree(matb); cudafree(mata);
164 74 Solution (partie 2) void MatMul(float* A, float* B, float* C) { float *d_a = 0; size_t size = MSIZE * MSIZE * sizeof(float); // TODO : Remove all memory management calls // Allocate space for matrix A on device cudamalloc(&d_a, size); // Copy matrix A to device cudamemcpy(d_a, A, size, cudamemcpyhosttodevice); float *d_b = 0; // Allocate space for matrix B on device cudamalloc(&d_b, size); // Copy matrix B to device cudamemcpy(d_b, B, size, cudamemcpyhosttodevice); // Allocate C in device memory float *d_c = 0; cudamalloc(&d_c, size); // Invoke kernel dim3 dimblock(block_size,block_size); dim3 dimgrid(msize/block_size,msize/block_size); MatMulKernel<<<dimGrid,dimBlock>>>(d_A, d_b, d_c); // Read C from device memory cudamemcpy(c, d_c, size, cudamemcpydevicetohost); // Free device memory cudafree(d_a); cudafree(d_b); cudafree(d_c);
165 74 Solution (partie 2) void MatMul(float* A, float* B, float* C) { float *d_a = 0; size_t size = MSIZE * MSIZE * sizeof(float); // TODO : Remove all memory management calls // Allocate space for matrix A on device cudamalloc(&d_a, size); // Copy matrix A to device cudamemcpy(d_a, A, size, cudamemcpyhosttodevice); float *d_b = 0; // Allocate space for matrix B on device cudamalloc(&d_b, size); // Copy matrix B to device cudamemcpy(d_b, B, size, cudamemcpyhosttodevice); // Allocate C in device memory float *d_c = 0; cudamalloc(&d_c, size); // Invoke kernel dim3 dimblock(block_size,block_size); dim3 dimgrid(msize/block_size,msize/block_size); MatMulKernel<<<dimGrid,dimBlock>>>(A,B,C); cudadevicesynchronize(); // Read C from device memory cudamemcpy(c, d_c, size, cudamemcpydevicetohost); // Free device memory cudafree(d_a); cudafree(d_b); cudafree(d_c);
166 74 Solution (partie 2) void MatMul(float* A, float* B, float* C) { float *d_a = 0; size_t size = MSIZE * MSIZE * sizeof(float); // TODO : Remove all memory management calls // Allocate space for matrix A on device cudamalloc(&d_a, size); // Copy matrix A to device cudamemcpy(d_a, A, size, cudamemcpyhosttodevice); float *d_b = 0; // Allocate space for matrix B on device cudamalloc(&d_b, size); // Copy matrix B to device cudamemcpy(d_b, B, size, cudamemcpyhosttodevice); // Allocate C in device memory float *d_c = 0; cudamalloc(&d_c, size); // Invoke kernel dim3 dimblock(block_size,block_size); dim3 dimgrid(msize/block_size,msize/block_size); MatMulKernel<<<dimGrid,dimBlock>>>(A,B,C); cudadevicesynchronize(); // Read C from device memory cudamemcpy(c, d_c, size, cudamemcpydevicetohost);? // Free device memory cudafree(d_a); cudafree(d_b); cudafree(d_c);
167 75 cudadevicesynchronize Par défaut, tous les appels Cuda sont lancés dans le même «stream» (0) Stream : Une séquence d opérations qui s exécutent dans l ordre sur le GPU Kernels cudamemcpy, cudamemset,... Tout est synchrone sur le GPU... sauf la mémoire unifiée.
168 V1.0 Multi-GPU 76
169 77 Contexte Cuda
170 77 Contexte Cuda Toutes les opérations Cuda sont exécutées dans un «contexte Cuda» Un contexte Cuda est associé à un GPU. On change de contexte en appelant cudasetdevice(int devnum); On connaît le nombre de devices avec cudagetdevicecount(int * dev_count);
171 V1.0 Exercice 9 : Multiplications de N matrices 78
172 79 Problématique #1 Performance limitée par l initialisation On doit intialiser sur le GPU Problème : un générateur de nombre aléatoire typique est séquentiel!
173 80 Nombres aléatoires device unsigned int hash(unsigned int x) { x = (x+0x7ed55d16) + (x<<12); x = (x^0xc761c23c) ^ (x>>19); x = (x+0x165667b1) + (x<<5); x = (x+0xd3a2646c) ^ (x<<9); x = (x+0xfd7046c5) + (x<<3); x = (x^0xb55a4f09) ^ (x>>16); return x; global void RandomFillKernel(float * A, unsigned int seed ) { unsigned int idx = threadidx.x + blockidx.x * blockdim.x; A[idx] = float(hash(idx+seed) / UINT_MAX);
174 81 Problématique #2
175 81 Problématique #2 Mémoire unifiée ne fonctionne pas très bien avec plusieurs GPUs
176 81 Problématique #2 Mémoire unifiée ne fonctionne pas très bien avec plusieurs GPUs Quel GPU devrait avoir la priorité sur la mémoire unifiée?
177 81 Problématique #2 Mémoire unifiée ne fonctionne pas très bien avec plusieurs GPUs Quel GPU devrait avoir la priorité sur la mémoire unifiée? Solution : retour aux cudamemcpy, cudamalloc, etc.
178 82 Exercice 9 : multiplication matricielle multi-gpu Fichier Description matrixmul.cu Modifier le code pour qu il s exécute sur 2 GPUs Soumission de tâche Du noeud interactif, faire : prepare_formation job2
179 83 Solution (partie 1) struct timespec ts; int dev_count = 0; cudagetdevicecount(&dev_count); float * matas[n], * matas_h[n]; float * matbs[n], * matbs_h[n]; float * matcs[n], * matcs_h[n];
Introduction à CUDA. gael.guennebaud@inria.fr
36 Introduction à CUDA gael.guennebaud@inria.fr 38 Comment programmer les GPU? Notion de kernel exemple (n produits scalaires): T ci =ai b ( ai, b : vecteurs 3D, ci for(int i=0;i
. Plan du cours. . Architecture: Fermi (2010-12), Kepler (12-?)
Plan du cours Vision mate riel: architecture cartes graphiques NVIDIA INF 560 Calcul Paralle le et Distribue Cours 3 Vision logiciel: l abstraction logique de l architecture propose e par le langage CUDA
Introduction à la programmation des GPUs
Introduction à la programmation des GPUs Anne-Sophie Mouronval Mesocentre de calcul de l Ecole Centrale Paris Laboratoire MSSMat Avril 2013 Anne-Sophie Mouronval Introduction à la programmation des GPUs
Calcul multi GPU et optimisation combinatoire
Année universitaire 2010 2011 Master recherche EEA Spécialité : SAID Systèmes Automatiques, Informatiques et Décisionnels Parcours : Systèmes Automatiques Calcul multi GPU et optimisation combinatoire
Une bibliothèque de templates pour CUDA
Une bibliothèque de templates pour CUDA Sylvain Collange, Marc Daumas et David Defour Montpellier, 16 octobre 2008 Types de parallèlisme de données Données indépendantes n threads pour n jeux de données
Brefs rappels sur la pile et le tas (Stack. / Heap) et les pointeurs
Brefs rappels sur la pile et le tas (Stack / Heap) et les pointeurs (exemples en C) v1.11 - Olivier Carles 1 Pile et Tas Mémoire allouée de manière statique Mémoire Allouée Dynamiquement variables locales
Introduction au calcul parallèle avec OpenCL
Introduction au calcul parallèle avec OpenCL Julien Dehos Séminaire du 05/01/2012 Sommaire Introduction Le calculateur du CGR/LISIC/LMPA Généralités sur OpenCL Modèles Programmation Optimisation Conclusion
Conventions d écriture et outils de mise au point
Logiciel de base Première année par alternance Responsable : Christophe Rippert Christophe.Rippert@Grenoble-INP.fr Introduction Conventions d écriture et outils de mise au point On va utiliser dans cette
DE L ALGORITHME AU PROGRAMME INTRO AU LANGAGE C 51
DE L ALGORITHME AU PROGRAMME INTRO AU LANGAGE C 51 PLAN DU COURS Introduction au langage C Notions de compilation Variables, types, constantes, tableaux, opérateurs Entrées sorties de base Structures de
Segmentation d'images à l'aide d'agents sociaux : applications GPU
Segmentation d'images à l'aide d'agents sociaux : applications GPU Richard MOUSSA Laboratoire Bordelais de Recherche en Informatique (LaBRI) - UMR 5800 Université de Bordeaux - France Laboratoire de recherche
M2-Images. Rendu Temps Réel - OpenGL 4 et compute shaders. J.C. Iehl. December 18, 2013
Rendu Temps Réel - OpenGL 4 et compute shaders December 18, 2013 résumé des épisodes précédents... création des objets opengl, organisation des données, configuration du pipeline, draw,... opengl 4.3 :
Initiation au HPC - Généralités
Initiation au HPC - Généralités Éric Ramat et Julien Dehos Université du Littoral Côte d Opale M2 Informatique 2 septembre 2015 Éric Ramat et Julien Dehos Initiation au HPC - Généralités 1/49 Plan du cours
1. Structure d un programme C. 2. Commentaire: /*..texte */ On utilise aussi le commentaire du C++ qui est valable pour C: 3.
1. Structure d un programme C Un programme est un ensemble de fonctions. La fonction "main" constitue le point d entrée pour l exécution. Un exemple simple : #include int main() { printf ( this
UE Programmation Impérative Licence 2ème Année 2014 2015
UE Programmation Impérative Licence 2 ème Année 2014 2015 Informations pratiques Équipe Pédagogique Florence Cloppet Neilze Dorta Nicolas Loménie prenom.nom@mi.parisdescartes.fr 2 Programmation Impérative
Cours d Algorithmique-Programmation 2 e partie (IAP2): programmation 24 octobre 2007impérative 1 / 44 et. structures de données simples
Cours d Algorithmique-Programmation 2 e partie (IAP2): programmation impérative et structures de données simples Introduction au langage C Sandrine Blazy - 1ère année 24 octobre 2007 Cours d Algorithmique-Programmation
EPREUVE OPTIONNELLE d INFORMATIQUE CORRIGE
EPREUVE OPTIONNELLE d INFORMATIQUE CORRIGE QCM Remarque : - A une question correspond au moins 1 réponse juste - Cocher la ou les bonnes réponses Barème : - Une bonne réponse = +1 - Pas de réponse = 0
Centre CPGE TSI - Safi 2010/2011. Algorithmique et programmation :
Algorithmique et programmation : STRUCTURES DE DONNÉES A. Structure et enregistrement 1) Définition et rôle des structures de données en programmation 1.1) Définition : En informatique, une structure de
Plan du cours 2014-2015. Cours théoriques. 29 septembre 2014
numériques et Institut d Astrophysique et de Géophysique (Bât. B5c) Bureau 0/13 email:.@ulg.ac.be Tél.: 04-3669771 29 septembre 2014 Plan du cours 2014-2015 Cours théoriques 16-09-2014 numériques pour
INITIATION AU LANGAGE C SUR PIC DE MICROSHIP
COURS PROGRAMMATION INITIATION AU LANGAGE C SUR MICROCONTROLEUR PIC page 1 / 7 INITIATION AU LANGAGE C SUR PIC DE MICROSHIP I. Historique du langage C 1972 : naissance du C dans les laboratoires BELL par
Introduction à la Programmation Parallèle: MPI
Introduction à la Programmation Parallèle: MPI Frédéric Gava et Gaétan Hains L.A.C.L Laboratoire d Algorithmique, Complexité et Logique Cours du M2 SSI option PSSR Plan 1 Modèle de programmation 2 3 4
<Insert Picture Here> Solaris pour la base de donnés Oracle
Solaris pour la base de donnés Oracle Alain Chéreau Oracle Solution Center Agenda Compilateurs Mémoire pour la SGA Parallélisme RAC Flash Cache Compilateurs
Bases de programmation. Cours 5. Structurer les données
Bases de programmation. Cours 5. Structurer les données Pierre Boudes 1 er décembre 2014 This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 License. Types char et
I. Introduction aux fonctions : les fonctions standards
Chapitre 3 : Les fonctions en C++ I. Introduction aux fonctions : les fonctions standards A. Notion de Fonction Imaginons que dans un programme, vous ayez besoin de calculer une racine carrée. Rappelons
03/04/2007. Tâche 1 Tâche 2 Tâche 3. Système Unix. Time sharing
3/4/27 Programmation Avancée Multimédia Multithreading Benoît Piranda Équipe SISAR Université de Marne La Vallée Besoin Programmes à traitements simultanés Réseau Réseau Afficher une animation en temps
Programmation système I Les entrées/sorties
Programmation système I Les entrées/sorties DUT 1 re année Université de Marne La vallée Les entrées-sorties : E/O Entrées/Sorties : Opérations d échanges d informations dans un système informatique. Les
Cours Programmation Système
Cours Programmation Système Filière SMI Semestre S6 El Mostafa DAOUDI Département de Mathématiques et d Informatique, Faculté des Sciences Université Mohammed Premier Oujda m.daoudi@fso.ump.ma Février
Optimisations des SGBDR. Étude de cas : MySQL
Optimisations des SGBDR Étude de cas : MySQL Introduction Pourquoi optimiser son application? Introduction Pourquoi optimiser son application? 1. Gestion de gros volumes de données 2. Application critique
Architecture des ordinateurs
Décoder la relation entre l architecture et les applications Violaine Louvet, Institut Camille Jordan CNRS & Université Lyon 1 Ecole «Découverte du Calcul» 2013 1 / 61 Simulation numérique... Physique
Introduction à MATLAB R
Introduction à MATLAB R Romain Tavenard 10 septembre 2009 MATLAB R est un environnement de calcul numérique propriétaire orienté vers le calcul matriciel. Il se compose d un langage de programmation, d
Master première année. Mention : Statistiques et Traitement de Données «STD» Rapport de stage
Université Blaise Pascal UFR Sciences et Technologie Département de Mathématique et Informatique 63177 AUBIERE CEDEXFrance Laboratoire de Météorologie Physique (LaMP) 24 avenue des Landais 63177 Aubière
1/24. I passer d un problème exprimé en français à la réalisation d un. I expressions arithmétiques. I structures de contrôle (tests, boucles)
1/4 Objectif de ce cours /4 Objectifs de ce cours Introduction au langage C - Cours Girardot/Roelens Septembre 013 Du problème au programme I passer d un problème exprimé en français à la réalisation d
Le prototype de la fonction main()
Le prototype de la fonction main() 1. Introduction...1 2. Paramètres et type de retour de la fonction main()...1 3. Exemple 1...2 4. La fonction exit() du C...2 5. Détecter le code de retour d un programme
Introduction à la programmation orientée objet, illustrée par le langage C++ Patrick Cégielski cegielski@u-pec.fr
Introduction à la programmation orientée objet, illustrée par le langage C++ Patrick Cégielski cegielski@u-pec.fr Mars 2002 Pour Irène et Marie Legal Notice Copyright c 2002 Patrick Cégielski Université
Argument-fetching dataflow machine de G.R. Gao et J.B. Dennis (McGill, 1988) = machine dataflow sans flux de données
EARTH et Threaded-C: Éléments clés du manuel de références de Threaded-C Bref historique de EARTH et Threaded-C Ancêtres de l architecture EARTH: Slide 1 Machine à flux de données statique de J.B. Dennis
Exécution des instructions machine
Exécution des instructions machine Eduardo Sanchez EPFL Exemple: le processeur MIPS add a, b, c a = b + c type d'opération (mnémonique) destination du résultat lw a, addr opérandes sources a = mem[addr]
Programmation C. Apprendre à développer des programmes simples dans le langage C
Programmation C Apprendre à développer des programmes simples dans le langage C Notes de cours sont disponibles sur http://astro.u-strasbg.fr/scyon/stusm (attention les majuscules sont importantes) Modalités
Analyse de sécurité de logiciels système par typage statique
Contexte Modélisation Expérimentation Conclusion Analyse de sécurité de logiciels système par typage statique Application au noyau Linux Étienne Millon UPMC/LIP6 Airbus Group Innovations Sous la direction
Initiation. àl algorithmique et à la programmation. en C
Initiation àl algorithmique et à la programmation en C Initiation àl algorithmique et à la programmation en C Cours avec 129 exercices corrigés Illustration de couverture : alwyncooper - istock.com Dunod,
1.6- Génération de nombres aléatoires
1.6- Génération de nombres aléatoires 1- Le générateur aléatoire disponible en C++ 2 Création d'un générateur aléatoire uniforme sur un intervalle 3- Génération de valeurs aléatoires selon une loi normale
Rappels Entrées -Sorties
Fonctions printf et scanf Syntaxe: écriture, organisation Comportement Données hétérogènes? Gestion des erreurs des utilisateurs 17/11/2013 Cours du Langage C ibr_guelzim@yahoo.fr ibrahimguelzim.atspace.co.uk
Techniques de stockage. Techniques de stockage, P. Rigaux p.1/43
Techniques de stockage Techniques de stockage, P. Rigaux p.1/43 Techniques de stockage Contenu de ce cours : 1. Stockage de données. Supports, fonctionnement d un disque, technologie RAID 2. Organisation
INF6500 : Structures des ordinateurs. Sylvain Martel - INF6500 1
INF6500 : Structures des ordinateurs Sylvain Martel - INF6500 1 Cours 4 : Multiprocesseurs Sylvain Martel - INF6500 2 Multiprocesseurs Type SISD SIMD MIMD Communication Shared memory Message-passing Groupe
IN 102 - Cours 1. 1 Informatique, calculateurs. 2 Un premier programme en C
IN 102 - Cours 1 Qu on le veuille ou non, les systèmes informatisés sont désormais omniprésents. Même si ne vous destinez pas à l informatique, vous avez de très grandes chances d y être confrontés en
Génération de code binaire pour application multimedia : une approche au vol
Génération de binaire pour application multimedia : une approche au vol http://hpbcg.org/ Henri-Pierre Charles Université de Versailles Saint-Quentin en Yvelines 3 Octobre 2009 Présentation Présentation
Cours Informatique Master STEP
Cours Informatique Master STEP Bases de la programmation: Compilateurs/logiciels Algorithmique et structure d'un programme Programmation en langage structuré (Fortran 90) Variables, expressions, instructions
Langage Java. Classe de première SI
Langage Java Table des matières 1. Premiers pas...2 1.1. Introduction...2 1.2. Mon premier programme...2 1.3. Les commentaires...2 2. Les variables et les opérateurs...2 3. La classe Scanner...3 4. Les
Cours d initiation à la programmation en C++ Johann Cuenin
Cours d initiation à la programmation en C++ Johann Cuenin 11 octobre 2014 2 Table des matières 1 Introduction 5 2 Bases de la programmation en C++ 7 3 Les types composés 9 3.1 Les tableaux.............................
Journée Utiliateurs 2015. Nouvelles du Pôle ID (Informatique) Pierre Neyron, LIG/CNRS
Journée Utiliateurs 2015 Nouvelles du Pôle ID (Informatique) Pierre Neyron, LIG/CNRS 1 Pôle ID, Grid'5000 Ciment Une proximité des platesformes Autres sites G5K Grenoble + CIMENT Pôle ID = «Digitalis»
Éléments d informatique Cours 3 La programmation structurée en langage C L instruction de contrôle if
Éléments d informatique Cours 3 La programmation structurée en langage C L instruction de contrôle if Pierre Boudes 28 septembre 2011 This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike
Processus! programme. DIMA, Systèmes Centralisés (Ph. Mauran) " Processus = suite d'actions = suite d'états obtenus = trace
Processus 1) Contexte 2) Modèles de Notion de Points de vue Modèle fourni par le SX Opérations sur les 3) Gestion des Représentation des Opérations 4) Ordonnancement des Niveaux d ordonnancement Ordonnancement
Cours d Algorithmique et de Langage C 2005 - v 3.0
Cours d Algorithmique et de Langage C 2005 - v 3.0 Bob CORDEAU cordeau@onera.fr Mesures Physiques IUT d Orsay 15 mai 2006 Avant-propos Avant-propos Ce cours en libre accès repose sur trois partis pris
École Polytechnique de Montréal. Département de Génie Informatique et Génie Logiciel. Cours INF2610. Contrôle périodique.
École Polytechnique de Montréal Département de Génie Informatique et Génie Logiciel Cours INF2610 Contrôle périodique Automne 2013 Date : 11 octobre 2013 de 18h à 20h Professeur : Boucheneb Hanifa Documentation
1 Mesure de la performance d un système temps réel : la gigue
TP TR ENSPS et MSTER 1 Travaux Pratiques Systèmes temps réel et embarqués ENSPS ISV et Master TP1 - Ordonnancement et communication inter-processus (IPC) Environnement de travail Un ordinateur dual-core
Introduction au langage C
Introduction au langage C Cours 1: Opérations de base et premier programme Alexis Lechervy Alexis Lechervy (UNICAEN) Introduction au langage C 1 / 23 Les premiers pas Sommaire 1 Les premiers pas 2 Les
Le Projet BINSEC. Automatiser l analyse de sécurité au niveau binaire. Airbus group, CEA, IRISA, LORIA, Uni. Joseph Fourier. p.
Le Projet BINSEC Automatiser l analyse de sécurité au niveau binaire Airbus group, CEA, IRISA, LORIA, Uni. Joseph Fourier p. 1/22 Introduction Panorama de BINSEC Cadre de travail Projet ANR INS, appel
UE C avancé cours 1: introduction et révisions
Introduction Types Structures de contrôle Exemple UE C avancé cours 1: introduction et révisions Jean-Lou Desbarbieux et Stéphane Doncieux UMPC 2004/2005 Introduction Types Structures de contrôle Exemple
IFT2245 - Systèmes d exploitation - TP n 1-20%
IFT2245 - Systèmes d exploitation - TP n 1-20% DIRO - Université de Montréal Nicolas Rous et Dorian Gomez Disponible : 14/02/2013 - Remise : 28/03/2013 au début de la démo LISEZ TOUT LE DOCUMENT AVANT
Dans le chapitre 1, nous associions aux fichiers ouverts des descripteurs de fichiers par lesquels nous accédions aux fichiers.
I Présentation : Dans le chapitre 1, nous avons vu comment utiliser les appels-systèmes de bas niveau pour créer et accéder à des fichiers sur le disque. Nous avons notamment mis en évidence leur dépouillement
TP n 2 Concepts de la programmation Objets Master 1 mention IL, semestre 2 Le type Abstrait Pile
TP n 2 Concepts de la programmation Objets Master 1 mention IL, semestre 2 Le type Abstrait Pile Dans ce TP, vous apprendrez à définir le type abstrait Pile, à le programmer en Java à l aide d une interface
Outils pour la pratique
Cinquième partie Outils pour la pratique 121 CHAPITRE 1 Les bases des séances de TP Avant de lire cettre section, il est suggéré de relire vos notes de cours se rapportant au système d exploitation Unix.
Cours 7 : Utilisation de modules sous python
Cours 7 : Utilisation de modules sous python 2013/2014 Utilisation d un module Importer un module Exemple : le module random Importer un module Exemple : le module random Importer un module Un module est
OS Réseaux et Programmation Système - C5
OS Réseaux et Programmation Système - C5 Rabie Ben Atitallah rabie.benatitallah@univ-valenciennes.fr RPC - XDR Rappel RPC: Remote Procedure Call Besoin d un environnement de haut niveau pour le développement
Algorithmique et Programmation, IMA
Algorithmique et Programmation, IMA Cours 2 : C Premier Niveau / Algorithmique Université Lille 1 - Polytech Lille Notations, identificateurs Variables et Types de base Expressions Constantes Instructions
Les structures de données. Rajae El Ouazzani
Les structures de données Rajae El Ouazzani Les arbres 2 1- Définition de l arborescence Une arborescence est une collection de nœuds reliés entre eux par des arcs. La collection peut être vide, cad l
6 - Le système de gestion de fichiers F. Boyer, UJF-Laboratoire Lig, Fabienne.Boyer@imag.fr
6 - Le système de gestion de fichiers F. Boyer, UJF-Laboratoire Lig, Fabienne.Boyer@imag.fr Interface d un SGF Implémentation d un SGF Gestion de la correspondance entre la structure logique et la structure
INTRODUCTION A JAVA. Fichier en langage machine Exécutable
INTRODUCTION A JAVA JAVA est un langage orienté-objet pur. Il ressemble beaucoup à C++ au niveau de la syntaxe. En revanche, ces deux langages sont très différents dans leur structure (organisation du
Seance 2: En respectant la méthode de programmation par contrat, implémentez les autres fonctions de jeu.
Seance 2: Complétion du code de jeu. (durée max: 2h) Mot clé const et pointeurs: En respectant la méthode de programmation par contrat, implémentez les autres fonctions de jeu. Implémentez jeu_recupere_piece
IRL : Simulation distribuée pour les systèmes embarqués
IRL : Simulation distribuée pour les systèmes embarqués Yassine El Khadiri, 2 ème année Ensimag, Grenoble INP Matthieu Moy, Verimag Denis Becker, Verimag 19 mai 2015 1 Table des matières 1 MPI et la sérialisation
TP : Gestion d une image au format PGM
TP : Gestion d une image au format PGM Objectif : L objectif du sujet est de créer une classe de manipulation d images au format PGM (Portable GreyMap), et de programmer des opérations relativement simples
Concept de machine virtuelle
Concept de machine virtuelle Chap. 5: Machine virtuelle Alain Sandoz Semestre été 2007 1 Introduction: Java Virtual Machine Machine Virtuelle Java: qu est-ce que c est? c est la spécification d une machine
Cours intensif Java. 1er cours: de C à Java. Enrica DUCHI LIAFA, Paris 7. Septembre 2009. Enrica.Duchi@liafa.jussieu.fr
. Cours intensif Java 1er cours: de C à Java Septembre 2009 Enrica DUCHI LIAFA, Paris 7 Enrica.Duchi@liafa.jussieu.fr LANGAGES DE PROGRAMMATION Pour exécuter un algorithme sur un ordinateur il faut le
Windows Server 2008. Chapitre 1: Découvrir Windows Server 2008
Windows Server 2008 Chapitre 1: Découvrir Windows Server 2008 Objectives Identifier les caractéristiques de chaque édition de Windows Server 2008 Identifier les caractéristiques généraux de Windows Server
SYSTÈME DE GESTION DE FICHIERS
SYSTÈME DE GESTION DE FICHIERS - DISQUE 1 Les couches logiciels réponse requête Requêtes E/S Système E/S Pilote E/S Interruptions utilisateur traitement S.E. commandes S.E. S.E. matériel Contrôleur E/S
Machines Virtuelles. et bazard autour. Rémi Forax
Machines Virtuelles et bazard autour Rémi Forax Avant propos Quelle est la complexité du code ci-dessous? Avec un processeur à 1Ghz, combien de temps le calcul prendra t'il? public static void main(string[]
Guide d'installation et de configuration de Pervasive.SQL 7 dans un environnement réseau Microsoft Windows NT
Guide d'installation et de configuration de Pervasive.SQL 7 dans un environnement réseau Microsoft Windows NT Ce guide explique les différentes étapes de l installation et de la configuration des composantes
Parallélisme et Répartition
Parallélisme et Répartition Master Info Françoise Baude Université de Nice Sophia-Antipolis UFR Sciences Département Informatique baude@unice.fr web du cours : deptinfo.unice.fr/~baude Septembre 2009 Chapitre
Introduction à Java. Matthieu Herrb CNRS-LAAS. Mars 2014. http://homepages.laas.fr/matthieu/cours/java/java.pdf
Introduction à Java Matthieu Herrb CNRS-LAAS http://homepages.laas.fr/matthieu/cours/java/java.pdf Mars 2014 Plan 1 Concepts 2 Éléments du langage 3 Classes et objets 4 Packages 2/28 Histoire et motivations
Tests de performance du matériel
3 Tests de performance du matériel Après toute la théorie du dernier chapitre, vous vous demandez certainement quelles sont les performances réelles de votre propre système. En fait, il y a plusieurs raisons
1. Systèmes d entrée/sortie 2. Systèmes de fichiers 3. Structure de mémoire de masse (disques)
Chapitre 4 Le système de Gestion de Fichiers 1. Systèmes d entrée/sortie 2. Systèmes de fichiers 3. Structure de mémoire de masse (disques) 1 Systèmes d entrée/sortie Concepts importants : Matériel E/S
3IS - Système d'exploitation linux - Programmation système
3IS - Système d'exploitation linux - Programmation système 2010 David Picard Contributions de : Arnaud Revel, Mickaël Maillard picard@ensea.fr Environnement Les programmes peuvent être exécutés dans des
Remote Method Invocation Les classes implémentant Serializable
Parallélisme Architecture Eric Goubault Commissariat à l Energie Atomique Saclay Classe qui implémente la méthode distante (serveur): - dont les méthodes renvoient un objet serializable - ou plus généralement
Cahier des charges. driver WIFI pour chipset Ralink RT2571W. sur hardware ARM7
Cahier des charges driver WIFI pour chipset Ralink RT2571W sur hardware ARM7 RevA 13/03/2006 Création du document Sylvain Huet RevB 16/03/2006 Fusion des fonctions ARP et IP. SH Modification des milestones
Python - introduction à la programmation et calcul scientifique
Université de Strasbourg Environnements Informatique Python - introduction à la programmation et calcul scientifique Feuille de TP 1 Avant de commencer Le but de ce TP est de vous montrer les bases de
SYSTÈME DE GESTION DE FICHIERS SGF - DISQUE
SYSTÈME DE GESTION DE FICHIERS SGF - DISQUE C.Crochepeyre MPS_SGF 2000-20001 Diapason 1 Les couches logiciels réponse SGF requête matériel matériel Requêtes E/S Système E/S Pilote E/S Interruptions Contrôleur
INF111. Initiation à la programmation impérative en C http://ama.liglab.fr/ amini/cours/l1/inf111/ Massih-Reza Amini
Initiation à la programmation impérative en C http://ama.liglab.fr/ amini/cours/l1// Massih-Reza Amini Université Joseph Fourier Laboratoire d Informatique de Grenoble 2/52 Introduction Structures de contrôle
Cours de Programmation Impérative: Zones de mémoires et pointeurs
Cours de Programmation Impérative: Zones de mémoires et pointeurs Julien David A101 - david@lipn.univ-paris13.fr Julien David (A101 - david@lipn.univ-paris13.fr) 1 / 1 Z`o n`e s `d`e m`é m`o i r`e Julien
as Architecture des Systèmes d Information
Plan Plan Programmation - Introduction - Nicolas Malandain March 14, 2005 Introduction à Java 1 Introduction Présentation Caractéristiques Le langage Java 2 Types et Variables Types simples Types complexes
Table des matières PRESENTATION DU LANGAGE DS2 ET DE SES APPLICATIONS. Introduction
PRESENTATION DU LANGAGE DS2 ET DE SES APPLICATIONS Depuis SAS 9.2 TS2M3, SAS propose un nouveau langage de programmation permettant de créer et gérer des tables SAS : le DS2 («Data Step 2»). Ces nouveautés
Cours de C. Petits secrets du C & programmation avancée. Sébastien Paumier
Cours de C Petits secrets du C & programmation avancée Sébastien Paumier paumier@univ-mlv.fr Illustrations provenant du site http://tux.crystalxp.net/ 1 Affectations étendues a+=expression a=a+expression
Prénom : Matricule : Sigle et titre du cours Groupe Trimestre INF1101 Algorithmes et structures de données Tous H2004. Loc Jeudi 29/4/2004
Questionnaire d'examen final INF1101 Sigle du cours Nom : Signature : Prénom : Matricule : Sigle et titre du cours Groupe Trimestre INF1101 Algorithmes et structures de données Tous H2004 Professeur(s)
OpenPaaS Le réseau social d'entreprise
OpenPaaS Le réseau social d'entreprise Spécification des API datastore SP L2.3.1 Diffusion : Institut MinesTélécom, Télécom SudParis 1 / 12 1OpenPaaS DataBase API : ODBAPI...3 1.1Comparaison des concepts...3
Temps Réel. Jérôme Pouiller <j.pouiller@sysmic.org> Septembre 2011
Temps Réel Jérôme Pouiller Septembre 2011 Sommaire Problèmatique Le monotâche Le multitâches L ordonnanement Le partage de ressources Problèmatiques des OS temps réels J. Pouiller
Architecture des calculateurs
Formation en Calcul Scientifique - LEM2I Architecture des calculateurs Violaine Louvet 1 1 Institut Camille jordan - CNRS 12-13/09/2011 Introduction Décoder la relation entre l architecture et les applications
1. Structure d'un programme FORTRAN 95
FORTRAN se caractérise par la nécessité de compiler les scripts, c'est à dire transformer du texte en binaire.(transforme un fichier de texte en.f95 en un executable (non lisible par un éditeur) en.exe.)
SRS DAY: Problématique liée à la virtualisation
SRS DAY: Problématique liée à la virtualisation Anthony GUDUSZEIT Franck CURO gudusz_a curo_f Introduction Sommaire Définition Contexte Avantages / inconvénients Fonctionnement et problématique Techniques
Informatique pour scientifiques hiver 2003-2004. Plan général Systèmes d exploitation
Informatique pour scientifiques hiver 2003-2004 27 Janvier 2004 Systèmes d exploitation - partie 3 (=OS= Operating Systems) Dr. Dijana Petrovska-Delacrétaz DIVA group, DIUF 1 Plan général Systèmes d exploitation
Gestion de mémoire secondaire F. Boyer, Laboratoire Sardes Fabienne.Boyer@imag.fr
Gestion de mémoire secondaire F. Boyer, Laboratoire Sardes Fabienne.Boyer@imag.fr 1- Structure d un disque 2- Ordonnancement des requêtes 3- Gestion du disque - formatage - bloc d amorçage - récupération
Gestion mémoire et Représentation intermédiaire
Gestion mémoire et Représentation intermédiaire Pablo de Oliveira March 23, 2015 I Gestion Memoire Variables locales Les variables locales sont stockées: Soit dans un registre,
Grandes lignes ASTRÉE. Logiciels critiques. Outils de certification classiques. Inspection manuelle. Definition. Test
Grandes lignes Analyseur Statique de logiciels Temps RÉel Embarqués École Polytechnique École Normale Supérieure Mercredi 18 juillet 2005 1 Présentation d 2 Cadre théorique de l interprétation abstraite