Discussion :

[Abdelazer]

Bonjour !

Je fais un programme de calcul scientifique qui doit diagonaliser une matrice dont il a préalablement calculer les coefficients. Pour çà, j'utilise la bibliothèque lapack (que je link avec les options -llapack -lblas avec gcc).

J'arrive à calculer ma matrice pour des tailles importantes (5000 x 5000), à diagonaliser une grosse matrice mais pas à faire les deux successivement !

Je joins mes fichiers sources : boulanger.c contient les fonctions pour calculer la matrice, test_diago_complex_ligne.c diagonalise de grosses matrices (je suis obligée de les transformer en ligne pour que la fonction zgeev fonctionne même sur des tailles importantes) et test_ouvert4.c est censé faire les deux. fonctions_tableaux.c est utilisé dans boulanger.c.

Le problème c'est que çà marche pour des matrices 1000 x 1000 mais pour des matrices plus grosses, j'obtiens l'erreur :
malloc: *** error for object 0x103ff7a08: incorrect checksum for freed object - object was probably modified after being freed.
*** set a breakpoint in malloc_error_break to debug
Abort trap
Parfois j'ai aussi : malloc: *** error for object 0x100807e00: pointer being freed was not allocated
Ce qui est bizarre c'est que, même pour des matrices petites (1000), quand je désalloue la matrice bidimensionnelle, çà ne marche plus !

Je suis sous Mac OS 10.6, je n'utilise pas d'IDE (je compile dans le terminal avec gcc).

N'hésitez pas à me demander des précisions.
Merci pour votre aide !

[Bktero]

Le problème c'est que çà marche pour des matrices 1000 x 1000 mais pour des matrices plus grosses, j'obtiens l'erreur :
malloc: *** error for object 0x103ff7a08: incorrect checksum for freed object - object was probably modified after being freed.
*** set a breakpoint in malloc_error_break to debug
Abort trap
Parfois j'ai aussi : malloc: *** error for object 0x100807e00: pointer being freed was not allocated
Ce qui est bizarre c'est que, même pour des matrices petites (1000), quand je désalloue la matrice bidimensionnelle, çà ne marche plus !

L'erreur ne doit pas dépendre de la taille de tes matrices. Comme le dit clairement les messages d'erreur, tu as fait un free sur une matrice alors que tu ne l'as pas allouée (cas 2) ou tu essayes de modifier une matrice déjà libérée (cas 1).

Ton code est clairement trop long pour qu'on puisse facilement se pencher dessus, surtout qu'il faut lapack pour compiler je suppose.

Essaye de passer ton code dans Valgrind pour voir s'il te donne la ligne générant l'erreur.

[Kaamui]

si tu utilise des mallocs, tu effectue des allocations dynamiques sur le tas, donc la taille de la matrice ne devrait pas poser de problèmes.

Code :

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

1
2
3
4
 
char pixels[5000][4000][3];//allocation statique sur la pile (stack), va surement planter...
 
char* pixels = new char[5000*4000*3]//allocation sur le tas (heap), ça passe^^

utilse valgrind (ou gdb hein peu importe, le debugger que tu as sous la main)

et dis nous où tu obtiens ta segfault (et comme ça tu nous montre juste le bout de code où ça foire^^)

[Bktero]

Pas de new en C ! Il faut faire des malloc

[Kaamui]

Pas de new en C ! Il faut faire des malloc

ah oui pardon

mais le conseil reste valable ^^

Code :

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

1
2
3
4
 
char pixels[5000][4000][3];//allocation statique sur la pile (stack), va surement planter...
 
char* pixels = (char*)malloc(sizeof(char)*5000*4000*3);//allocation sur le tas (heap), ça passe^^

[Abdelazer]

Merci pour vos réponses ! Désolée de vous répondre si tard mais il m'a fallu pas mal de temps pour apprendre à utiliser gdb (je n'ai pas valgrind et d'après ce que j'ai lu, çà ne marcherait pas très bien sous mac).
J'ai donc :

Code :

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

1
2
3
4
5
 double complex **matrice = malloc(dimension * sizeof(double complex)); 
	for (i = 0; i < dimension; i++)
	{
		matrice[i] = malloc(dimension * sizeof(double complex));
	}

...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 double complex *travail = malloc(dimension * dimension *  sizeof(double complex)); // il faut allouer dynamiquement pour accéder à toute la mémoire
	for (i = 0 ; i < dimension ; i++) 
	{
		for (j = 0 ; j < dimension ; j++) 
		{
			travail[dimension * i + j] = matrice[i][j];
		}
	}
	for (i = 0; i < dimension; i++)
	{
		free(matrice[i]);
	}
	free(matrice);

D'après gdb, le problème se situe à la ligne free(matrice[i])
Voilà ce qui se passe :

Breakpoint 1, main () at test_ouvert4.c:55
55 for (i = 0; i < dimension; i++)
(gdb) n
57 free(matrice[i]);
(gdb) n
Program received signal EXC_BAD_ACCESS, Could not access memory.
Reason: KERN_INVALID_ADDRESS at address: 0xfffffd7c61ad1808
0x00007fff84d55468 in szone_size ()

Je ne sais pas si gdb peut me donner plus d'informations.

[Kaamui]

C'est l'allocation de mémoire qui ne vas pas je penses :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
//tu alloues [double complex* x dimension] octets sur le tas pour ton pointeur de pointeurs sur double complex, 
//chaque emplacement mémoire pouvant ainsi contenir un pointeur sur double complex
double complex **matrice = (double complex**)malloc(dimension * sizeof(double complex*)); 
	for (i = 0; i < dimension; i++)
	{
//pour chaque pointeur sur double complex tu alloues [dimension x double complex] octets, chaque emplacement mémoire 
//pouvant contenir un double complex
		matrice[i] = (double complex*)malloc(dimension * sizeof(double complex)); 
	}

Là je penses que ça devrait aller mieux quand tu essaieras de libérer la mémoire allouée.

[Abdelazer]

Désolée mais il n'aime pas du tout les tableaux de (double complex*)
Il ne calcule même plus les coefficients de la matrice, j'obtiens tout de suite segmentation fault

[diogene]

1- Tes allocations sont systématiquement fausses

Code :

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

1
2
3
4
5
	double complex **matrice = malloc(dimension * sizeof(double complex *)); // il faut allouer dynamiquement pour accéder à toute la mémoire
	for (i = 0; i < dimension; i++)
	{
		matrice[i] = malloc(dimension * sizeof(double complex));
	}

2- Lorsque je vois le code de boulangerOuvertLisse(), quelque chose m'interpelle :

Code :

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

zgemm_ (&TRANSA, &TRANSB, &dimension, &dimension, &dimension, &alpha, &(fourier[0][0]), &dimension, &(blocs[0][0]), &dimension, &beta, &(matrice[0][0]), &dimension);

Je ne connais pas la fonction zgemm_ () mais les arguments &(fourier[0][0]), &(matrice[0][0]) et &(blocs[0][0]) m'intriguent : à partir de ces adresses, et compte tenu de la méthode d'allocation, il est impossible d'avoir accès à tous les éléments des tableaux mais seulement aux dimension éléments commençant aux adresses fourier[0], matrice[0] et blocs[0] (tous les éléments ne sont pas consécutifs en mémoire, ils sont consécutifs par blocs de dimension éléments)