Discussion :

[dva2tlse]

Bonjour,
je suis mécanicien et non développeur, et j'utilise des codes éléments finis, nastran en ce qui me concerne mais le problème pourrait être généralisé.

les éléments finis que j'utilise sont numérotés sur huit chiffres, de 1 à 99999999. Comment utiliser en fortan un tableau (d'entiers) de cette taille ? Cela dépasse malheureusement les 4Go d'adressage que l'on peut atteindre sur 64 bits, alors comment faire pour adresser tous ces gens là ?

Merci,
David

[dva2tlse]

Bon, je me réponds à moi-même au cas où d'autres tomberaient là dessus; j'ai déclaré le tableau en allocatable et ça a l'air d'aller, sauf qu'il y a une nouvelle segfault au troisième sous-programme qui est appelé, un peu plus loin :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
c
      program S4
      integer, dimension (:), allocatable :: i  ! declaration d'un tableau d'entiers
      integer :: taille                         ! taille du tableau
      TAILLE=99999999
      allocate (i(0:taille))                    ! allocation de la memoire pour le tableau
      i(0)=9
      i(1)=1
      i(99999999)=2
      print('(/A,I8.8)'), '        i(0)=', i(0)
      print('(A,I8.8)'), '        i(1)=', i(1)
      print('(A,I8.8/)'), ' i(99999999)=', i(99999999)
      stop                                      ! suite du programme
      end program S4

[Sylvain Bergeron]

Ton tableau est-il plein ? As-tu besoin de toutes les cases ? Sinon, la solution se trouve du côté des listes liées, les tables de "hashage", ...

[dva2tlse]

Bonjour Sylvain,
non, mon tableau n'est pas plein du tout; il contiendrait environ 22 mille éléments, soit 22000 numéros sur 10**8 positions.

Mais je ne sais pas comment revenir au N° de la case d'après ce qu'elle contient.

Donc pour l'instant je ne sais que passer par ce gigantesque tableau presque vide. (22/10**5=pas derche comme densité)

J'ai déjà lu plusieurs fois les termes "listes chaînées", est-ce que les listes liées dont tu me parles sont la même chose ?
Je pourrais me renseigner dessus.
merci,
David

Edit: Mais ça ne semble concerner que le C, enfin c'est les gens qui font du C qui en parlent le plus.
(serait-ce une occasion de me faire [piger et] être à l'aise avec les pointeurs du C depuis le fortran ? Rêvons...)

[Sylvain Bergeron]

Oui, liste chaînée fait partie des solutions possibles.

En fait, la solution dépend beaucoup de comment tu veux utiliser, et de ton habilité de programmeur !!!

Par exemple, une solution très simple, et archaïque, mais qui peut bien fonctionner si tu connais bien le nombre d'entrées que tu dois stocker consiste à avoir 2 listes : les CLES et les VALEURS. À cela, tu ajoute NOMBRE, le nombre d'entrée, MAXNBR, le nombre maximum supporté :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
integer, parameter :: MaxNbr = 22000 ! Alternativement, tu peux rendre variable avec des allocates...
integer Cles(MaxNbr)
integer Valeurs(MaxNbr) 
 
Nbr = 0
do
   read(...) Cles(Nbr+1), Valeurs(Nbr+1)
   Nbr = Nbr+1
enddo
...

Une telle solution est simpliste, et elle ne sera pas efficace si tu dois souvent retrouver tes valeurs par clé, parce qu'une recherche séquentielle est requise. Supposons que tu cherche la Valeur qui correspond à Cle :

Code :

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

1
2
3
4
5
6
 
k = 1
do while (k <= Nbr .and. Cles(k) /= Cle)
   k = k + 1
enddo
Valeur = Valeurs(k)

Tu pourrais accélérer le code en bissectionnant, mais tes entrées doivent alors être triées. C'est là que les listes chaînées, les tables de hashage et les arbres interviennent. Les listes chaînées et les arbres requièrent l'utilisation de pointeurs. Les tables de hashage sont plus simples : c'est simplement une fonction qui permet de distribuer tes données dans CLES() et VALEURS() ci-haut, et de raccourcir la recherche.

[Ehouarn]

Bonjour,

les éléments finis que j'utilise sont numérotés sur huit chiffres, de 1 à 99999999. Comment utiliser en fortan un tableau (d'entiers) de cette taille ? Cela dépasse malheureusement les 4Go d'adressage que l'on peut atteindre sur 64 bits, alors comment faire pour adresser tous ces gens là ?

Pour palier à la "limitation d'adressage" il y a des options de compilations adaptées, pas nécessairement besoin d'ajouter du code, c.f par exemple l'option "mcmodel" (pour gfortran). Ce qui est dit ici pourrait t'intéresser.

PS: Ton petit programme test marche très bien chez moi (Linux, 64 bit, avec gfortran).

[dva2tlse]

Ce qui est dit ici pourrait t'intéresser.

Oui en effet, ça a l'air très bien, mais mon assembleur se limite aux Z80 et 8086 d'il y a trente cinq ans... (en huit bits) et le Vladimir de S/O est un peu trop calé pour moi là dessus.

PS: Ton petit programme test marche très bien chez moi (Linux, 64 bit, avec gfortran).

Oui, ça c'est ce que j'ai utilisé comme modèle pour commencer à me sortir de la mouise.
à+,
David

[dva2tlse]

ReBonjour à tous,
j'en suis maintenant à utiliser mon grand tableau que j'ai réussi à allouer, dans un sous programme de celui où il a été crée.
Je n'imagine pas qu'il faille allouer de nouveau de la place pour lui, alors comment le passer ? Comme d'hab' ???

prgm principal :

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
 
      program S4
      implicit none
      integer, dimension (:), allocatable :: IDeltN ! declaration d'un tableau d'entiers
      integer :: taille                         ! taille du tableau IDeltN
c
      TAILLE=99999999
      allocate (IDeltN(0:taille))                    ! allocation de la memoire pour le tableau
      IDeltN(0)=0
      IDeltN(1)=1
      IDeltN(99999999)=9
c
      call lecelt(IDeltN)
c
      print('(/A,I8.8)'), '        IDeltN(0)=', IDeltN(0)
      print('(A,I8.8)'), '        IDeltN(1)=', IDeltN(1)
      print('(A,I8.8/)'), ' IDeltN(99999999)=', IDeltN(99999999)
      stop
      end program S4

ss-prgm :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
      subroutine lecelt(IDeltN)
      implicit none
      integer, dimension (:), allocatable :: IDeltN ! declaration d'un tableau d'entiers
      integer :: taille                         ! taille du tableau IDeltN
c
      TAILLE=99999999
      IDeltN(0)=0+100
      IDeltN(1)=1+100
      IDeltN(99999999)=9+100
      return
      end subroutine lecelt

Bon bin je viens de copier tout ça et ça compile mais ça segfaulte je ne sais où.
Merci si quelqu'un sait m'aider,
David

[dva2tlse]

YOUPI, j'ai tâtonné quelques instants et c'est bon. BYE