Méthode d'allocation par défaut des variables locales

Bonjour,

en C++, comme en C, et sans aucun doute la plupart des langages, les variables locales sont par défaut allouées sur la pile à chaque appel de la fonction.
Cependant en Fortran, cette allocation est par défaut "static" : ainsi la variable est allouée une seule fois en mémoire et pas à chaque invocation et conserve sa valeur d'une invocation à l'autre.

Cette deuxième solution n'est-elle donc pas plus performante du point de vue allocation ?

De plus, d'un point de vue programmation, l'allocation "static" ne correspond elle pas mieux aux attentes des débutants en programmation ?

Quelles sont donc les motivations du choix de l'allocation non "static" dans la majorité des langages ?

Merci.

Salut,
je vais juste te citer un cas où l'utilisation de variables "static".
Dans le cas de la programmation en mémoire distribuée(sur plusieurs machines), cela n'est pas possible d'utiliser ces variables.
De plus, en parallèle il est délicat de les utiliser.

Un autre point, l'utilisation de variables non "static" n'est pas moins performante. Car l'allocation consiste à une simple addition sur un pointeur.

Bye,

Merci de votre réponse.

En effet le cas d'accès concurrent lors de parallélisation est une excellente raison.

Que tu alloues 1 ou 500 octets sur la pile, cela ne devrait faire aucune différence. A partir du moment où tu empiles l'adresse de retour, tu peux décaler ton pointeur de pile de quelques octets de plus sans impacter les perfs.
Enfin, c'est comme ça que je le vois.

De plus, sans variable locale, pas de re-entrance pour des fonctions récursives.

Raison de plus en effet.

Donc la question serait plutôt l'inverse : pourquoi une allocation "static" en Fortran ?

Donc si un modérateur pouvait déplacer ce "thread" dans le forum Fortran ...

Merci.

Ce thread a débuté initialement sur le forum C++ et à la demande de l'initiateur du thread a étré déplacé dans le forum fortran pour que la question continue avec le langage fortran

Citation:

---

Envoyé par seriousme

Donc la question serait plutôt l'inverse : pourquoi une allocation "static" en Fortran ?

---

Es-tu sûr que les variables locales sont statiques en Fortran? Ça ne correspond pas à ma mémoire (mais ça fait plus de 20 ans que je n'ai fait du Fortran). Je ne suis pas un spécialiste de la lecture de la norme du Fortran, mais une recherche rapide me donne la page 290 de http://j3-fortran.org/doc/standing/a...f/97-007r2.pdf qui me conforte plutôt dans mon opinion.

Il est vraisemblable que les premiers compilateurs Fortran utilisaient une allocation statique des activation records, mais c'est plus parce que ces ordinateurs ne disposaient pas d'un mode d'adressage adéquat. Et sur ces ordinateurs, un appel de fonction par exemple pouvait modifier l'adresse contenue dans le saut qui effectuait le retour. Il n'est pas impossible que les compilateurs plus récent et pour des architectures disposant de piles aient gardés cette habitude pour des raisons de compatibilité avec l'existant plus que d'exigence de la norme.

En effet il faut que l'attribut "save" soit présent, mais il semble l'être par défaut :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

subroutine f() integer :: a   write (*, *), a   a = a + 1   return end subroutine f   program test call f() call f() call f() end program test

---

Donne :

Code:

---

1 2 3

0 1 2

---

Ce qui semble bien indiquer une allocation "static".

A priori ce comportement "static" ne devrait être présent que si la variable est initialisée ce qui n'est pas le cas ici.

Donc un détail d'implémentation : "gfortran" a ce comportement mais pas "ifort".

En revanche les deux ont un comportement static si il y a initialisation :

Code:

---

integer :: a = 0

---

EDIT : Bon finalement après de plus amples tests il semble que la méthode est bien réentrante dans le cas de non initialisation :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

recursive subroutine f(b) logical :: b   integer :: a a = 0   write (*, *), a, b   a = a + 1   if (b) then call f(.false.) end if   return end subroutine f   program test call f(.true.) call f(.true.) call f(.true.) end program test

---

Donne :

Code:

---

1 2 3 4 5 6 7

0 T 0 F 0 T 0 F 0 T 0 F

---

Mais pas en cas d'initialisation à la déclaration :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

recursive subroutine f(b) logical :: b   integer :: a = 0   write (*, *), a, b   a = a + 1   if (b) then call f(.false.) end if   return end subroutine f   program test call f(.true.) call f(.true.) call f(.true.) end program test

---

Donne :

Code:

---

1 2 3 4 5 6

0 T 1 F 2 T 3 F 4 T 5 F

---

Donc fausse alerte le Fortran a un comportement classique, mais pas tous les compilateurs.