SetLength Access violation

Version imprimable

Hi

I have a problem when I want to change the size of a dynamic array but if the data is fill with value other than 0 I have an error message Access Violation

I do a simple unit to reproduce this error

Step by step, the error append when SetLength(VarB,VarSize) is call

Code:

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
 
unit Unit1;
 
interface
 
uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls;
 
type
  TBPointReal      = array of double;
 
  TForm1 = class(TForm)
    Button1: TButton;
    procedure InitVar;
    procedure AddVar(VarSize: integer);
    procedure Button1Click(Sender: TObject);
    procedure FormActivate(Sender: TObject);
 
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
    VarA,VarB    : TBPointReal;
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.dfm}
procedure TForm1.AddVar(VarSize: integer);
begin
  SetLength(VarA,VarSize);
  SetLength(VarB,VarSize);
end;
 
procedure TForm1.InitVar;
begin
  FillChar(VarA,SizeOf(VarA),0);
  FillChar(VarB,SizeOf(VarB),999);
end;
 
procedure TForm1.FormActivate(Sender: TObject);
begin
  AddVar(4);
  InitVar;
end;
 
procedure TForm1.Button1Click(Sender: TObject);
begin
  AddVar(8);
end;
 
end.

Why this code is not correct

Thankyou

Bonjour,

Vous pouvez écrire en français, c'est un peu tout l'intérêt de Developpez.com d'avoir une communauté francophone.

C'est FillChar qui est la source de la future exception, confusion entre VarA qui est la référence sur le tableau et VarA[0] qui est l'emplacement mémoire du premier élément
SizeOf renvoie d'ailleurs 4 ou 8 selon 32/64Bits car c'est juste la taille de la référence (un pointeur) contrairement à SizeOf(VarA[0]) qui retournera toujours 8 la taille d'un Double
En fait, le InitVar altère la référence et non le contenu du tableau, résultat au prochain SetLength, l'opération est effectuée sur une adresse totalement fausse, sans compter que 999 me semble bien elévé, je dirais 255 au plus car c'est un Byte ou AnsiChar)
Code:

1 2 3 4 5 procedure TForm1.InitVar; begin FillChar(VarA[0], SizeOf(Double) * Length(VarA), 0); // Inutile après un SetLength FillChar(VarB[0], SizeOf(Double) * Length(VarB), 999); // Valeur 999 fausse tronqué à 255 soit $FF, ça ferait en fait un Double en $FFFFFFFFFFFFFFFF soit probablement NaN. end;
A Noter que le SetLength initialise le tableau par défaut à Zéro, à l'instar des membres d'une classe donc inutile de le refaire.
Pour initialiser 999 dans chaque Double, FillChar ne fonctionnera pas car cela travaille à l'octet et non à la valeur, une boucle classique sera donc à utiliser

09/09/2021, 09h41
FlyByck

Merci pour ces explications
Je voulais optimiser pour eviter une boucle !

Cordialement
09/09/2021, 10h36
ShaiLeTroll

FillChar fait aussi une boucle qui écrit par lot de 8 octets la combinaison calculée de la valeur en entrée
La boucle sur un tableau de Double sera de performance équivalente
On manipule la mémoire par Registre du CPU donc pas de miracle.

Récemment, j'ai fait le test d'ailleurs sur un objet lent dans un programme dont j'ai la charge de l'optimisation, le SetLength était long sur un tableau de 1Mo bien plus long que les tests que j'avais fait pour un GetMem sur un 1Mo, en fait c'est le ZeroMemory (un FillChar 0 donc) qui prend du temps, la majeur partie en fait.

en même temps il faudrait un tableau de taille tout de même extrêmes conséquente pour que ce soit sensible

sinon on peut imaginer une copie du type
Code:

1 2 3 4 5 6 Tab[0] := 999; // 1 élément Move(Tab[0], Tab[1], SizeOf(Double)); // 2 éléments Move(Tab[0], Tab[2], 2 * SizeOf(Double)); // 4 éléments Move(Tab[0], Tab[4], 4 * SizeOf(Double)); // 8 éléments ...
en doublant la taille de la copie à chaque fois et en terminant sur une copie limitée aux nombres restant à la fin

là j'ai mis un code en dur, mais on doit pouvoir le rendre paramétrable avec un "while 2 * Count < TotalLen do" et un move Final pour la fin du tableau

bonsoir

j'avais trouvé ceux-ci sur le net
l'auteur n'est autres que Henri Gourvest

Code:

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
 
procedure FillDouble(var Dest; Count: integer; Value: double); register;
{$IFNDEF USEASM} // 2687 ms
var
  i  : integer;
  p : PDouble;
begin
  p := @dest;
  for i := 1 to count do
  begin
     p^ := Value;
     inc(integer(p), 8);
  end;
end;
{$ELSE} // 5656 ms
asm
  test edx, edx
  jz @@End
  fld qword ptr [ebp+8]
  @@Loop:
  fst qword ptr [eax]
  lea eax, eax+8
  dec edx
  jnz @@Loop
  ffree st(0)
  @@End:
end;
{$ENDIF}
 
procedure TForm1.Button2Click(Sender: TObject);
var
  c: cardinal;
  i: integer;
  buffer: array[1..1000] of double;
begin
  c := GetTickCount;
  for i := 1 to 1000000 do
     FillDouble(buffer, length(buffer), 1.1);
  memo1.Lines.Add(inttostr(GetTickCount - c));
end;

Attention pour FillDouble,
Si buffer fonctionne pour un tableau statique, c'est toujours buffer[0] pour un tableau dynamique.

Et Inc(P); est suffisanr pour déplacer le pointeur, cela gère automatiquement le décalage pour un pointeur typé.
Surtout pour conserver un pointeur 64Bits on ne sait jamais :roll:

Autre façon de l'écrire
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 procedure FillDouble(var Dest; Count: Integer; Value: Double); register; var P, PE: PDouble; begin P := @Dest; PE := P; Inc(PE, Count); {$POINTERMATH ON} while P < PE do {$POINTERMATH OFF} begin P^ := Value; Inc(P); end; end;

10/09/2021, 09h39
anapurna

salut

tiens je ne connaissais pas cette directive {$POINTERMATH ON}
Merci pour cette petite astuce