je veux optimiser une boucle for ecrit en C :
dans le cas ou je connais pas ma borne ?? comment je peux le faire .. c'est à dire , mon but est de transformer ma boucle en un ensemble des instructions :
exemple
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
 
for ( i=0 ; i<3 ; i++ )
    doSmthg(i);
 
==> sera ecrit :
doSmthg(0);
doSmthg(1);
doSmthg(2);
ce cas est simple à le transformer mais si j ai ceci :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
 
for(i=0;i<n;i++)
  doSmthg(i);
 
==> sera ecrit :
doSmthg(0);
doSmthg(1);
doSmthg(2);
doSmthg(3);
....
....
doSmthg(n-1);
je veux pas mon programme qui prend en argument un fichier codé en C n'execute pas le code qui est dejà ecrit mais je veux degagé quelques informations

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
 
--> ficheir d'entrée : entree.c
 
int a ;   // declaration simple                                                            
int i ;                                                                                             
int b=0;      // declaration avec affectation
int c ,z,n ;   // declaration avec plus qu'un variable                            
a=1;          // affectation
scanf("%d",&a);
b=a+3;     // operation
scanf("%d",&b);
c=a+b;      // instruction , operation
scanf("%d",&c);
for ( i=0 ; i<n ; i++ )     // boucle for
{   z = c+3 ; }
// fin programme
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
 
 
fichier de sortie : sortie.log
********************************************** 
0         a             read               null                          dirty
1         i              read               null                          dirty
2         b             write              null                          dirty
3         c             read               null                          dirty
4         z             read               null                          dirty
5         n             read               null                     readOnly
6         a             write              null                           read
7         a             write              null                     readOnly
8         a             read               null                     readOnly
9         b             write              a                               read
10       b             write              null                     readOnly
11       a             read               null                           dead
12       b             read               null                           dead
13       c             write              a,b                             read
14       c             write              null                     readOnly
15       i              write              null                           dirty
16       n             read               null                     readOnly
17       c             read               null                     readOnly
18       z             write              c                               dirty
19       i              write             null                            dirty
20       n             read              null                      readOnly
..
...
...
==> jusqu'à fin de la boucle
dernier ligne sera ( nbre d'instruction qui ne verifie pas  le condition d'arret + 15 )
ici .. z prendera comme tag dead et meme pour c .
je veux vous decrire la structure de mon fichier de sortie :
premier colonne : temps == ordre sequentiel pour les instructions
2ème colonne : nom du variables en cours de lire lors l'instruction
3ème colonne : statu actuelle" du variable lors de l'instruction courante
4ème colonne : dependance ( le variable de quoi il depend d'autres variables )
5ème colonne : Tag ( statu de variable au reste de programme )

quelques significations :

read : le variable on en statu de lecture
write : d'ecriture
dead : le variable on va plus l'utiliser jusqà fin programme
readOnly : le variable on va l'utiliser q pour lecture jusqà fin programme
dirty : le variable on va le modifier avant la fin programme


En fait , pour lire mes instructions < scanf , affectation , instruction ( exp : a =b+c , un seul operateur pour le moment ) > il affiche ds mon fichier , il me reste les boucles , j ai trouve pas un algorithme pour le lire .. je pense à eliminer les boucles et le transforme en un ensemble des instructions mais j'ai pas une idée claire , ben je sais pas car je connais pas puisq mon programme fait pas l'execution afin de savoir combien elle vaut la borne ??? ..

j ai trouvé un lien http://www.alrj.org/docs/algo/boucles.html ds une page peut m'aider mais j ai pas bien compris , est ce que vous pouvez le refaire pour un boucle qui fait le produit matriciel c 'est assez simple que la manipulation des mémoires virtuelle et offset :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
 
for ( i= 0; i<n ; i++)
     for (j=0;j<m ; j++)
           for ( k=0; j<p ; k++)
                  c[i][j]=c[i][j]+A[i][k]*B[k][j];
           fin pour
     fin pour
fin pour
en fait j ai connais une autre idée mais je suis pas sure .. meme le syntaxe p etre faux .
pour compiler : gcc -o3 prog.c proc
cette commande sert à optimiser un code c sequentielle pour les boucles il le transforme automatiquement en des instructions mais .. qlq peut m'aider comment je peux l'integrer dans mn programme qui lire ce code sans l'execution et merci encore
merci infiniment !!
je travaille sous linus avec QT4 pour mon programme mais il mache avec d'autre palt form jspr