Discussion :

[babykichon]

Faire correspondre le code au plus proche de ce qui se passe en ASM

[diogene]

Si il s'agit de faire pointer ptr sur le dernier double alloué, ceci est faux

per che ? ...

à cause du sizeof(double)

Code :

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

ptr = ptr + (taille-1)*sizeof(double);

[souviron34]

Faire correspondre le code au plus proche de ce qui se passe en ASM

En général, on essaye plutôt de se fiche pas mal de l'assembleiur, et de faire correspondre le code au plus près de la formulation humaine.... et dans ce cas mathématique...

Comme ça, que tu aies 1, 2, ou N processeurs, que tu soit sur un x86, un RISC ou un CISC, ou n'importe quoi, le code ne change pas.. Et c'est bien ce que propose C...

à cause du sizeof(double)

Code :

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

ptr = ptr + (taille-1)*sizeof(double);

Explicite, je ne comprend toujours pas..

[diogene]

L'arithmétique des pointeurs tient compte implicitement de la taille des objets pointés.

ptr est un double *. ptr = ptr + (taille-1) ptr pointe alors sur le (taille-1)ieme double apres celui pointé à l'origine par ptr.

ptr = ptr + (taille-1)*sizeof(double) n'a pas de sens. On ne trouve (pratiquement) jamais de sizeof dans des expressions de calcul d'adresses (sauf à la rigueur des sizeof x/ sizeof *x où x est un tableau)

[TheGzD]

Explicite, je ne comprend toujours pas..

tu pointeur étant déjà typé à double* il avancera forcément de sizeof(double), l'écriture correcte est donc :

Code :

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

ptr = ptr + (taille-1);

[babykichon]

Suffit de faire un test.

Code :

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

1
2
3
4
5
6
7
8
double *ptr;
ptr = malloc(constante*sizeof(double)); 
 
printf("adresse ptr = %d\n", ptr);
 
ptr++;
 
printf("adresse ptr = %d\n", ptr);

---> L’incrémentation s'est faite de 8.

______________________


Sinon pour le lien entre le C et l'ASM, je ne veux pas faire complètement correspondre le code. Mais Concernant les buffer circulaire j'aimerais qu'ils tournent de la même façon en C qu'en ASM.

C'est a dire :

en C je peux juste me faire un petit buffer modulo du type :

Code :

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

1
2
3
4
5
6
7
8
 
double value[constante];
int x;
.
.
//process while ou boucle
value[x++]= ....
x % = constante;

Le problème est que ce comportement est inexistant sur DSP, sur lequel tu configures un buffer avec une adresse de début et de fin, et il fait simplement un compare pour revenir en début lorsque tu es en fin.

Le code C que j’écris sera peut être intégré directement sur la target, peut être une partie seulement sera en ASM, je ne sais pas encore. Dans le doute, j'essaye de rendre ce buffer le plus transparent possible, comme ça dans mon code je ne fais qu'utiliser un pointeur que j’incrémente ou décrémente, comme en ASM. L’étape du modulo je la code dans un fichier "tampon" pour l'exclure du code générique.
EDIT : Lorsque je dis, l’étape modulo, j'entends le compare entre adresse courante/fin, qui est complètement transparent sur la target.

Du coup lorsque je le réécris en ASM, suffit de recopier bêtement mon code C générique, qui sera déjà optimisé sur ce point la.

Enfin je suis pas très doué pour les explications ... j’espère que je suis assez clair lol

[souviron34]

L'arithmétique des pointeurs tient compte implicitement de la taille des objets pointés.

ptr est un double *. ptr = ptr + (taille-1) ptr pointe alors sur le (taille-1)ieme double apres celui pointé à l'origine par ptr.

ptr = ptr + (taille-1)*sizeof(double) n'a pas de sens. On ne trouve (pratiquement) jamais de sizeof dans des expressions de calcul d'adresses (sauf à la rigueur des sizeof x/ sizeof *x où x est un tableau)

vi vii t'as raison je reviens de vacances et j'avais la tête dans ... ailleurs dirons-nous...

de toutes façons j'aurais normalement écris plutôt :

Code :

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

ptr = &(x[taille-1]);

si j'avais voulu faire ça..

[souviron34]

oui c'est exactement l'idee, sauf que la ligne du for de la fonction je la rend generique en la remplacant par une fonction qui fera appel a un autre fichier qui pourra etre changer.

Et que je ne veux voir aucune [i] dans le code

Mais sinon c'est ca ^^

Ce qui ne change strictement rien par rapport à ce que j'ai écris :

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
int main (void)
{
double *ptr, *x, Result;
ptr = malloc ( taille* sizeof(double));
x = malloc ( taille*sizeof(double));
.
.
Result = function1(ptr, x, .....);
.
}
 
double function1(double *ptr, double *x .....)
{
  double Res ;
  int i ;
 
x = x + (taille-1) ;
 
for (i=(taille-1);i>= 0;i--)
 {
    Res = Res + function2(*ptr, *x); 
    ptr++ ; x-- ;
 }
 
return Res ;
}
 
double function2 ( double ptrVal, double xVal)
{
   double Res = ptrVal + xVal ;
 
   return Res ;
}

tes variables ptr et x étant locales à la fonction function1, les décrémenter ou incrémenter ne modifie pas leurs valeurs à l'extérieur, et donc quand on ressort de function1 les valeurs sont inchangées, rendant caduque l'histore de redémarrer cycliquement.. C'est cycliquement programmé...

[babykichon]

Dans mon code, X est local a fonction1 ok, mais pas ptr qui vient du main et doit etre modifie par function1 et 2.

j'ai pas poste le code complet car ca sortait du cadre du sujet.

Enfin, tout marche comme je le souhaites merci pour votre aide

[diogene]

mais pas ptr qui vient du main et doit etre modifie par function1 et 2

ptr est bien une variable locale à la fonction function1() initialisée avec la valeur du ptr de main().
Le ptr du main ne sera pas modifié par function1()

[babykichon]

A mon premier post, non tu as raison, mais j'ai modifie le code depuis.

Je te remercie

[souviron34]

oui mais ce qu'on te dit c'est que si tu veux faire "cyclique", il ne fallait pas faire cette modif, car ça le fait tout seul..

[babykichon]

Bon finalement j'ai vire toutes les locales, comme me l'avait dit tres justement j'écrasais la valeur passe en parametre du main a la fonction1.

En faite pour coller vraiment su titre, pour envoyer la meme reference en cascade je suis arrive a un truc du genre :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
int main()
{
double *ptr;
ptr= malloc(NbCoefFIR *sizeof(double));
.
.
.
.
ptr++;      //incremente l'adresse
function1(&ptr,....); //prototype -> function1(double **ptr,...)
}

Code :

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

1
2
3
4
5
6
7
8
9
 
int function1(double **ptr,...)
{
.
(*ptr)++;  //incremente l'adresse
.
function2(&*ptr,...);   //prototype -> function2(double **ptr,...)
.
}

Code :

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

1
2
3
4
5
6
7
8
9
10
 
function2(double **ptr,....)
{
.
.
**ptr = X; //modifie la valeur du buffer a l'adresse *ptr
(*ptr)++;  //incremente l'adresse
.
.
}

Alors bon, ca marche ... mais j'ai comme le sentiment d'etre parti en vrille ...

[diogene]

Un détail :

Code :

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

function2(&*ptr,...);   //prototype -> function2(double **ptr,...)

&*ptr c'est simplement ptr :

Code :

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

function2(ptr,...);   //prototype -> function2(double **ptr,...)

[babykichon]

Ah oui ... aussi ....


....



Merci chef !