Einzelnen Beitrag anzeigen

Benutzerbild von himitsu
himitsu

Registriert seit: 11. Okt 2003
Ort: Elbflorenz
43.166 Beiträge
 
Delphi 12 Athens
 
#10

Re: Speicherausrichtung (Align) berechnen

  Alt 25. Nov 2009, 21:24
Die bißher "besten" Informationen hab ich nun erstmal hier gefunden:
http://en.wikipedia.org/wiki/Data_structure_alignment
http://msdn.microsoft.com/en-us/libr...8VS.71%29.aspx

Schlimm wird es aber bei sowas:
Delphi-Quellcode:
// align = 2, 4 oder 8

Type
  T1 = Record
    A: Array[0..1] of Byte;
    B: Byte;
  End;
  T2 = Record
    A: Word;
    B: Byte;
  End;
Die beiden Records sind (packed) 3 Byte groß, werden aber anders behandelt.

SizeOf(T1) = 3
SizeOf(T2) = 4

Und als SubRecords oder in Arrays wird T2 an 2er-Grenzen ausgerichter, aber T1 natürlich nicht.


Ich bekomme zwar langsam so Einiges zusammen, aber auch nur durch ausprobieren

hatte sogar mal vor lauter Wahnsinn 'ne größere Testreihe gemacht ... nur um ganz ganz ganz sicher zu gehn
Delphi-Quellcode:
{$ALIGN x}
Type TA = Record
    B: Array[1..y] of Byte;
    C: z;
  End;
Type TD = Record
    B: Array[1..Y] of Byte;
    C: z;
    D: Byte;
  End;
Code:
x = align
y = 1..7
z = 1:Byte 2:Word 4:LongWord 8:Int64 10:Extended

// > size  (C)
// V offset (B)
//
// Integer(@A.C) - Integer(@A.B)
//     align 1           align 2           align 4           align 8
//     1  2  4  8 10     1  2  4  8 10     1  2  4  8 10     1  2  4  8 10
// 1   1  1  1  1  1     1  2  2  2  2     1  2  4  4  4     1  2  4  8  8
// 2   2  2  2  2  2     2  2  2  2  2     2  2  4  4  4     2  2  4  8  8
// 3   3  3  3  3  3     3  4  4  4  4     3  4  4  4  4     3  4  4  8  8
// 4   4  4  4  4  4     4  4  4  4  4     4  4  4  4  4     4  4  4  8  8
// 5   5  5  5  5  5     5  6  6  6  6     5  6  8  8  8     5  6  8  8  8
// 6   6  6  6  6  6     6  6  6  6  6     6  6  8  8  8     6  6  8  8  8
// 7   7  7  7  7  7     7  8  8  8  8     7  8  8  8  8     7  8  8  8  8
//
// SizeOf(TA)
//     align 1           align 2           align 4           align 8
//     1  2  4  8 10     1  2  4  8 10     1  2  4  8 10     1  2  4  8 10
// 1   2  3  5  9 11     2  4  6 10 12     2  4  8 12 16     2  4  8 16 24
// 2   3  4  6 10 12     3  4  6 10 12     3  4  8 12 16     3  4  8 16 24
// 3   4  5  7 11 13     4  6  8 12 14     4  6  8 12 16     4  6  8 16 24
// 4   5  6  8 12 14     5  6  8 12 14     5  6  8 12 16     5  6  8 16 24
// 5   6  7  9 13 15     6  8 10 14 16     6  8 12 16 20     6  8 12 16 24
// 6   7  8 10 14 16     7  8 10 14 16     7  8 12 16 20     7  8 12 16 24
// 7   8  9 11 15 17     8 10 12 16 18     8 10 12 16 20     8 10 12 16 24
//
// SizeOf(TD)
//     align 1           align 2           align 4           align 8
//     1  2  4  8 10     1  2  4  8 10     1  2  4  8 10     1  2  4  8 10
// 1   3  4  6 10 12     3  6  8 12 14     3  6 12 16 16     3  6 12 24 24
// 2   4  5  7 11 13     4  6  8 12 14     4  6 12 16 16     4  6 12 24 24
// 3   5  6  8 12 14     5  8 10 14 16     5  8 12 16 16     5  8 12 24 24
// 4   6  7  9 13 15     6  8 10 14 16     6  8 12 16 16     6  8 12 24 24
// 5   7  8 10 14 16     7 10 12 16 18     7 10 16 20 20     7 10 16 24 24
// 6   8  9 11 15 17     8 10 12 16 18     8 10 16 20 20     8 10 16 24 24
// 7   9 10 12 16 18     9 12 14 18 20     9 12 16 20 20     9 12 16 24 24
und nun probiere ich verschiedene Record/Array-Kombinationen
Garbage Collector ... Delphianer erzeugen keinen Müll, also brauchen sie auch keinen Müllsucher.
my Delphi wish list : BugReports/FeatureRequests
  Mit Zitat antworten Zitat