Discussion :

[Saphir21]

Salut,

j'utilise un memory streams dans lequel j'écris un string (memorystream.write), quand j'essaie disons d'écrire un string de plus de 300 mb (en fais, j'utilise une fonction qui lit un fichier et l'écris dans un string), j'obtiens l'erreur "Out of memory while expanding memory stream"

pourtant la machine a encore beaucoup de ram disponible.

j'ai donc premièrement essayé mon code dans un nouveau projet, ça marchait très bien, finalement, j'ai fini par identifier ce qui cause le message d'erreur, si j'ajoute un savedialog sur la form, et que avant de faire l'opération, je fais savedialog.execute, ca me fais ce truc out of memory quand j'écris dans le streams,

j'utilise delphi 7, je ne sais pas si les autres versions de delphi causeront ce problème, mais c'est très embêtant, je ne sais pas trop comment régler ça.

pour utiliser le code, placez un gros fichier (plus de 300 mb) dans le C:\, appelez le "film.avi", ensuite créez 1 nouveau projet, ajouter un bouton et un savedialog.

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
function ReadFileString(FileName: String): Ansistring;
var
  F: file;
  Buffer: Ansistring;
  Size: Integer;
  ReadBytes: Integer;
  DefaultFileMode: Byte;
begin
  Result := '';
 
  DefaultFileMode := FileMode;
 
  FileMode := 0;
  AssignFile(F, FileName);
  Reset(F, 1);
 
  if (IOResult = 0) then
  begin
    Size := FileSize(F);
 
    while (Size > 1024) do
    begin
      SetLength(Buffer, 1024);
      BlockRead(F, Buffer[1], 1024, ReadBytes);
      Result := Result + Buffer;
      Dec(Size, ReadBytes);
    end;
 
    SetLength(Buffer, Size);
    BlockRead(F, Buffer[1], Size);
    Result := Result + Buffer;
 
    CloseFile(F);
  end;
 
  FileMode := DefaultFileMode;
end;
 
procedure TForm1.Button1Click(Sender: TObject);
var
  bufferBig: string;
  MemStream2: TMemoryStream;
begin
 
  SaveDialog1.Execute;
 
  MemStream2 := TMemoryStream.Create;
  BufferBig := ReadFileString('C:\film.avi');
  MemStream2.Write(BufferBig[1], Length(BufferBig));
 
end;

si j'enlève "SaveDialog1.Execute;", ça marche, aucun problème.
j'ai essayé SaveDialog1.free apres le execute, aucun effet.

J'aimerais beaucoup recevoir un peu d'aide, merci à l'avance!

[Paul TOTH]

deux choses:

1) ta fonction ReadFileString passe son temps à réallouer Result

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
 
function ReadFileString(FileName: String): Ansistring;
var
  F: file;
  Size: Integer;
  DefaultFileMode: Byte;
begin
  DefaultFileMode := FileMode;
 
  FileMode := 0;
  AssignFile(F, FileName);
  Reset(F, 1);
 
  if (IOResult = 0) then
  begin
    Size := FileSize(F);
    SetLength(Result, Size);
    BlockRead(F, Result[1], Size, ReadBytes);
 
{ ou encore...
 
    Index := 1;
    while (Size > 1024) do
    begin
      BlockRead(F, Result[Index], 1024, ReadBytes);
      Inc(Index, ReadBytes);
      Dec(Size, ReadBytes);
    end;
 
    BlockRead(F, Result[Index], Size);
 
    CloseFile(F);
}
  end;
 
  FileMode := DefaultFileMode;
end;

2) TMemoryStream possède une méthode LoadFromFile

[Saphir21]

merci, j'ai tester, mais ça donne toujours la même erreur.

pour le load de streams, je peux pas parce que je fais des opérations sur le buffer avant de mettre en streams (pas dans ce code, mais dans mon vrai oui)

[Paul TOTH]

en fait tu alloues deux fois la taille du fichier en mémoire...c'est un peu dommage

1) n'utilise pas le MemoryStream et travaille sur le string retourné par ReadFileString

2) n'utilise pas ReadFileString mais alloue directement le MemoryStream

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
 
function ReadFileStream(FileName: String): TMemoryStream;
var
  F: file;
  Size: Integer;
  DefaultFileMode: Byte;
  PMem : PChar;
begin
  Result := TMemoryStream.Create;
 
  DefaultFileMode := FileMode;
 
  FileMode := 0;
  AssignFile(F, FileName);
  Reset(F, 1);
 
  if (IOResult = 0) then
  begin
    Size := FileSize(F);
    Result.Size := Size;
    BlockRead(F, Result.Memory^, Size, ReadBytes);
 
{ ou encore...
 
    PMem := Result.Memory;
    while (Size > 1024) do
    begin
      BlockRead(F, PMem^, 1024, ReadBytes);
      Inc(PMem, ReadBytes);
      Dec(Size, ReadBytes);
    end;
 
    BlockRead(F, PMem^, Size);
 
    CloseFile(F);
}
  end;
 
  FileMode := DefaultFileMode;
end;

[Saphir21]

oui je sais, mais je crois pas pouvoir me passer du string, donc je vais essayer de pas utiliser le memory streams alors.

merci pour l'aide.

[Paul TOTH]

oui je sais, mais je crois pas pouvoir me passer du string, donc je vais essayer de pas utiliser le memory streams alors.

merci pour l'aide.

Si tu as besoin d'un TStream tu peux aussi créer un TStringStream

[Saphir21]

j'ai essayé sans le stream, de travailler sur le string direct, ça me fait la meme chose, la memoire double la taille du fichier.

j'utilise une encryption sur le string, genre buffer := encrypt(buffer), c'est p-e à cause de ça j'en sais rien, mais je sais une chose, quand ca me dis "out of memory", il me reste beaucoup de ram encore (j'ai 6gb)

donc je comprend pas trop pourquoi. bref ;/

[Franck SORIANO]

j'ai essayé sans le stream, de travailler sur le string direct, ça me fait la meme chose, la memoire double la taille du fichier.

j'utilise une encryption sur le string, genre buffer := encrypt(buffer), c'est p-e à cause de ça j'en sais rien, mais je sais une chose, quand ca me dis "out of memory", il me reste beaucoup de ram encore (j'ai 6gb)

donc je comprend pas trop pourquoi. bref ;/

6 Go de RAM ! Bon déjà si tu n'as pas un OS 64 bits ça ne sert à rien...

Ensuite Delphi n'étant pas encore 64 bits, ton appli doit être limitée à 2 Go (peut-être 4 Go si tu as un OS 64 bits, je ne sais pas comment se comporte Wow32).

Cette limite est un problème d'adressage, en Win32 normal (sans avoir précisé le mode /3G au démarrage de windows), un processus ne dispose que de 32 bits pour indiquer une adresse mémoire. Windows se réserve le dernier bit pour son fonctionnement, donc aucun processus ne peut s'allouer plus de 2 Go.
Avec un OS 64 bits, peut-être que tu peux récupérer intégralement le dernier bit d'adressage, mais si une chose est sûr c'est que tu ne dépasseras pas les 4Go.

Deuxièmement, tu peux aussi être confronté à un problème de fragmentation de la mémoire. Surtout si tu travailles tel que sur ton premier post de ReadFileString, où comme l'a fait remarquer Paul TOTH tu réalloues result en boucle :
- A la première allocation, le gestionnaire mémoire demande un bloc mémoire à windows.
- Lorsque tu réalloues la chaîne, le gestionnaire mémoire de Delphi risque de demander un bloc plus important à l'OS, et conserve l'ancien bloc dans un pool interne pour le recycler par la suite.
- Dans une utilisation normale, les anciens bloc mémoires qui ne sont plus utilisés sont recylés lors des allocations suivantes, donc ça n'a pas trop d'effets néfastes (au contraire même, cette mise en cache des anciens blocs mémoire permet d'obtenir une gestion de la mémoire très rapide).
- Seulement dans ton cas de figure, tu vas allouer sans cesse des blocs plus importants, donc le gestionnaire mémoire ne peut pas recyler les anciens blocs... d'où un accroissement exponentiel de la mémoire consommée...

[ShaiLeTroll]

As-tu le code de "encrypt" ?
Peut-être effectivement que cette fonction aussi réalloue son result ...

PS : il est même très difficile d'atteindre le 2Go, arrivée à 1930Mo déjà le EOutOfMemory se déclenche ... le chiffre change selon la météo ... voir le sujet sur Phidels avec Papy John FullSpeed, en tout cas merci Franck SORIANO de ton explication ... cela répond à l'une des mes questions à ce sujet ...

[Paul TOTH]

de toute façon il est peu probable que l'encryption ai besoin de tout le fichier en ligne

[Paul TOTH]

rien à voir (encore que) mais ça me rappelle mes début sur Delphi, première version. J'avais codé un afficheur GIF qui avait bien du mal à gérer les images de plus de 64K

et voila maintenant qu'on réclame le Go de RAM

[Montor]

Mais issu final c'est quoi un fichier vedeo converti en texte puis crypter/décrypter se n'est pas la bonne démarche

[Dr.Who]

VINDIOUS!

1 : utilisation des bloc Try..Finally
2 : protection des appel SaveDialog sur execute!
3 : bonjour les performances avec AnsiString -> utilise Buffer de byte!

buffer de byte ...
parfois la prog fait dire des vulgarités ...

4 : TFileStream, TMemoryStream!
5 : Gros fichiers ? encryption ? FileStream uniquement (disk to disk on fly)

le bout de code (attention code un peu vieillo) :

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
procedure EncodeHRot(const FileNameInput, FileNameOutput, Key : string);
var
  FileNameTemp : string; // fichier temporaire
  RK : TMD5Digest; // Clef MD5
  BB : array[word] of byte; // Buffer 65Kb
  RKp, BBl, N : integer; 
  SI, SO : TFileStream; // Flux
begin
  // Creation de la clef
  RK  := MD5(Key);
 
  // Selection du premier pivot
  RKp := (RK[0] xor RK[8]) mod 16;
 
  // creation du fichier temporaire
  FileNameTemp := GetTempDir+MD5ToStr(MD5(FileNameInput))+'.tmp';
 
  // sortie si erreur de fichier en entrée
  if not FileExists(FileNameInput) then
     exit;
 
  // Compression du fichier
  SI := TFileStream.Create(FileNameInput, fmOpenRead);
  try
    SO := TFileStream.Create(FileNameTemp, fmCreate);
    try
      ZLibEx.ZCompressStream(SI,SO,zcLevel7);
    finally
      SO.Free;
    end;
  finally
    SI.Free;
  end;
 
  // Encryption du stream compréssé
  SI := TFileStream.Create(FileNameTemp, fmOpenRead);
  try
    SO := TFileStream.Create(FileNameOutput, fmCreate);
    try
      while SI.Position < (SI.Size-1) do
      begin
        // bizarre ... j'aurais pourtant juré utilisé un buffer de 65Kb ?!!
        BBl := Min(32768, SI.Size - SI.Position);
 
        // Lecture
        SI.ReadBuffer(BB, BBl);
 
        // Encryption
        for N := 0 to BBl-1 do
        begin
          if (RK[RKp] mod 2) = 0 then
             BB[N] := not byte( (BB[N] - (RK[RKp] shl (RKp mod 5))) xor RK[RKp] )
          else
             BB[N] := not byte( (BB[N] + (RK[RKp] shr (RKp mod 5))) xor RK[RKp] );
 
          // Selection d'un nouveau pivot
          RKp := (RKp + 7) mod 16;
        end;
 
        // Ecriture 
        SO.WriteBuffer(BB, BBl);
      end;
    finally
      SO.Free;
    end;
  finally
    SI.Free;
    // Suppression du fichier temporaire
    SysUtils.DeleteFile(FileNameTemp);
  end;
end;

Certe les performances seront bof bof sur de gros fichier (~1.5Mo/s et ~370 secondes pour un fichier de 700Mo sur un HP Pavilion trop vieux...), mais ici c'est surtout pour te montrer comment utiliser des FileStream.

[ShaiLeTroll]

Dr. Who, c'est très gentil ton exemple, mais on a dépassé le problème du FileStream ... tant que Saphir21 n'est pas revenu nous expliquer comment fonctionne sa fonction encrypt, on ne peut pas savoir si elle peut fonctionner correctement en buffer ou si il lui faut la totalité du fichier ...

entre BlockRead et TFileStream, il n'y a pas de grosse différence ... la transition est assez aisée ...

tu n'aurais pas une erreur ? pourquoi -1 ?

Code :

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

while SI.Position < (SI.Size-1) do

sinon pour simplifier ton code, cela fonctionne très bien, sinon j'aurais plein de code qui ne fonctionnerait pas !

Code :

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

1
2
3
4
5
6
        // Lecture
        BBl := SI.ReadBuffer(BB, SizeOf(BB));
 
        // Encryption
        for N := 0 to BBl-1 do
        begin

sache que l'accès aux propriétés Position et Size, ce n'est pas ce qu'il y a de plus performant (plein de seek donc API Windows), mieux vaut stocker la taille dans une variable ...

[Dr.Who]

non pas d'erreur :

sur position = 0 à Size-1 ...


Size = 1024 octet
Position range = 0..1023

comme pour les tableaux.


sinon oui, parfaitement d'accord sur le fait que Size est Position sont anti-performante. on devrait toujours mettre en "cache" les propriétés qui appelles des fonctions (pleins de call).

mais j'avais prévenus, le code est vieillo, donc peut performant, si j'ai le temps un jours je mettrais a jours (surtout quand on vois les faible performances des routines).


maintenant je préférais utiliser :

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
const
  BuffSize = 4096;
var FLX : TFileStream;
    Buff: array[0..BuffSize-1] of byte;
    N, L: integer;
    V   : UInt64;
begin
  ZeroMemory(@Buff, BuffSize);
  V := 0;
  L := 0;
  FLX := TFileStream.Create('c:\essaicube3d.x', fmOpenRead);
  try
    repeat
      L := FLX.Read(Buff, BuffSize);
      for N := 0 to L-1 do
        V := UInt64(V + Buff[N]);
    until L < BuffSize; // L <> BuffSize = fin du fichier
  finally
    FLX.Free;
  end;
 
  caption := format('%.16x',[V]);
end;

plus d'utilisation de position ou size ...
et même utilisation de Read plutot que ReadBuffer.

[ShaiLeTroll]

sur position = 0 à Size-1, bien sur, mais ça serait <= et non < !

ton 2eme code étant plus court, il est nettement plus simple à comprendre si l'on s'attache au TFileStream, c'est une bonnne approche pédagogique avec le repeat, c'est vrai qu'on y pense jamais !

[Dr.Who]

rhaaa mais oui, j'ai même pas vus l'erreur pourtant grossiere.

tu sais ce que c'est, on s'attache au "gros" trucs et on fail sur les chose basique.
comme oublier un ; ou un : et se demander pourquoi ça fonctionne pas.

[ShaiLeTroll]

J'ai perdu 3 heures un jour à ne pas comprendre une violation d'accès qui arrivait un peu n'importe quand, jusqu'à que je comprenne que lors d'un parcours de 3 tableaux, j'avais utilisé la mauvaise borne de fin et que cela écrivait pas où il fallait dans la mémoire ... et bien sur la VA arrivait 100 lignes de code plus bas ...

[Saphir21]

dsl de la lente réponse les gars, j'avais des exams a la faq.

le code de lencrypt, c'est une encryption rc4:

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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
{*******************************************************}
 
{       RC4 encryption unit                             }
{       October 2006, Codius                            }
{       Thanks to Michael Puff, shapeless               }
 
{*******************************************************}
unit RC4;
 
interface
 
type
  PByteArray = ^TByteArray;
  TByteArray = array [0..32767] of Byte;
 
  TRC4 = class
  Private
    D: array[Byte] of Byte;
    I, J: Byte;
    procedure Init(const Key: String);
    procedure Done;
    procedure Code(Source, Dest: Pchar; Count: Integer);
  Public
    function Encrypt(S: Pchar; const Password: String): Ansistring;
    function Decrypt(S: Pchar; const Password: String): Ansistring;
  end;
 
implementation
 
{ TRC4.Encrypt
  This function will return the text(S) encrypted with the chosen password. }
function TRC4.Encrypt(S: Pchar; const Password: String): Ansistring;
begin
  SetLength(Result, Length(S));
  Init(Password);
  Code(Pchar(S), Pchar(Result), Length(S));
  Done;
end;
 
{ TRC4.Decrypt
  This function will return the text(S) decrypted with the chosen password. }
function TRC4.Decrypt(S: Pchar; const Password: String): Ansistring;
begin
  SetLength(Result, Length(S));
  Init(Password);
  Code(Pchar(S), Pchar(Result), Length(S));
  Done;
end;
 
{ TRC4.Init
  This routine will prepare the encryption/decryption. }
procedure TRC4.Init(const Key: String);
var
  R, S, T, K: Byte;
  U, L: Integer;
  DummyArray: array [0..1599] of Char;
begin
{$R-}
{$Q-}
  L := Length(Key);
  I := 0;
  J := 0;
  R := 0;
  U := 0;
  for S := 0 to 255 do
    D[S] := S;
  for S := 0 to 255 do
  begin
    if (U < L) then
      K := PByteArray(Key)[u]
    else
      K := 0;
    Inc(U);
    if (U >= L) then
      U := 0;
    Inc(R, D[S] + K);
    T := D[S];
    D[S] := D[R];
    D[R] := T;
  end;
  Code(@DummyArray, @DummyArray, 1600);
end;
 
{ TRC4.Done
  This routine will clean the variables used when encrypting/decrypting. }
procedure TRC4.Done;
begin
  FillChar(D, sizeOf(D), 0);
  FillChar(I, sizeOf(I), 0);
  FillChar(J, sizeOf(J), 0);
end;
 
{ TRC4.Code
  This routine will encrypt the text. }
procedure TRC4.Code(Source, Dest: Pchar; Count: Integer);
var
  S: Integer;
  T: Byte;
begin
  for S := 0 to (Count - 1) do
  begin
    Inc(I);
    T := D[i];
    Inc(J, T);
    D[i] := D[J];
    D[J] := T;
    Inc(T, D[i]);
    Byte(Dest[S]) := Byte(Source[S]) Xor D[T];
  end;
end;
 
end.