Speicherbedarf Datenverbund?

[Lotus]

Servus,

ich habe folgende Typdeklartionen:

Delphi-Quellcode:

type tpointer=^tdaten;
tdaten=record
name:string[10];
next:tpointer;
end;

Für mich wären dies ein Speicherbedarf von 15Byte (11 für String+4Byte für den Pointer)

Delphi gibt mir allerdings per sizeof(tdaten) eine größe von 16 Byte aus... warum?
Bzw. welches Ergebnis ist nun richtig?

[edit=mkinzler]Delphi-Tag eingefügt Mfg, mkinzler[/edit]

[mkinzler]

Es wird auf auf Word-Grenzen ausgerichtet. 15Bytes wäre es bei packed

[Lotus]

Kann ich sizeof so einstellen das es nur packed ausgibt? bzw. wo is der unterschied von packed?

[alzaimar]

Das Schlüsselwort 'packed' weist den Compiler an, die Felder bytegenau anzuordnen. Dann ist der Zugriff aber etwas langsamer. Ohne diesen Zusatz werden die Felder (aus Gründen der Performance) -wie mkinzler schon sagte- 16bit-weise angeordnet.

'SizeOf' kann man nicht 'einstellen' :gruebel:

[Lotus]

Gäbe es noch eine andere Methode den Speicherbedarf (packed) auszugeben?

[mkinzler]

Was gefällt dir an packed nicht?
Warum ist die das eine Byte so wichtig?

[guidok]

Zitat:

Zitat von Lotus

Gäbe es noch eine andere Methode den Speicherbedarf (packed) auszugeben?

Ich glaube du missverstehst hier etwas. Es geht nicht um die Ausgabe des Speicherbedarfes, denn der wird so wie du den Record deklariert hast richtig ausgegeben. Du müsstest deinen Record anders deklarieren:

Delphi-Quellcode:

tdaten = packed record 
  name : string[10]; 
  next : tpointer; 
end;

Auf diese Weise wird der Speicher anders angeordnet (eben nicht mehr wortweise) und der Speicherbedarf ändert sich entsprechend. Geht, wie schon von den Vorrednern geschrieben, etwas zu Lasten der Performance.

[Bernhard Geyer]

Zitat:

Zitat von alzaimar

-wie mkinzler schon sagte- 16bit-weise angeordnet.

Die Ausrichtung kann schon lange auf 1/2/4 oder 8 Byte eingestellt werden (Projektoptionen/Compiler/Codeerzeugung -> Ausrichtung von Record-Felder).
Bei neueren Delphi-Versionen ist hier der Default-Wert 8 Byte. Dies ist auch für neuerer Prozessoren (Pentium (?) und neuer) auch besser da hier die Prozessorarchitektur schon auf 64-Bit Speicherzugriff ausgerichtet ist).

[himitsu]

Zitat:

Zitat von Lotus

Delphi gibt mir allerdings per sizeof(tdaten) eine größe von 16 Byte aus... warum?

Weil Delphi es per alles Standard so ausrichtet, daß der Zugrigg optimaler Weise an Integergrenzen beginnt und auch die ganze Datenstruktur als vielfaches von Integern auftritt, also sich über ganze Integer-Operationen zu kopieren läßt.

Zitat:

Zitat von alzaimar

-wie mkinzler schon sagte- 16bit-weise angeordnet.

'SizeOf' kann man nicht 'einstellen' :gruebel:

nein, es sind 32 Bit ...
Test: versuch es einfach mal mit string[8] :angel2:

jupp, die Ausrichtung mußt du direkt am Record einstellen, also Packed oder nicht und wenn nicht, dann greift hier als Erstes das aktuell in der Unit gültige/letzte {$A...} bzw. {$ALIGN ...} (siehe OH) und wenn da nichts steht, dann das aus den Projektoptionen.

Zitat:

Kann ich sizeof so einstellen das es nur packed ausgibt? bzw. wo is der unterschied von packed?

blos weil dir ein Maß nicht gefällt, änderst du ja auch nicht das Linial, sondern das zu Messende :zwinker:

PACKED besagt ... ach, schau einfach mal bei packed in deine OH.

[mkinzler]

Zitat:

Die Ausrichtung kann schon lange auf 1/2/4 oder 8 Byte eingestellt werden (Projektoptionen/Compiler/Codeerzeugung -> Ausrichtung von Record-Felder).
Bei neueren Delphi-Versionen ist hier der Default-Wert 8 Byte. Dies ist auch für neuerer Prozessoren (Pentium (?) und neuer) auch besser da hier die Prozessorarchitektur schon auf 64-Bit Speicherzugriff ausgerichtet ist).

In seinem Fall sind es wohl 2 Bytes

[Bernhard Geyer]

Zitat:

Zitat von mkinzler

In seinem Fall sind es wohl 2 Bytes

Oder auch 4 Bytes sein. Kommt für den o.g. Record aufs gleiche raus.

[himitsu]

Zitat:

Zitat von mkinzler

In seinem Fall sind es wohl 2 Bytes

dann hat er wohl was verstellt? :gruebel:
(D7 und D2009 machen bei der Recordgröße per Standard 4)

Zitat:

Delphi-Quellcode:

type tpointer=^tdaten;
tdaten=record
  name: string[10];
  next: tpointer;
end;

gemessen: (obwohl in D2009 eigentlich QuadWord in den Projekttionen eingestellt ist :gruebel: und selbst ein {$A8} hat keine Auswirkung darauf ... aber zumindestens {$A1} läßt es PACKED sein)

Zitat:

string[6] = 12 Byte
string[8] = 16 Byte
string[10] = 16 Byte
string[12] = 20 Byte

[add]

Delphi-Quellcode:

{$A8}

type tpointer=^tdaten;
tdaten=record
  name: string[2];
  next: tpointer;
end;

müßte doch mindestens 8(3) + 4 Byte sein, wenn "next" an der nächsten 8 Byte-Genze liegen würde?

[Lotus]

Ich persönlich möchte gar nichts mit diesem Datensatz anfangen. Es geht nur darum, das ich in ein paar Tagen meine Prüfung (Abitur) in Informatik ablegen muss und mein Lehrer stellt gern einmal solche Aufgaben wo man den Speicherbedarf ermitteln soll. Dürfte normalerweise kein Problem darstellen, aber nur um sicherzugehen wollte ich halt mit sizeof nachprüfen. Mit packed dürfte das ja nun ganz gut funktionieren.

Noch ne kurze Frage:

Bei Pointern haben wir gelernt das man 4Byte für den Zeiger selbst braucht.
Brauch ich diese 4 Byte nur einmal? Oder brauch ich diese 4Byte für die Anzahl meiner Datensätze?

Nach dem Datensatz oben (packed) haben wir ja einen Verbrauch von 15Byte.. hierzukommen dann diese 4Byte für den Pointer.. wenn ich jetzt 2datensaetze habe... brauch ich dann diese 4 byte noch ein zweites mal?

[mkinzler]

Eine 2. Pointer variable belegt wieder 4 Bytes

[Bernhard Geyer]

Zitat:

Zitat von Lotus

Bei Pointern haben wir gelernt das man 4Byte für den Zeiger selbst braucht.

Um mal kleinkarriert zu sein: 4 Byte sind es auf einem 32-Bit-System. Auf einem 64-Bit System (woh ja gerade der Wechsel erfolgt) sind es 8 Byte.

[Lotus]

ok danke sehr.. damit haben sich alle fragen geklärt!

[himitsu]

Zitat:

Zitat von Lotus

Ich persönlich möchte gar nichts mit diesem Datensatz anfangen. Es geht nur darum, das ich in ein paar Tagen meine Prüfung (Abitur) in Informatik ablegen muss und mein Lehrer stellt gern einmal solche Aufgaben wo man den Speicherbedarf ermitteln soll. Dürfte normalerweise kein Problem darstellen, aber nur um sicherzugehen wollte ich halt mit sizeof nachprüfen. Mit packed dürfte das ja nun ganz gut funktionieren.

Jupp, bei Packed brauchst du ja nur die Größen der Einzelteile bestimmen, zusammenrechnen und fertig.

Bei ungepackten/ausgerichteten Records:

der Beispielrecord:

Delphi-Quellcode:

daten = record
  S: String[10];
  B: Byte;
  i: Integer;
  K: Int64;
  P: Pointer;
  W: Word;
end;

entweder du stellst dir ein Raster vor

per Standard also mit 4 Byteschritten (Integergrenzen)
und richtest nacheinander die Elemente an den Grenzen aus

Delphi-Quellcode:

// packed / packed[1]      30 Byte
sSSSSSSSSSSBiiiiKKKKKKKKPPPPWW

// unpacked / packed[4]    36 Byte = 9 * 4[Integer]
1---2---3---4---5---6---7---8---9---
sSSSSSSSSSS B   iiiiKKKKKKKKPPPPWW

// unpacked / packed[8]    56 Byte = 7 * 8[Int64]
1-------2-------3-------4-------5-------6-------7-------
sSSSSSSSSSS     B       iiii    KKKKKKKKPPPP    WW

// unpacked / packed[2]    32 Byte = 16 * 2[Word]
1-2-3-4-5-6-7-8-9-0-1-2-3-4-5-6-
sSSSSSSSSSS B iiiiKKKKKKKKPPPPWW

oder du rundest jedes Element auf die Gittergrößen auf
und rechnest dieses nur noch zusammen

Code:

.                SizeOf/
                 packed   packed[4]   packed[8]   packed[2]
S: String[10];   11       3*4= 12     2*8= 16     6*2= 12
B: Byte;         1        1*4= 4      1*8= 8      1*2= 2
i: Integer;      4        1*4= 4      1*8= 8      2*2= 4
K: Int64;        8        2*4= 8      1*8= 8      4*2= 8
P: Pointer;      4        1*4= 4      1*8= 8      2*2= 4
W: Word;         2        1*4= 4      1*8= 8      1*2= 2
                 =30           =36         =56         =32