Faire correspondre le code au plus proche de ce qui se passe en ASM
Faire correspondre le code au plus proche de ce qui se passe en ASM
à cause du sizeof(double)
Code : Sélectionner tout - Visualiser dans une fenêtre à part ptr = ptr + (taille-1)*sizeof(double);
Publication : Concepts en C
Mon avatar : Glenn Gould
--------------------------------------------------------------------------
Une réponse vous a été utile ? Remerciez son auteur en cliquant le pouce vert !
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...
Explicite, je ne comprend toujours pas..
"Un homme sage ne croit que la moitié de ce qu’il lit. Plus sage encore, il sait laquelle".
Consultant indépendant.
Architecture systèmes complexes. Programmation grosses applications critiques. Ergonomie.
C, Fortran, XWindow/Motif, Java
Je ne réponds pas aux MP techniques
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)
Publication : Concepts en C
Mon avatar : Glenn Gould
--------------------------------------------------------------------------
Une réponse vous a été utile ? Remerciez son auteur en cliquant le pouce vert !
tu pointeur étant déjà typé à double* il avancera forcément de sizeof(double), l'écriture correcte est donc :Explicite, je ne comprend toujours pas..
Code : Sélectionner tout - Visualiser dans une fenêtre à part ptr = ptr + (taille-1);
Vous postez du code ? Merci d'utiliser les balises
Code : Sélectionner tout - Visualiser dans une fenêtre à part ...
Un message vous paraît pertinent ? Merci de le gratifier d'un vote positif
Vous avez obtenu une réponse à votre question ? Merci d'utiliser le tag
__________________
Ingénieur R&D, diplômé en 2007 de l'ISIMA
Docteur en informatique, diplômé en 2015 de l'EDSPI de Clermont-Ferrand
Suffit de faire un test.
---> L’incrémentation s'est faite de 8.
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);
______________________
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 :
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.
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 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
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..
"Un homme sage ne croit que la moitié de ce qu’il lit. Plus sage encore, il sait laquelle".
Consultant indépendant.
Architecture systèmes complexes. Programmation grosses applications critiques. Ergonomie.
C, Fortran, XWindow/Motif, Java
Je ne réponds pas aux MP techniques
Ce qui ne change strictement rien par rapport à ce que j'ai écris :
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é...
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 ; }
"Un homme sage ne croit que la moitié de ce qu’il lit. Plus sage encore, il sait laquelle".
Consultant indépendant.
Architecture systèmes complexes. Programmation grosses applications critiques. Ergonomie.
C, Fortran, XWindow/Motif, Java
Je ne réponds pas aux MP techniques
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
ptr est bien une variable locale à la fonction function1() initialisée avec la valeur du ptr de main().mais pas ptr qui vient du main et doit etre modifie par function1 et 2
Le ptr du main ne sera pas modifié par function1()
Publication : Concepts en C
Mon avatar : Glenn Gould
--------------------------------------------------------------------------
Une réponse vous a été utile ? Remerciez son auteur en cliquant le pouce vert !
A mon premier post, non tu as raison, mais j'ai modifie le code depuis.
Je te remercie
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..
"Un homme sage ne croit que la moitié de ce qu’il lit. Plus sage encore, il sait laquelle".
Consultant indépendant.
Architecture systèmes complexes. Programmation grosses applications critiques. Ergonomie.
C, Fortran, XWindow/Motif, Java
Je ne réponds pas aux MP techniques
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 ...
Un détail :
&*ptr c'est simplement ptr :
Code : Sélectionner tout - Visualiser dans une fenêtre à part function2(&*ptr,...); //prototype -> function2(double **ptr,...)
Code : Sélectionner tout - Visualiser dans une fenêtre à part function2(ptr,...); //prototype -> function2(double **ptr,...)
Publication : Concepts en C
Mon avatar : Glenn Gould
--------------------------------------------------------------------------
Une réponse vous a été utile ? Remerciez son auteur en cliquant le pouce vert !
Ah oui ... aussi ....
....
Merci chef !
Vous avez un bloqueur de publicités installé.
Le Club Developpez.com n'affiche que des publicités IT, discrètes et non intrusives.
Afin que nous puissions continuer à vous fournir gratuitement du contenu de qualité, merci de nous soutenir en désactivant votre bloqueur de publicités sur Developpez.com.
Partager