1GB Pointer bekommen

[NickelM]

Hallo einmal wieder,

Ich bin gerade an einem Programm amschreiben, wo ich große Datanmengen im Speicher ablege, damit ich die dan Verwalten kann. Der User kann den Buffer, die Größe an Daten, die im Speicher liegt fürs lesen selber Wählen. Ich wollte ihm natürlich auch eine Große Anzahl ermöglichen, da es eine Art FileViewer ist.

Es ist eine 32bit Anwendung und ich hab kein Delphi XE2 oder so, um 64bit zu Kompilieren xD Und soll auch nicht.

So ich habe selber 32bit Windows nur mit 4GB (3,5GB möglich zu verwenden, dass weiß ich)

So bei Pointergrößen von < 256MB funkt es fast immer, wenn ich jedoch 512MB oder 1GB nehmen will, sagt er mir ich hätte nicht genug Speicher, was nicht Stimmt.

So folgendes, gibt irgendeine Möglichkeit, einen Pointer zubekommen der solche Größen mir erlaubt oder nicht?
Ich habe schon einen Post hier gelesen, das wegen Dll's und so es kaum Möglich ist so EINEN Pointer zubekommen der solche Größe hat. Kann ich dann vielleicht 4x256MB Pointer bei 1 GB machen? Weil das müsste ja gehen, da ich nen Spiel hab, das locker 1GB Speicher insgesammt verwendet, wenns läuft.

Gruß NickelM

[Bernhard Geyer]

Zitat von NickelM:

So bei Pointergrößen von < 256MB funkt es fast immer, wenn ich jedoch 512MB oder 1GB nehmen will, sagt er mir ich hätte nicht genug Speicher, was nicht Stimmt.

Es stimmt schon. Du willst 512/1GB durchgehenden Adressraum. Denn hat aber deine 32-Anwendung nicht mehr zur Verfügung.

Zitat von NickelM:

So folgendes, gibt irgendeine Möglichkeit, einen Pointer zubekommen der solche Größen mir erlaubt oder nicht?

Es gab mal (als Windows nur 32-Bit konnte) möglichkeiten solche Extension für 32-Bit zu bekommen. Dies war aber AFAIK nie für Delphi-Apps möglich und mit 64-Bit Windows ist dieses Workaround auch gar nicht mehr nötig.

Zitat von NickelM:

Ich habe schon einen Post hier gelesen, das wegen Dll's und so es kaum Möglich ist so EINEN Pointer zubekommen der solche Größe hat. Kann ich dann vielleicht 4x256MB Pointer bei 1 GB machen?

Ja, kannst du. Einfach 4*256 (oder besser 10*100 MB) anfordern. Ist halt dann keine durchgehender Adressraum mehr.
Oder eifach deine Datenstrukturen so wählen das du einfach immer kleine Häppchen benötigst. Dann solltest du auch nahe der 2 bzw. 3 GB Grenze kommmen

[Furtbichler]

Was willst du eigentlich mit 1GB am Stück?

[NickelM]

Naja, es ist einfacher mit einem Pointer, weil ich mit "Pointer-Adressverschiebung" arbeite um die Bytes im Pointer zu interpretieren aller
PInt64(Cardinal(Anfangpointer) + Offset)^ Wenn ich dann mit Offsets und mehrer Pointern (da ich dan die Pointer in nen Array hinterlege) und dann je nach Offset den Pointer wechseln muss, wird mist zuschreiben xD

Geht eigentlich nur um die Einfachheit und das ich nicht so oft direkt aus der Datei lesen muss.
Ich glaube mit mehren Pointern bei 1GB zuarbeiten wird etwa umständlich. besonders, wenn der Bereich von einem Typ (Int64 z.b.) in einen anderen Pointer übergeht, dann muss ich das zwischenspeichern und lesen, das ist Mist.

[Namenloser]

Klingt nach einem Kandidaten für Memory Mapped Files.

Für MMF gibt es auch schon einige Wrapper hier in der DP, z.B. (auf die Schnelle über Google gefunden) diesen. Habe aber bisher keinen davon selbst ausprobiert.

[Furtbichler]

Zitat von NickelM:

Naja, es ist einfacher

Schon klar. Und was ist, wenn die Datei größer als 1GB ist? 20, 30 100? Ist doch blöd, so eine Lösung, die nur manchmal funktioniert. Machs doch richtig.

Wenn Du in einer Datei einen String der Länge L suchst, dann liest Du dir einen Puffer der Länge P ein, wobei P>L.

Du kannst direkt bis von Position 0..P-L suchen. Dann verschiebst Du die Bytes P-L...P-L-1 an die Stelle 0..L-1 und liest P-L-1 Bytes ab Position L ein. Das ganze wiederholst Du bis zum Ende. Fertig.

Das geht natürlich noch schneller und vielleicht sogar mit MMF, aber eine nette Übung ist es in jedem Fall.

Merke: Mach es richtig UND einfach, nicht einfach nur einfach.

[NickelM]

Naja, im Prinzip mache ich ja sowas ähnliches. Ich teile eine Datei in Buffers auf und lese den kompletten Buffer und danach interpretiere ich diesen Buffer. Ich kann dann, wenn die Datie größer ist als der Buffer, den rest oder den nächsten Teil der Datei in den buffer lesen und interpetieren. Es ist mit absicht so gemacht, dass man nur den Buffer interpetiert wird.

Naja ich kann ja mal kurz das Prog erklären, weil ich es sowieso später in die DP setzen wollte.

Das Programm ist dafür da, die Bytes einer Datei zu interpretieren und dadurch Formate zu verstehen und dann Programme zuschreiben, die das Format lesen. Es ist eine Art Tool für Programmierer, die Formate lesen wollen, wo es z.b. keine Docu gibt. Es soll nicht zum Hacken oder sowas animieren xD

Mann kann dann halt die Bytes interpretieren lassen und dafür wäre es am besten einen Pointer für die Daten, die interpetiert werden, zuhaben. Das macht es am einfachsten.

Ich denke aber, das ich wohl den auszuwählen Buffer wohl auf 256 MB begrenzen muss, weil die größen halt selten verwendet werden können.

[himitsu]

Du kannst auch eine MMF nehmen, welche sogar mehr als 4GB vom physischen RAM+Auslagerungsdatei nutzen könnte
und davon wird dann immer nur der grade benötigte Teil in deinen virtuellen Arbeitsspeicher (standardmäßig 2 GB) mappen.

[Namenloser]

[OT]
Cool, sowas hatte ich mir schon öfter gewünscht... also so eine Art „Syntaxhighlighting“ für Binärdateien... oder man könnte auch sagen IDA Pro für reine Daten statt für Programme.

Hatte aber nie die Idee, wie man das gescheit umsetzen könnte aufgrund der unendlichen Möglichkeiten, wie ein Format aufgebaut sein könnte. Solange es sich nur um einfache Record-Formate handelt, ist es ja noch einfach, aber was, wenn die Datei aus mehreren Abschnitten oder aus Chunks mit Längenangabe besteht, oder es sich gar um eine Baumstruktur handelt oder oder oder... Ist eigentlich nur mit Scripting zu realisieren, meine ich. Da besteht die Kunst dann darin, eine gute API zu designen.

Würde mich sehr interessieren, was du am Ende zu stande bringst
[/OT]

[Insider2004]

Deine Zeigerarithmetik ist falsch. Stichwort PByte ab XE2 bzw. PAnsiChar bei <XE2.