Gagner de l'espace mémoire

**smail21** · 15/09/2007, 16h02

Salut
j'ai une application qui implémente un algorithme de calcul et de recherche dans un texte, à l'aide de deux matrice!
alors lorsque la taille du texte dépasse les 10000 caractère, il m'affiche un message d'erreur Mémoire insuffisante!
j'ai essayé sur plusieurs pc (même un Double core)! c'est le même problème pourtant le pc ne se bloque pas!
comment pourrais-je lui augmenter la taille de l'espace mémoire

pour le code je ne peux pas le simplifier plus qu'il en est!

j'attends votre réponse

merci

**devyan** · 15/09/2007, 16h59

Peut-être peux-tu effectuer ta recerche sans charger TOUT le texte en une fois

Yan.

**Gilbert Geyer** · 15/09/2007, 18h09

Bonjour,

Bizarre que pour seulement 10000 caractères tu satures ta mémoire même en supposant qu'il y en a 10000 dans le texte chargé et autant dans chacune de tes deux matrices ... car avec ma mem-vive-totale de seuleument 255.434 Mo et deux logiciels en activité il me reste encore suffisamment de mem-vive-dispo pour charger en mem-vive 3 fois 6.878 Mo qui équivalent à 3 paquets de 500 feuilles A4 imprimées recto-verso sur 60 lignes de 115 caractères Times New Roman taille 10, soit une pile de 15 cm de papier bien tassé.

Faudrait voir ton code pour pourvoir t'aider.

A+

**smail21** · 15/09/2007, 19h55

non, je dois charger les deux textes au complet avant de lancer les procédures de calculs et de remplacmeents des colones!
ce que j'ai omis de mentioner est que durant ce traitement je générère une 3ème matrice qui à au maximum 10000 colones! et 7 lignes!

that's my problem

**droggo** · 15/09/2007, 20h42

Mio,

Envoyé par smail21

non, je dois charger les deux textes au complet avant de lancer les procédures de calculs et de remplacmeents des colones!
ce que j'ai omis de mentioner est que durant ce traitement je générère une 3ème matrice qui à au maximum 10000 colones! et 7 lignes!

that's my problem

Alors, c'est sans solution, car tu finiras toujours par arriver à la limite de la mémoire disponible.

Il faut revoir ton algorithme.

**smail21** · 15/09/2007, 21h10

malhereusement ce n'est pas mon algorithme!
il est fait par deux chercheur taiwanais!

**droggo** · 15/09/2007, 21h59

Hui,

Quand je parlais d'algorithme, c'était dans un sens très large, y compris une autre implémentation d'un même algorithme.

**Clorish** · 15/09/2007, 22h25

As tu verifié aur tu n'as pas une fuite memoire ? ce qui expliquerais cela ...

Sinon pour info : Un double core avec 128Mo de ram plate alors qu'un P1 166 avec 1go de ram peut passer

Juste pour dire que le processeur n'ets pas vraiement impliqué dans les problemes memoire

**tourlourou** · 16/09/2007, 09h27

quel est le message d'erreur précis ?

**Gilbert Geyer** · 16/09/2007, 10h56

Bonjour,

L'implémentation, même taiwanaise, dès que c'est du Delphi, est certainement modifiable. Pour commencer je trufferais l'appli d'une série de ShowMessage(intToStr(memDisponible)) bien placés pour localiser les étapes les plus gourmandes en mémoire, de façon à pouvoir voir si la partie du code concernée n'est pas entâchée d'une lourdeur, de plus cela permet de constater jusqu'à quelle étape il reste de la mem-vive-dispo et selon ce qu'il resterait à être exécuté pour arriver jusqu'à la fin en fonction du code cela permettrait d'évaluer l'importance du manque de memoire vive et de faire un diagnostic : modifier le code ou installer des barettes de mem-vive.

Dans tous les cas tant qu'on ne voit pas le code de ton appli on va pédaller dans la choucroute.

A+

**Clorish** · 16/09/2007, 16h21

d'ailleur je ferais petu etre une etape intermediaire : Une comparaison plus petite qui vas jusqu'au bout.
Puis comme l'a suggerer Gilbert, je regarderais la quantité memoire disponible : Avant et apres l'algo.

En theorie, il doit etre identique (a quelques octets pres

)
Si ce n'ets pas le cas, tu as une sacree fuite memoire, qui expliquerais peut etre ton probleme ....

A noter, j'ai quand meme reussi a charger en memoire un bitmap de pres de 30.000x30.000 pixels avant plantage .... donc a priori, je ne vois pas en quoi ton algo ateindrais cette limite.
(un bitmap est composé d'au moins 3 octets par pixels soit 3x30.000x30.000 !!)

**smail21** · 16/09/2007, 18h15

Merci pour Vos réponses :

1- le message d'erreur est "Mémoire Insuffisante"

2- avant(dans la première version où j'utilisais des Grid pour afficher le contenu de mes matrices et les calculer, l'espace mémoire utilisé arrivait jusqu'à 340 mo, mais après j'ai retiré les affichages et les grids, donc j'utilise des matrice de type string(car j'ai des valeurs positives >=0 et des cases vides remplis par un tiret -)

voici le code (la partie où les calculs plantent) :

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
procedure TFentree.dxButton1Click(Sender: TObject);
var i,j,a,b,c:integer;
begin
n:=length(memoi.text); // memoi contient le premier texte
m:=length(memoj.text); // memoj contient le second texte
//copier le contenu des Tmemo
s1:=copy(memoi.text,0,n);
s2:=copy(memoj.text,0,m);
 
if (n>0) and (m>0) then
begin
c:=0;
//************************************
//********* Matrice Score ************
//************************************
//redimensionner la matrice Score
SetLength(x,n);
for i := Low(x) to High(x) do
   SetLength(x[i], m);
 
//calcul de la matrice des scores
 for i := low(x) to High(x) do
 for J := low(x[i]) to High(x[i]) do
 begin
 if s1[i+1]=s2[j+1] then x[i,j]:=1 else x[i,j]:=0;
 end;
//***********************************************
//********* Fin calcul Matrice Score ************
//***********************************************
 
//initialisation
SetLength(y,n+1);
for i := Low(y) to High(y) do
   SetLength(y[i], m+1);
 
for i := Low(y) to High(y) do  y[i,0]:=0;
 for j := Low(y[1]) to High(y[1]) do y[0,j]:=0;
 //calcul de la matrice des alignement
 for i := 1 to High(y) do
  for J := 1 to High(y[i]) do
 begin
 a:= y[i-1,j-1]+X[i-1,j-1];
 b:= y[i-1,j];
 c:= y[i,j-1];
 a:=max(a,b);
  c:=max(a,c);
  y[i,j]:=c;
 end;
 transit.value:=y[n,1];
 
 
end;
end;

**smail21** · 16/09/2007, 18h23

alors le second code qui est d'une autre application(avec un autre algo plus compliqué)

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
procedure TFentree.BtYdirectClick(Sender: TObject);
var n,m,i,ord,j,x1,x2,classe,l,k,val,symb,compt,r:integer;
    s1,s2:string;
    replace:boolean;
begin
 
nb:=0;
compt:=0;
n:=length(memoi.text);
m:=length(memoj.text);
s1:=copy(memoi.text,0,n);
s2:=copy(memoj.text,0,m);
 
SetLength(Y,7);
for ord := Low(y) to High(y) do
   SetLength(y[ord], 1);
 
 
//****initialisation des cellules  du tableau Y
remplirGridy(0,0,0);
 
L:=0;   // l est l'indice de la séquence j
classe:=1;
symb:=0;
j:=1;// se positionner sur la colone de C0   ===> à revoir
// k est l'indice de la séquence i
for k:= 1 to n  do   //se pointer sur les symbole de I
begin
if s1[k]='A' then symb:=0;
if s1[k]='C' then symb:=1;
if s1[k]='G' then symb:=2;
if s1[k]='T' then symb:=3;
 
if X[symb+1,L]<>'-' then // **********************************
begin
 
val:=strtoint(X[symb+1,L]);
for ord := Low(y) to High(y) do
   SetLength(y[ord], classe+1);
 
 
i:=i+1;
remplirGridy(classe,val,k);
 
j:=j+1;
//**********vérifier les remplacements
L:=val;
 
for x1:=classe-1 downto  0  do    // jusqu'à C0
 
    if(Y[symb+3,x1]<>'-') and (Y[symb+3,x1]<>Y[symb+3,x1+1]) then
       begin
       replace:=false;
       for x2:=classe-1 downto  0  do
           if (replace=false) then
             begin
               if strtoint(y[1,x2])<strtoint(y[symb+3,x1]) then
               begin
               //remplacer la colone suivante de Y
 
               remplirGridy(x2+1,strtoint(Y[symb+3,x1]),k);
               replace:=true;
 
               end;  // fin du remplacement
             end;
       end;
classe:=classe+1;
 
end  //fin du traitement cas normal*******************************
 
else
 
begin //début traitement du cas '-'  ***************************
for x1:=classe-2 downto  0  do    // jusqu'à C0
 
    if(Y[symb+3,x1]<>'-') and (Y[symb+3,x1]<>Y[symb+3,x1+1]) then
       begin
       replace:=false;
       for x2:=classe-1 downto  0  do
           if (replace=false) then
             begin
               if strtoint(y[1,x2])<strtoint(y[symb+3,x1]) then
               begin
               //remplacer la colone suivante de Y
               remplirGridy(x2+1,strtoint(Y[symb+3,x1]),k);
               replace:=true;
 
               end;  // fin du remplacement
             end;
       end;
L:=strtoint(y[1,classe-1]);
 
end; //fin du cas '-'  *****************************
 
end;// fin de la séquence I  
lab1.caption:=inttostr(classe-1);
 
end;

**smail21** · 16/09/2007, 19h50

bon première bonne nouvelle!

j'ai changé le type des matrices de string en Integer et au lieu d'utiliser le tirret '-', j'utilise la valeur -1!

alors là, le premier essai à 10000 caractères a marché
je vais essayer 50000 tout à l'heure(aprè la rupture du jeûne

)
et je vous rendrai la réponse

**Jipété** · 17/09/2007, 08h01

Yep !

A noter, j'ai quand meme reussi a charger en memoire un bitmap de pres de 30.000x30.000 pixels avant plantage

Ça aurait été intéressant de connaitre le type de plantage, car effectivement, 30000 * 30000 * 3 = 2,7 GB, soit bien au delà de la limite max autorisée pour un process, qui est de 2,1 GB (le max d'un integer, quoi) - 128 KB (64 sous '95) inaccessibles car protégés.

Puis comme l'a suggerer Gilbert, je regarderais la quantité memoire disponible : Avant et apres l'algo.

En theorie, il doit etre identique (a quelques octets pres )

Oh oh... J'ai joué avec une image de 327 MB : avant chargement j'ai environ 50 % de mémoire libre (j'ai 512 MB), je charge avec Photoshop et je tombe à 1 % libre, je ferme Photoshop et je remonte à 80 % libre !
Explication : au chargement de l'image, ça a dû swapper dur vers Pagefile.sys (j'avais 2-3 trucs ouverts, navigateur, messagerie, ...) pour libérer la mémoire pour Photoshop.

--
jp

**smail21** · 17/09/2007, 12h33

et pour mon problème, t'as pas une solution ?

**Clorish** · 17/09/2007, 13h43

Bon .. desolé .. jama planté

Sous Delphi c'est du 5000x5000 pixels que l'on peut charger dans un TBitmap.

Par contre sous mon editeur d'image, je suis monté a plus de 15000x15000, pour 630Mo de memoire ... sur les 1Go disponnible.
et ca fait quand meme plus de 600.000.000 caracteres

Apres faut voir combien de caracteres (taille en Mo) est composé les textes a comparer ...

Faut voir aussi l'algo, si ca traine pas des tableaux temporaires plus nombeux que prevu a l'aide d'une certaine recursivité.

Mais le plus simple, c'est deja d'estimer la quantitée de memoire necessaire a l'algo (en estimant le nombre et la taille des tableaux "dans le pire des cas").

**tourlourou** · 17/09/2007, 15h23

je viens de regarder le 1° algo : si j'ai bien compris, il crée une matrice score de 10000*10000 soit 400 Mo si ce sont des entiers (d'ailleurs, il suffit sûrement de Byte), puis une seconde pour les alignements.

pour le second, trop obscur !!!

tu veux comparer des séquences d'ADN ?
quel est le principe ?

**Gilbert Geyer** · 17/09/2007, 16h05

Bonjour,

Juste pour suivre l'évolution de l'occupation-mémoire :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
procedure AfficheInfosMemoire;
const     ls = #13+#10;
var       MS: TMemoryStatus;
          MemPhysT,MemPhysD,MemPagiT,MemPagiD,MemVirtT,MemVirtD,msg : string;
begin     GlobalMemoryStatus(MS);
          MemPhysT:='Mem Phys Totale : '+FormatFloat('#,###" Ko"', MS.dwTotalPhys / 1024);
          MemPhysD:='Mem Phys Dispo  : '+FormatFloat('#,###" Ko"', MS.dwAvailPhys / 1024);
          MemPagiT:='Mem Pagi Totale : '+FormatFloat('#,###" Ko"', MS.dwTotalPageFile / 1024);
          MemPagiD:='Mem Pagi Dispo  : '+FormatFloat('#,###" Ko"', MS.dwAvailPageFile / 1024);
          MemVirtT:='Mem Virt Totale : '+FormatFloat('#,###" Ko"', MS.dwTotalVirtual / 1024);
          MemVirtD:='Mem Virt Dispo  : '+FormatFloat('#,###" Ko"', MS.dwAvailVirtual / 1024);
          msg:=MemPhysT+ls+MemPhysD+ls+MemPagiT+ls+MemPagiD+ls+MemVirtT+ls+MemVirtD;
          showMessage(msg);
end;

A+

**Jipété** · 17/09/2007, 16h13

À quoi on peut rajouter :

- The "MemoryLoad" figure has nothing to do with the percentage of
virtual memory in use at the time. In Microsoft documentation it is defined
as "a measure of how busy the memory management system is." It can be
calculated as 50 percent of the ratio of the committed (requested for use
by an application) memory pages to the physical (actual RAM) memory pages
managed by Windows 95.

- The "Bytes of physical memory present" figure (= Total) is the amount of physical RAM
minus any holes in the upper memory area (UMA), used by adapters, and so
forth.

- The "Bytes of available physical memory" figure (= Libre) shows how much of this
physical memory is available.

- The "Bytes of paging file" figure is the size of the current paging file.
This figure represents the number of bytes in the paging file that are
uncommitted to any process. (TotalPageFile ou AvailPageFile ? Pas très clair...)

- The "TotalVirtual" figure indicates the size of the process'
address space. Under Windows 95, this figure is exactly 4 MB short of being
2 GB. Under Windows 95 every process has a 2 GB private address space and
the lower 4 MB of this address space is protected. Under Windows NT, this
figure would always be 128 KB short of 2 GB, since Windows NT protects the
64 KB at the start and end of the process' 2 GB private address space.

All of these figures would be exactly the same, no matter which process
called GlobalMemoryStatus() except the "AvailableVirtual" figure.
To calculate this value, GlobalMemoryStatus() adds up all the free regions
in the process' address space. This number can shrink and grow.

This text comes from Q177372, copyright Microsoft Corporation 1998, avec 2-3 commentaires de ma pomme

Valà,
--
jp
PS : c'est avec ce genre de code que j'ai relevé les chiffres donnés ce matin.

Gagner de l'espace mémoire

API, COM et SDKs Delphi

Discussions similaires

Partager

Partager