Memory mapped files - Ist ein offset zugriff möglich?

[Sequitar]

Ich habe eine einfache Inter-prozess-Kommunikation mittels MMF. Dabei habe ich einen geteilten "Namespace", der die einzelnen MMFs eindeutig addressierbar macht.
Unabhängig davon würde ich gerne innerhalb einer einzigen MMF verschiedene Bereiche ansprechen. Ich dachte, das geht einfach mit folgendem:

Delphi-Quellcode:

type mydata=record
 //..
end;
//...
Mem := MapViewOfFile(Memsharehandle^, FILE_MAP_WRITE
      { FILE_MAP_ALL_ACCESS { both read and write } ,0, 0, Size);//->>dwfileoffsethi=0,dwfileoffsetlo=0
// copy the data
CopyMemory(Mem, MyData, { Sizeof(Mydata^) } Size);

Ich hab gelesen, dass die Offsets ein vielfaches der standard Allokationsgrößse des OS (Hier win64) sein müssen,
allerdings kann ich keine offsets<>0 festlegen, ohne Access-Violations im anschließsenden CopyMemory zu produzieren. (Eigentlich klar, wenn ich einen falschen Adressbereich kopieren möchte)

die Frage ist also, Kann ich denn hier mithilfe der beiden offsets zwischen verschiedenen positionen innerhalb einer MMF springen und so unterschiedliche Bereiche der MMF beschreiben / abfragen?

Danke

[himitsu]

Zitat:

If the function fails, the return value is NULL. To get extended error information, call GetLastError.

Warum macht niemand das, was in der Doku steht?

Zitat:

kann ich

Ja.

Und man kann aber auch zu Mem ein Offset draufrechnen, wenn es innerhalb von Size liegt.

[Sequitar]

Zitat von himitsu:

Zitat:

If the function fails, the return value is NULL. To get extended error information, call GetLastError.

Warum macht niemand das, was in der Doku steht?

Zitat:

kann ich

Ja.

Und man kann aber auch zu Mem ein Offset draufrechnen, wenn es innerhalb von Size liegt.

Danke schon mal für deine Rckmeldung. Leider muss ich feststellen, dass das mit dem einfachen "draufrechnen" nicht funktioniert. Ich glaube ich habe die Offsets falsch gesetzt (da wohl noch nicht korrekt verstanden):

Ein Test-Case:

Delphi-Quellcode:

// exemplary data definition:
// pmydata=^tmydata
// tmydata=record
// astring:Shortstring;
// id:byte
// end;

procedure test_access_existing_share;

Var
  Mydata_in1, mydata_in2: Pmydata;
  mydata_seq1, mydata_seq2: Pmydata;
  Mydata_out: TMyData;
  filehandle: thandle;
  share: TMMFWriter;
begin
  share := TMMFWriter.Create;
  filehandle := share.Createsharedmemspace(Privatespaceid, 5000);
  // assigns new space and saves it to access in a dictionary
  Assert(share.Shares[Privatespaceid]^ = filehandle); // OK
  // add first element
  New(Mydata_in1); // pointer to record
  Mydata_in1^.Create(33);
  share.WriteToMMF(filehandle, Mydata_in1, Sizeof(TMyData));
  Mydata_out := share.ReadFromMMF<TMyData>(filehandle);
  Assert(Mydata_out.id = 33); // OK
  // add 2 elements sequentially:
  // first element
  New(mydata_seq1);
  mydata_seq1^.Create(34, '');
  Assert(mydata_seq1^.id = 34);
  share.WriteToMMF(filehandle, mydata_seq1, Sizeof(TMyData));
  // get again
  Mydata_out := share.ReadFromMMF<TMyData>(filehandle, 0);
  Assert(Mydata_out.id = 34);
  // second element
  New(mydata_seq2);
  mydata_seq2^.Create(35);
  Assert(mydata_seq2^.id = 35);

//Problemstelle (mit manuellem offset: +sizeof(tmydata)):

  { try to add second element at the end, by setting offset=sizeof(tmydata).
    adding fails, wrong offset / wrong writing access?
    raising custom exception "Error writing to shared memory" @copymemory
    share.WriteToMMF(filehandle, mydata_seq2, Sizeof(TMyData), Sizeof(TMyData));//hier
    // !!
    // test get sequential elements, but only gets last added:
    // !!!
    //  Mydata_out := share.ReadFromMMF<TMyData>(filehandle, Sizeof(TMyData));
    //  Assert(Mydata_out.id = 35);
    }
    // clean up
    share.Closeshare(Privatespaceid);
  Dispose(Mydata_in1);
  Dispose(mydata_seq1);
  Dispose(mydata_seq2);
  share.Free;
end;

Im Anhang: die entsprechende Writer-Klasse. Ich würde mich über Anmerkungen, Gedankenfehler freuen. Danke