Discussion :

[Le_CuLtO]

Bonjour à tous.

Je viens de constater un problème assez curieux dont j'ignore complètement la provenance.
Je fais des comparaisons de temps de calculs sur OpenMP en utilisant des nombres différents de threads.
Voici mon petit programme de test:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
#include <stdio.h>
#include <stdlib.h>
// librairie openmp
#include <omp.h>
 
// Multithreading ?
#define MULTITHREAD
// Dimension des matrices
#define N 3000
 
// Définition des 3 matrices
int A [N][N];
int B [N][N];
int C [N][N];
 
int main()
{
	long i,j,k;
 
	// Initialisation des 2 matrices sources
	//srand(time(NULL));
	for (i=0; i<N; i++) {
		for (j=0; j<N; j++) {
			A[i][j] = 1+rand()%9;
			B[i][j] = 1+rand()%9;
			C[i][j] = 0;
		}
	}
 
	#ifdef MULTITHREAD
	// OpenMP adapte automatiquement le nombre de threads en fonction des capcités de la machine
	//omp_set_dynamic(1);
	//printf("\nThreads dispos: %i",omp_get_max_threads());
	// OpenMP utilise un nombre de threads définit par l'utilisateur
	omp_set_dynamic(0);
	omp_set_num_threads(3);
 
	// Directive OpenMP pour exécuter du code en parallèle sur une boucle for
	#pragma omp parallel for shared (A,B,C) private (i,j,k)
	#endif
 
	for(i=0;i<N;i++) {
		for(j=0;j<N;j++) {
			for(k=0;k<N;k++) {
				C[i][j] += A[i][k]*B[k][j];
			}
		}
	}
 
	return 0;
}

Comme vous pouvez le constater c'est très simple... multiplication de matrice en multithreadé.
Le programme fonctionne très bien, pas de soucis à ce niveau là.

Par contre je me suis arraché les cheveux pendant quelques heures car j'avais une erreur à l'exécution quand mes matrices faisaient grosso modo plus de 1000 * 1000 en dimension:
Segmentation fault (core dumped)

La seule différence que j'avais par rapport à cette version là est que les 3 matrices A,B, et C étaient déclarées dans le main.
Depuis que je les ait déclarées en global, plus aucun soucis, je peux passer sans soucis à de grandes dimensions et aucune erreur.

Je fais tourner le programme sous Fedora.
J'ai testé avec et sans OpenMP, même soucis si les matrices sont déclarées dans le main.

Je serais bien curieux de savoir de quoi ça vient.

[Invité]

Bonjour,
De toute façon, un tableau de 3000 x 3000 c'est tout de même beaucoup.
Il me semble que si un tableau est alloué en static (ce qui est le cas), il doit trouver un espace mémoire unique.
Allouez vos tableaux dynamiquement, tout devrait s'arranger.

[Franck.H]

Bonjour,
De toute façon, un tableau de 3000 x 3000 c'est tout de même beaucoup.
Il me semble que si un tableau est alloué en static (ce qui est le cas), il doit trouver un espace mémoire unique.
Allouez vos tableaux dynamiquement, tout devrait s'arranger.

C'est surtout la taille de la pile qui est limitée.

[Le_CuLtO]

J'ai aussi une version avec allocation dynamique... même soucis...
Les variables qu'on crée dans une fonction sont stockées en totalité dans la pile et pas celles qui sont crée en global, ce serait ça ?

[la_tupac]

J'ai pas tout suivis mais oui c'est le cas ... pour les variables instanciées dans une fonction.

[Invité]

Bonjour,
A mon avis, si c'était un problème de pile il y aurait le terme "stack" dans le message d'erreur, et non "segment".
C'est probablement vos fonctions omp_set_... qui provoquent cet écrasement de mémoire.

[diogene]

J'ai aussi une version avec allocation dynamique... même soucis...
Les variables qu'on crée dans une fonction sont stockées en totalité dans la pile et pas celles qui sont crée en global, ce serait ça ?

Les variables locales sont créées par allocation automatique sur la pile et l'espace mémoire maximum alloué à celle-ci est limité.
Ce n'est pas le cas des variables en allocation statique (globales ou déclarées static) ou en allocation dynamique (créées par la famille malloc()) où on dispose de la mémoire disponible. Dans le cas de l'allocation dynamique, il faudra quand même qu'il existe des segments de mémoire compacts de 36Mo (si tes int font 4 octets) pour que l'allocation réussisse. Pour les grosses allocations dynamiques, tu peux avoir intérêt à les faire tôt dans le programme avant d'avoir un émiettement de la mémoire disponible.

[Le_CuLtO]

Impeccable merci à tous pour votre aide.