Seg fault lors d'une optimisation avec icc

Student said the following on 5/09/2006 16:03:

Bonjour,

Lors de l'optimisation d'un code avec icc, j'ai eu un seg fault, après
un petit analyse j'ai trouvé que le programme essaye d'écrire sur un
tableau non aloué, l'allocation je le fait par des boucles puisque c
des tableaux de plusieur dimensions, (exemple pour un float ** :
allocation de float ** puis des float *), est ce que c possible que
lors de l'optilisation cette boucle soit traiter en bloques?, si c le
cas comment je peux eviter une telle erreur,
j'utilise : icc avec LDFLAFGS=-xW -tpp7 -O3

merci

Obtiens-tu ce genre de résultat sans optimisation avec le même compilateur ?

Es-tu certain de tes bornes ?

Pourquoi n'emplois-tu pas un vecteur de vecteur ?

Student said the following on 5/09/2006 16:03:

Bonjour,

Lors de l'optimisation d'un code avec icc, j'ai eu un seg fault, après
un petit analyse j'ai trouvé que le programme essaye d'écrire sur un
tableau non aloué, l'allocation je le fait par des boucles puisque c
des tableaux de plusieur dimensions, (exemple pour un float ** :
allocation de float ** puis des float *), est ce que c possible que
lors de l'optilisation cette boucle soit traiter en bloques?, si c le
cas comment je peux eviter une telle erreur,
j'utilise : icc avec LDFLAFGS=-xW -tpp7 -O3

merci

Obtiens-tu ce genre de résultat sans optimisation avec le même compil ateur ?

Es-tu certain de tes bornes ?

Pourquoi n'emplois-tu pas un vecteur de vecteur ?

lorsque je compile avec gcc ça marche bien, avec icc sans optimisation
c aussi bien,
les bornes sont sures (soignés à la main une par une),
J'ai pas volu compliqué la vie puisqu'il s'agit juste de 4 tableaux et
puisque je passe ces tableaux à d'autres fonctions faites pour les
tableaux, mais pourquoi pas, tu m'a donner envis d'essayer.

merci

Le 05-09-2006, Student <ghriss.hicham@gmail.com> a écrit :

Lors de l'optimisation d'un code avec icc, j'ai eu un seg fault, après
un petit analyse j'ai trouvé que le programme essaye d'écrire sur un
tableau non aloué,

C'est à dire ?

l'allocation je le fait par des boucles puisque c
des tableaux de plusieur dimensions, (exemple pour un float ** :
allocation de float ** puis des float *), est ce que c possible que
lors de l'optilisation cette boucle soit traiter en bloques?

Que cela signifie-t-il "traiter en bloques" ?
As-tu essayé des outils tel que valgrind ou boundschecking
pour vérifier si ce n'est pas ton code qui serait en cause ?

Car le coup du code qui 'marche' avec certaines options
de compil et plus avec d'autres, ça m'évoque surtout
un UB (genre accès hors bornes) qui ne fait rien de mal
dans certaines configurations mémoire, et qui devient
visible dans d'autres.

Marc Boyer
--
Si tu peux supporter d'entendre tes paroles
Travesties par des gueux pour exciter des sots
IF -- Rudyard Kipling (Trad. Paul Éluard)

les bornes sont sures (soignés à la main une par une),

A mon humble avis, il y a un problème quand même.
Je suppose que tu as un dépassement tout le temps, mais selon le
compilateur (allocateur mémoire, options de compilation) il se trouve
dans une configuration que tu débordes dans de la mémoire allouée et
qu'ainsi tu ne t'en aperçois pas alors que dans une autre configuration
tu as droit à la faute de sementation immédiatement.
C'est en tout cas très typique de ce que tu décris, AMHA.

--
Alain

je pense que c'est moi qui s'est mal exprimé, en expliquant le
problème,
alors j'utilise des tableaux allouées graces à des fonctions que j'ai
fait dans un module : exemple:
float ** allocArray2D(float **a,int x,int y){
if( (a = (float **)malloc(sizeof(float*)*x)) == NULL){
fprintf(stderr,"Error:allocation Failed n");
return NULL;
}
for( i = 0; i<x; i++){
if( (a[i] = (float*)malloc(sizeof(float)*y)) ==NULL){
fprintf(stderr,"Error:allocation Failedn");
free(a);
return NULL;
}
} sans oublier de faire des tests à gauche et à droite pour m'assuer
que le retour est bon, ceci n'est pas mon prob,
pour initialiser mes tableaux j'ai fait des fonctions pareil qui font
l'initialisation,( vous allez me dire peut etre pourquoi ne pas faire
le job une fois, j'ai mes raison, c pas ici que je peux les expilquer)
ces tableaux sont utilisées dans une boucles
for(i=0;i<VAL; i++){
//traitements en boucles des tableaux
}
lors de la compilation normale: tout se passe bien, pas de problem mon
programme tourne à 50 MFLOPS, qui est negligeable par rapport à ma
version fortran qui tourne 650 MFLOPS, alors j'optimise : j'utilise un
compilateur intel avec -xW -tpp7 et -O3, ok normalement j'espere avoir
meiux,
j'execute : op un problem de segfault, qui est aléatoire, après
chaque compilation il me sort un nouveau, mais qui touchent toute le
temps l'initialisation des tableaux par exemple, lorsque je vois avec
ddd, je trouve qu'il essaye d'initisaliser avec d'allouer!!!, j'elimine
pas la possiblité de faire des betises dans mon code, mais j'ai une
grande confiance en se que j'ai écris.
s'étais ça, j'ai corriger des problèmes de conversion de type et
d'autres #remark que icc me présente, et voila ça marche
l'éxécution mais je suis trés loin des perf souhaités: je tourne à
60 MFLOPS.
désolé pour ce long message explicatif, mais je veux bien voir si
qlqn à une exlication sur ces perf, merci.

les bornes sont sures (soignés à la main une par une),

A mon humble avis, il y a un problème quand même.
Je suppose que tu as un dépassement tout le temps, mais selon le
compilateur (allocateur mémoire, options de compilation) il se trouve
dans une configuration que tu débordes dans de la mémoire allouée et
qu'ainsi tu ne t'en aperçois pas alors que dans une autre configuration
tu as droit à la faute de sementation immédiatement.
C'est en tout cas très typique de ce que tu décris, AMHA.

--
Alain

je pense que c'est moi qui s'est mal exprimé, en expliquant le
problème,
alors j'utilise des tableaux allouées graces à des fonctions que j'ai
fait dans un module : exemple:
float ** allocArray2D(float **a,int x,int y){
if( (a = (float **)malloc(sizeof(float*)*x)) == NULL){
fprintf(stderr,"Error:allocation Failed n");
return NULL;
}
for( i = 0; i<x; i++){
if( (a[i] = (float*)malloc(sizeof(float)*y)) ==NULL){
fprintf(stderr,"Error:allocation Failedn");
free(a);
return NULL;
}
}

si l'allocation d'un a[i] echoue, il faudrait aussi liberer
les tableaux a[0] ... a[i-1], non ?

sans oublier de faire des tests à gauche et à droite pour m'assuer

que le retour est bon, ceci n'est pas mon prob,
pour initialiser mes tableaux j'ai fait des fonctions pareil qui font
l'initialisation,( vous allez me dire peut etre pourquoi ne pas faire
le job une fois, j'ai mes raison, c pas ici que je peux les expilquer)
ces tableaux sont utilisées dans une boucles
for(i=0;i<VAL; i++){
//traitements en boucles des tableaux
}
lors de la compilation normale: tout se passe bien, pas de problem mon
programme tourne à 50 MFLOPS, qui est negligeable par rapport à ma
version fortran qui tourne 650 MFLOPS, alors j'optimise : j'utilise un
compilateur intel avec -xW -tpp7 et -O3, ok normalement j'espere avoir
meiux,

Question: pourquoi reecrire ce programme en C alors qu'une version
FORTRAN existe ? Si c'est pour pouvoir executer ce moteur de calcul
depuis un programme C, ne pourrais-tu pas ecrire une API minimale de
traduction C/FORTRAN vers ce moteur?

j'execute : op un problem de segfault, qui est aléatoire, après
chaque compilation il me sort un nouveau,

Je me permet de te le répéter ce que tu dis est très caractérisque.

pas la possiblité de faire des betises dans mon code, mais j'ai une
grande confiance en se que j'ai écris.

Tu ne devrais pas:

dans

for( i = 0; i<x; i++){
if( (a[i] = (float*)malloc(sizeof(float)*y)) ==NULL){
fprintf(stderr,"Error:allocation Failedn");
free(a);
return NULL;
}

Tu libères sans doute a, mais toutes les zones pointées par les a[i]
dans la boucle avant l'éventuel échec de malloc restent allouées.
Pour une fuite mémoire c'en est une, et une belle.
Bon tu me diras sans doute que tu ne parles pas de fuite mémoire. Ce à
quoi je te répondrais que si j'étais toi je serais un peu moi sûr que ce
que j'écris et hors cette allocation de mémoire, je vérifierais si par
hasard le remplissage du tableau par de valeurs ne déborderait pas un
peu....

--
Alain

Tu libères sans doute a, mais toutes les zones pointées par les a[i]
dans la boucle avant l'éventuel échec de malloc restent allouées.
Pour une fuite mémoire c'en est une, et une belle.

D'ailleurs je parierais volontier qu'en fonctionnement normal tu fais la
même boulette et quand tu libères float **a tu oublies de libérer les
a[i] avant...

--
Alain

quoi je te répondrais que si j'étais toi je serais un peu moi sûr que ce

lire: "un peu moins sûr"


--
Alain

ne pariez sur rien, le code publier est à titre indicatif, je fait
bien libérer la mémoire déjà alouée avant l'intéruption.
Alain Gaillard wrote:

quoi je te répondrais que si j'étais toi je serais un peu moi sûr que ce

lire: "un peu moins sûr"


--
Alain