Limite de taille List(Of ) - System.OutOfMemoryException

Version imprimable

16/11/2021, 22h12
electroremy

Limite de taille List(Of ) - System.OutOfMemoryException

Bonjour à tous,

J'ai un programme qui stocke pas mal de données en RAM

Je tombe sur cette erreur :

System.OutOfMemoryException: Les dimensions du tableau dépassent la plage prise en charge.
à System.Collections.Generic.List`1.set_Capacity(Int32 value)
à System.Collections.Generic.List`1.EnsureCapacity(Int32 min)
à System.Collections.Generic.List`1.Add(T item)

Je stocke mes données dans
- deux List(Of Single)
- une List(Of Color)

C'est un programme qui fait de la 3D.

J'arrive à gérer 22 millions de triangles, pour chaque triangle on stoke :
- trois nombres Single pour le vecteur normal
- neuf nombre Single pour les coordonnées (X,Y,Z) des trois sommets
- une couleur (entier 32 bits)
Cela fait 1,06 Go de données utiles (un single étant stocké sur 4 octets), auxquelles il faut ajouter les octets requis par les pointeurs utilisés par les listes

Au delà (25 millions de triangles) ça plante.

Alors oui 22 millions de triangles c'est déjà pas mal 8-)
Avec ces données, le programme compilé en release 64 bits, sous Seven 64 bits intégrale, consomme 1,9 à 2,6Go de RAM.
(NB : en plus les triangles sont envoyés dans la carte graphique via Open GL pour affichage, tout en restant en RAM pour les calculs de mon programme)

Je n'ai pas à rougir, VisCamView n'arrive pas à ouvrir ce fichier STL de 22 millions de triangles, et MeshLab y arrive mais en chie :mouarf:

Mon PC a 16 Go de RAM, lorsque le plantage se produit il n'y a même pas la moitié de ces 16 Go qui est utilisée... C'est frustrant...
Je programme aussi en embarqué (microcontrôleur), je suis habitué à pouvoir exploiter le hardware à 100% :mouarf: j'aimerais bien exploiter mon PC à fond :mouarf:

Est-il possible d'aller au dela ?

Il me semble que l'intérêt du 64 bits par rapport au 32 bits est justement la possibilité d'outrepasser la limite de 4Go de RAM

Et vis à vis de la fragmentions de la mémoire, il me semble que c'était aussi l'intérêt des listes par rapport au tableaux

A bientôt
16/11/2021, 23h21
Pol63

une appli .net peut prendre plusieurs Go de ram, je l'ai déjà vu avec des fuites mémoires :D

il me semble qu'outofmemory peut arriver lorsque l'allocation de ram est trop rapide

un list est un array en plus pratique, mais il y a bien un array dedans
un array n'est pas redimensionnable sans refaire une copie de l'existant dans un tableau plus grand
pour ca le list dimensionne son tableau au démarrage à une taille donnée, puis quand un .add fait que ca devrait dépasser il créé un array 2x plus grand puis recopie le 1er dans le 2eme
ceci a un cout en mémoire et en performance, si tu sais vaguement combien va faire ton list à l'avance tu peux faire en sorte qu'il dimensionne l'array via la surcharge du constructeur new list<machin>(int capacity)
idéalement à une taille qu'il ne dépassera pas ce qui évitera toute recopie inutile

si ca ne corrige pas le problème essaye d'allouer un peu moins vite les choses, ne serait ce que pour voir si c'est bien la vitesse de remplissage le problème (ce n'est pas forcément une solution idéale)

sinon il y a des méthodes dans le framework pour prévenir qu'on va allouer beaucoup de ram (et pour la rendre plus tard), je l'ai plus en tête mais ca permettrait peut etre d'éviter l'out of memory
17/11/2021, 08h07
m4k-Hurrican

Bonjour,

Ce n'est pas le nombre d'éléments qui est en cause, c'est certain, la limite comme indiqué dans l'erreur, est d''environ 2 milliards (Int32).
Y a t'il une limite en taille globale du même acabit, genre un pointeur Int32 qui est chargé de pointer dans la List et qui lui se trouve dépassé ? Il me semble que Microsoft avait une limite à 2Go pour les objets, et c'est peut être là qu'il faut chercher.
Un test simple avec une List de quelques centaines ou milliers d'éléments mais de grande taille devrait donner la réponse.
17/11/2021, 09h48
electroremy

Merci pour vos réponses.

Comme c'est pour de la 3D (CAO), le programme est optimisé pour être rapide.

Les 22 millions de triangles sont créés en 25 secondes par une procédure de génération de forme.

Si derrière les List(Of ) se cachent des tableaux redimenssionés, il faut créer des tableaux cela me semble évident...
Le soucis est de savoir quelle taille prendre, dommage de bouffer de la RAM pour créer de petites pièces.
Ou alors à un moment donné il faudra supprimer les tableaux pour les recréer en plus grand.
Il n'est pas toujours possible de savoir à l'avance quels quantité de données sera créé.

Autre aspect des choses : j'ai une liste pour les valeurs NX, NY, NZ et une autre pour les valeurs X1, Y1, Z1... Z3
Ca serait plus pertinent de prendre une liste NX, une liste NY... une liste Z3 ? Chaque liste serait plus petite

Autre idée : avoir une liste de liste.
Chaque fonction qui génère des triangles créé une liste, chaque petite liste est ajoutée dans la liste de liste.
Le soucis étant que j'ai une fonction "gourmande" qui a elle seule est capable de générer 22 millions de triangles voire plus :aie: :mouarf:
Il faudrait faire une liste NX, une liste NY... une liste Z3 par fonction, et une liste de liste NX... une liste de liste Z3

Dernière idée : avoir des listes de liste, avec création d'une nouvelle sous-liste de taille fixe une fois une certaine taille limite atteinte.
Genre je commence avec une liste de taille fixe pour 100.000 triangles; une fois qu'elle est remplie j'en créé une deuxième, et ainsi de suite
Cela permet d'allouer/libérer la mémoire par bloc de 100.000 triangles, c'est moins violent pour la gestion de la mémoire, et ça permet au programme de ne pas gâcher de la mémoire en allouer une trop grande quantité de mémoire au démarrage. Dans mon code, au moment de la libération, il faudra que j'appelle le garbage collector avant de créer de nouvelles listes.
Je peux carrément utiliser des tableaux de 100.000 à la place des listes, et avoir une liste de tableaux.
La bonne nouvelle c'est que je n'ai pas besoin de supprimer les triangles au milieu de la liste, donc c'est gérable avec des tableaux.
Qu'en pensez vous ?

A bientôt
17/11/2021, 10h12
Pol63

j'en pense qu'en effet il y a plusieurs choses à tester pour chercher le plus performant, mais qu'il faudrait déjà que tu règles ton problème d'out of memory exception avant d'avancer, car tant que tu ne sais pas pourquoi il est là tu risques de retomber dessus plus tard

tu peux tenter ca dans un premier temps : gcAllowVeryLargeObjects element - .NET Framework | Microsoft Docs
17/11/2021, 10h31
electroremy

Merci

Ton lien est intéressant mais est limité au 64 bits
Je voulais que mon programme puisse tourner en 32 bits aussi ; en CAO / FAO on peut dédier un ordinateur un peu ancien pour une machine.

Comme expliqué j'ai des choses à tester, je pense que mon idée de faire une liste de tableau fixes de 100.000 peut marcher et qu'elle risque même d'apporter un gain en vitesse. C'est chouette il y a deux choses à gagner : outrepasser la limite de mémoire et gagner un peu de vitesse :)

Je reviens vers vous quand j'aurais le résultat

A bientôt

Bonjour

Alors je suis content j'ai trouvé une solution :)

Résumé du problème :
- stocker de nombreux triangles en RAM
- pouvoir les écrire et les lire rapidement.
- pour chaque triangle, 12 valeurs Single (NX, NY, NZ, X1, Y1, Z1 ... Z3) + une couleur sous forme d'entier 32 bits

Le programme de départ stockait les données dans 3 listes :
- une list(of Single) avec à la suite toutes les valeurs de NX, NY, NZ
- une list(of Single) avec à la suite toutes les valeurs de X1, Y1, ... Z3
- une list(of Color) avec à la suite toutes les couleur

D'abord j'ai testé avec un liste pour NX, une pour NY... une pour Z3 ; soit 12 listes : le code est plus propre, mais ralentissement de 10%

Ensuite avec une seule liste pour toutes les valeurs Singles (de NX à Z3) : gain de 10%

Puis, j'ai remplacé chaque liste par une listes de listes.
Le principe est de mettre dans les List(Of List(Of )) que des petites listes de taille fixe

Voici la déclaration des données :

Code:

1
2
3
4
5
6
7
8
9
10
11
 
    Public STL_ListeT_NbTri As Integer
    Public STL_ListeT_index As Integer
    Public Const STL_ListeT_MAX As Integer = 100000 'sous liste de 100000 triangles
    Public Const STL_ListeT_MAXcount As Integer = STL_ListeT_MAX * 12
 
    Public STL_ListeT As List(Of List(Of Single))
    Public STL_ListeT_Current As List(Of Single)
 
    Public STL_ListeColor3 As List(Of List(Of Color))
    Public STL_ListeColor3_Current As List(Of Color)

Voici le code d'initialisation :

Code:

1
2
3
4
5
6
7
8
9
        STL_ListeT = New List(Of List(Of Single))
        STL_ListeT.Add(New List(Of Single)(STL_ListeT_MAXcount))
        STL_ListeT_NbTri = 0
        STL_ListeT_index = 0
        STL_ListeT_Current = STL_ListeT.Item(STL_ListeT_index)
 
        STL_ListeColor3 = New List(Of List(Of Color))
        STL_ListeColor3.Add(New List(Of Color)(STL_ListeT_MAX))
        STL_ListeColor3_Current = STL_ListeColor3.Item(STL_ListeT_index)

Le code pour ajouter un triangle :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
            STL_ListeT_NbTri += 1
            If STL_ListeT_NbTri > STL_ListeT_MAX Then
                STL_ListeT_NbTri = 1
                STL_ListeT_index += 1
                STL_ListeT.Add(New List(Of Single)(STL_ListeT_MAXcount))
                STL_ListeT_Current = STL_ListeT.Item(STL_ListeT_index)
 
                STL_ListeColor3.Add(New List(Of Color)(STL_ListeT_MAX))
                STL_ListeColor3_Current = STL_ListeColor3.Item(STL_ListeT_index)
            End If
            STL_ListeT_Current.Add(nx) : STL_ListeT_Current.Add(ny) : STL_ListeT_Current.Add(nz)
            STL_ListeT_Current.Add(X1) : STL_ListeT_Current.Add(Y1) : STL_ListeT_Current.Add(Z1)
            STL_ListeT_Current.Add(X2) : STL_ListeT_Current.Add(Y2) : STL_ListeT_Current.Add(Z2)
            STL_ListeT_Current.Add(X3) : STL_ListeT_Current.Add(Y3) : STL_ListeT_Current.Add(Z3)
 
            STL_ListeColor3_Current.Add(STL_Color3)

Le code pour supprimer le dernier triangle (j'ai parfois besoin de faire ça) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
        If STL_ListeT_NbTri = 0 Then
            STL_ListeT.RemoveAt(STL_ListeT_index)
            STL_ListeColor3.RemoveAt(STL_ListeT_index)
            STL_ListeT_index -= 1
            STL_ListeT_Current = STL_ListeT.Item(STL_ListeT_index)
            STL_ListeColor3_Current = STL_ListeColor3.Item(STL_ListeT_index)
            STL_ListeT_NbTri = STL_ListeT_MAX
        End If
        STL_ListeT_Current.RemoveRange(STL_ListeT_Current.Count - 12, 12)
        STL_ListeT_NbTri -= 1
 
        STL_ListeColor3_Current.RemoveAt(STL_ListeColor3_Current.Count - 1)

Le code pour utiliser les triangles, par exemple pour écrire le fichier STL :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
            For k = 0 To STL_ListeT.Count - 1
                STL_ListeT_Current = STL_ListeT.Item(k)
                STL_ListeColor3_Current = STL_ListeColor3.Item(k)
                NbTriangles = STL_ListeT_Current.Count \ 12
                For i = 0 To NbTriangles - 1
                    j = 12 * i
                    STL_binWriter.Write(STL_ListeT_Current.Item(j)) : STL_binWriter.Write(STL_ListeT_Current.Item(j + 1)) : STL_binWriter.Write(STL_ListeT_Current.Item(j + 2)) 'NX, NY, NZ
                    STL_binWriter.Write(STL_ListeT_Current.Item(j + 3)) : STL_binWriter.Write(STL_ListeT_Current.Item(j + 4)) : STL_binWriter.Write(STL_ListeT_Current.Item(j + 5)) 'X1, Y1, Z1
                    STL_binWriter.Write(STL_ListeT_Current.Item(j + 6)) : STL_binWriter.Write(STL_ListeT_Current.Item(j + 7)) : STL_binWriter.Write(STL_ListeT_Current.Item(j + 8)) 'X2, Y2, Z2
                    STL_binWriter.Write(STL_ListeT_Current.Item(j + 9)) : STL_binWriter.Write(STL_ListeT_Current.Item(j + 10)) : STL_binWriter.Write(STL_ListeT_Current.Item(j + 11)) 'X3, Y3, Z3
                    c = STL_ListeColor3_Current.Item(i)
                    STL_binWriter.Write(CUShort((c.B >> 3) + (c.G >> 3) * 32 + (c.R >> 3) * 1024 + 32768))
                Next
            Next

Ca n'est pas trop compliqué à faire, notamment parce que je n'ai pas besoin de retirer ou d'insérer des triangles au milieu des listes.

Le résultat :
- gain en vitesse supplémentaire de 10% (donc 20% par rapport au programme de départ)
- possibilité de stocker beaucoup de triangles : avec l'EXE en release 64 bits, j'ai pu générer 95 137 226 triangles sans soucis, occupation RAM de 6,7Go, fichier STL généré de 4,42Go

Avec le release AnyCPU ça marche, mais avec le release 32 bits ça plante (erreur OutOfMemory lorsque le programme arrive à 1,6Go de RAM occupée dans le gestionnaire des tâches)

Je n'ai pas testé avec des tableaux de largeur fixe à la place des listes, mais je ne sais pas si ça vaut la peine car le compilateur .NET semble gérer cela efficacement

A bientôt

Bonjour,

J'ai modifié le code d'initialisation, qui appelé au démarrage mais aussi à chaque nouvelle pièce, pour appeler le garbage collector :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 STL_ListeT = New List(Of List(Of Single)) STL_ListeT.Add(New List(Of Single)(STL_ListeT_MAXcount)) STL_ListeT_NbTri = 0 STL_ListeT_index = 0 STL_ListeT_Current = STL_ListeT.Item(STL_ListeT_index) STL_ListeColor3 = New List(Of List(Of Color)) STL_ListeColor3.Add(New List(Of Color)(STL_ListeT_MAX)) STL_ListeColor3_Current = STL_ListeColor3.Item(STL_ListeT_index) GC.Collect() My.Application.DoEvents()
Ca fonctionne, dans le gestionnaire des tâches on voit que lorsqu'on fait une petite pièce après une grosse, l'occupation mémoire redescend nettement.

A bientôt