grand tableau en fortran

Version imprimable

01/09/2016, 07h28
dva2tlse

grand tableau en fortran

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

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:

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

01/09/2016, 15h52
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", ...
01/09/2016, 17h57
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...)

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:

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:

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.

02/09/2016, 08h23
Ehouarn

Bonjour,

Citation:

Envoyé par dva2tlse

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).
02/09/2016, 11h04
dva2tlse

Citation:

Envoyé par Ehouarn

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.

Citation:

Envoyé par Ehouarn

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

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:

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:

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

06/09/2016, 13h15
dva2tlse

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