[C#] Marshaling performance problemen

[voodooless]

Het volgende is geval:

We hebben een dll gemaakt die wat fun stuff doet. Hieronder de imports:

C#:

[DllImport("funstuff.dll", CharSet = CharSet.Ansi)]
private static extern void freeStuff(IntPtr ptr);
[DllImport("funstuff.dll", CharSet = CharSet.Ansi)]
private static extern IntPtr doStuff(double dx, double dy);

doStuff geeft een pointer terug naar een stuk data met het resultaat.

Nu hebben we het volgende stukje testcode:

C#:

for (int i=0; i<100000; i++) {
   // do stuff
   IntPtr pointers = doStuff(i*0.00001, i*0.00001);
   // lees data
   IntPtr stringPointer1= Marshal.ReadIntPtr(pointers, 0);
   IntPtr stringPointer2= Marshal.ReadIntPtr(pointers, 4);
   IntPtr stringPointer3= Marshal.ReadIntPtr(pointers, 8);
   int x1 = Marshal.ReadInt32(pointers, 12);
   int y1 = Marshal.ReadInt32(pointers, 16);
   int x2 = Marshal.ReadInt32(pointers, 20);
   int y2 = Marshal.ReadInt32(pointers, 24);
   int z = Marshal.ReadInt32(pointers, 28);
   // hier doen we stuff met de data, maar voor de test doen we even niets
   ... 
   // geef memory vrij   
   freeStuff(pointers);
}

Dit stukje code doet er zo'n 18 seconden over in deze vorm. Wat is nu het geval: als de Marschaling van int x1 tot z weglaten (gewoon even in commentaar zetten) doet het stukje code er 9 seconden over.

Wat is namelijk het 2e geval: De zelfde DLL heeft ook JNI exports met vrijwel de zelfde interface. doStuff geeft dan netjes een java object terug welke in C code netjes via JNI calls is opgebouwd. En dit is gewoon rete snel. Vergelijkbare code in Java doet er ook zo'n 9 seconden over, maar dan heb je wel alle data die je nodig hebt.

De vraag is dus waarom dit Marschaling in C# zo extreem traag is en of er niet een betere manier is om dit te doen

Wat we al hebben geprobeerd is om in C# een struct te maken om ze de data in te lezen, maar om de een of ander reden komt daar alleen maar rubbish uit.

[riezebosch]

Waarschijnlijk kan je er wel een struct van maken en kan je zelf op de fields de FieldOffset instellen. Zoiets dus:

C#:

struct MyStruct
{
   [FieldOffset(12)]
   public int x1;
   [FieldOffset(16)]
   public int y1;
   [FieldOffset(20)]
   public int x2;
   [FieldOffset(24)]
   public int y2;
   [FieldOffset(28)]
   public int z; 
}

[ Voor 54% gewijzigd door riezebosch op 20-11-2007 12:29 ]

[voodooless]

Bedankt! Om de een of ander rede gaat het zo wel goed. Ook de string pointers worden correct in de struct geladen. Ik snap nog steeds niet waarom het nu eerst niet werkte, want we deden zo'n beetje precies 't zelfde... Misschien hebben we uit frustratie te veel dingen tegelijk veranderd om het te laten werken. 'T is nog steeds niet zo snel als de Java variant (scheelt een seconde), maar het resultaat is bevredigend genoeg.