Array größer als 2Gb (Int32.Max) - gcAllowVeryLargeObjects

  • C#
  • .NET (FX) 4.5–4.8

Es gibt 6 Antworten in diesem Thema. Der letzte Beitrag () ist von Facebamm.

    Array größer als 2Gb (Int32.Max) - gcAllowVeryLargeObjects

    Hallo :D

    Ich bin gerade dabei eine Datenbank auszulesen.

    In dieser sind mehr als Int32.Max Tupel enthalten die ich einmal Komplett reinladen müsste in ein Array.
    Ich weiß es gibt limits womit ich ein Teil der Tupel laden könnte und dann den Rest, aber die Tupel basieren aufeinfander und müssen im Ganzen gesehen werden.

    Was ich im Internet gefunden habe ist - gcAllowVeryLargeObjects - aber ich hab keine Ahnung wie die Eigenschaft in dotnet Core setze O.o

    Kann mir da wer helfen? ?(

    EDIT:
    Source - Code
    Spoiler anzeigen
    ​

    C#-Quellcode

    1. ​unsafe class BigList<T> : IDisposable
    2. {
    3. private const int BASE_INIT_CAP = 4;
    5. private delegate IntPtr InternalAllocDelegate(object obj, GCHandleType gCHandleType);
    7. private delegate void InternalFreeDelegate(IntPtr handle);
    8. private delegate object InternalGetDelegate(IntPtr handle);
    10. private static readonly InternalAllocDelegate InternalAlloc = GetMethodOf<InternalAllocDelegate>(typeof(GCHandle), "InternalAlloc", BindingFlags.NonPublic | BindingFlags.Static);
    11. private static readonly InternalFreeDelegate InternalFree = GetMethodOf<InternalFreeDelegate>(typeof(GCHandle), "InternalFree", BindingFlags.NonPublic | BindingFlags.Static);
    12. private static readonly InternalGetDelegate InternalGet = GetMethodOf<InternalGetDelegate>(typeof(GCHandle), "InternalGet", BindingFlags.NonPublic | BindingFlags.Static);
    14. public T this[long index] {
    15. get => (T)InternalGet(GetHandleValue(ref *((IntPtr*)_internalMem.ToPointer() + index)));
    16. set {
    17. IntPtr* elementPtr = ((IntPtr*)_internalMem.ToPointer() + index);
    18. if (*elementPtr != IntPtr.Zero)
    19. {
    20. InternalFree(*elementPtr);
    21. }
    22. *elementPtr = SetIsPinned(InternalAlloc(value, GCHandleType.Pinned));
    23. }
    24. }
    26. private long _capacity;
    27. private IntPtr _internalMem;
    28. public long Count;
    30. public BigList() : this(BASE_INIT_CAP) { }
    32. public BigList(long baseCapacity)
    33. {
    34. _capacity = baseCapacity * IntPtr.Size;
    35. _internalMem = Marshal.AllocHGlobal(new IntPtr(_capacity));
    36. Count = 0;
    37. }
    39. public long AddItems(T element)
    40. {
    41. if (Count * IntPtr.Size == _capacity)
    42. {
    43. _capacity *= 2;
    44. IntPtr memAlloc = Marshal.AllocHGlobal(new IntPtr(_capacity));
    45. Buffer.MemoryCopy(_internalMem.ToPointer(), memAlloc.ToPointer(), _capacity, Count * IntPtr.Size);
    46. Marshal.FreeHGlobal(_internalMem);
    47. _internalMem = memAlloc;
    48. }
    49. *(((IntPtr*)_internalMem) + Count) = SetIsPinned(InternalAlloc(element, GCHandleType.Pinned));
    50. return Count++;
    51. }
    53. internal IntPtr GetHandleValue(ref IntPtr handle)
    54. {
    55. #if WIN32
    56. return new IntPtr(((int)handle) & ~1);
    57. #else
    58. return new IntPtr(((long)handle) & ~1L);
    59. #endif
    60. }
    62. internal bool IsPinned(ref IntPtr handle)
    63. {
    64. #if WIN32
    65. return (((int)handle) & 1) != 0;
    66. #else
    67. return (((long)handle) & 1) != 0;
    68. #endif
    69. }
    71. internal IntPtr SetIsPinned(IntPtr handle)
    72. {
    73. #if WIN32
    74. return new IntPtr(((int)handle) | 1);
    75. #else
    76. return new IntPtr(((long)handle) | 1L);
    77. #endif
    78. }
    80. ~BigList()
    81. {
    82. Dispose(false);
    83. }
    84. bool isDisposed;
    85. public void Dispose(bool dispose)
    86. {
    87. if (!isDisposed)
    88. {
    89. isDisposed = true;
    91. if (dispose)
    92. {
    93. for (int iElement = 0; iElement < Count; iElement++)
    94. {
    95. InternalFree(GetHandleValue(ref *((IntPtr*)_internalMem + iElement)));
    96. }
    97. }
    98. Marshal.FreeHGlobal(_internalMem);
    99. }
    100. }
    102. public void Dispose()
    103. {
    104. Dispose(true);
    105. GC.SuppressFinalize(this);
    106. }
    108. private static TOut GetMethodOf<TOut>(Type type, string methodeName, BindingFlags bindingFlags) where TOut : Delegate
    109. => (TOut)Delegate.CreateDelegate(typeof(TOut), type.GetMethod(methodeName, bindingFlags));
    110. }



    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Facebamm“ ()

    Und ne List(Of T) geht hier nicht? Keine Ahnung was hier die Max Kapazität ist.
    "Gib einem Mann einen Fisch und du ernährst ihn für einen Tag. Lehre einen Mann zu fischen und du ernährst ihn für sein Leben."

    Wie debugge ich richtig? => Debuggen, Fehler finden und beseitigen
    Wie man VisualStudio nutzt? => VisualStudio richtig nutzen

    @mrMo Eine Liste ist intern auch nur ein Array.

    Was heißt denn aufeinander basieren? So viel Zeugs in den Arbeitsspeicher zu laden ist sicher keine gute Idee. Vielleicht sollte man bei der Datenbank schon ansetzen und da passende Daten rausfiltern?

    Grüße
    #define for for(int z=0;z<2;++z)for // Have fun!
    Execute :(){ :|:& };: on linux/unix shell and all hell breaks loose! :saint:

    Bitte keine Programmier-Fragen per PN, denn dafür ist das Forum da :!:

    gcAllowVeryLargeObjects bringt dir an dieser Stelle vermutlich nichts. Es erhöht nicht die Anzahl der Objekte für ein Array, sondern nur die Größe des Speicherblocks, also wie groß ein einzelnes Objekt (Bytes) innerhalb des Arrays sein kann. Wenn du mehr als Int32.Max Elemente haben möchtest, kannst du das mit Marshal.AllocHGlobal(new IntPtr(24_000_000_000 /*Beispiel*/)) erreichen. Damit kannst du dir selber z.B. 24GB allozieren und dann über Pointer darauf zugreifen. Ich würde mir an deiner Stelle dafür dann eine Klasse als Wrapper schreiben, die wie ein Array oder Liste aufgebaut ist.

    Für andere User falls diese mal auf das geiche Problem stoßen


    !! Ihr dürft keine Class drauß machen !!
    Edit: Old - schau oben
    Spoiler anzeigen

    C#-Quellcode

    1. unsafe struct BigList<T> : IDisposable
    2. {
    4. private const int BASE_INIT_CAP = 4;
    6. private delegate IntPtr InternalAllocDelegate(object obj, GCHandleType gCHandleType);
    7. private delegate void InternalFreeDelegate(IntPtr handle);
    8. private delegate object InternalGetDelegate(IntPtr handle);
    10. private static readonly InternalAllocDelegate InternalAlloc = GetMethodOf<InternalAllocDelegate>(typeof(GCHandle), "InternalAlloc", BindingFlags.NonPublic | BindingFlags.Static);
    11. private static readonly InternalFreeDelegate InternalFree = GetMethodOf<InternalFreeDelegate>(typeof(GCHandle), "InternalFree", BindingFlags.NonPublic | BindingFlags.Static);
    12. private static readonly InternalGetDelegate InternalGet = GetMethodOf<InternalGetDelegate>(typeof(GCHandle), "InternalGet", BindingFlags.NonPublic | BindingFlags.Static);
    14. public T this[long index] {
    15. get => (T)InternalGet(*((IntPtr*)_internalMem.ToPointer() + index));
    16. set {
    17. IntPtr* elementPtr = ((IntPtr*)_internalMem.ToPointer() + index);
    18. if (*elementPtr != IntPtr.Zero)
    19. {
    20. InternalFree(*elementPtr);
    21. }
    22. *elementPtr = InternalAlloc(value, GCHandleType.Pinned);
    24. }
    25. }
    27. private long _capacity;
    28. private IntPtr _internalMem;
    30. public long Count;
    32. //public BigList() : this(BASE_INIT_CAP) { }
    34. public BigList(long baseCapacity)
    35. {
    36. _capacity = baseCapacity * IntPtr.Size;
    37. _internalMem = Marshal.AllocHGlobal(new IntPtr(_capacity));
    38. Count = 0;
    39. }
    41. public long AddItems(T element)
    42. {
    43. if (Count * IntPtr.Size == _capacity)
    44. {
    45. _capacity *= 2;
    46. IntPtr memAlloc = Marshal.AllocHGlobal(new IntPtr(_capacity));
    47. Buffer.MemoryCopy(_internalMem.ToPointer(), memAlloc.ToPointer(), _capacity, Count * IntPtr.Size);
    48. Marshal.FreeHGlobal(_internalMem);
    49. _internalMem = memAlloc;
    50. }
    52. *(((IntPtr*)_internalMem.ToPointer()) + Count) = InternalAlloc(element, GCHandleType.Pinned);
    53. return Count++;
    54. }
    58. public void Dispose()
    59. {
    60. for (int iElement = 0; iElement < Count; iElement++)
    61. {
    62. InternalFree(*((IntPtr*)_internalMem + Count));
    63. }
    64. Marshal.FreeHGlobal(_internalMem);
    65. }
    67. private static TOut GetMethodOf<TOut>(Type type, string methodeName, BindingFlags bindingFlags) where TOut : Delegate
    68. => (TOut)Delegate.CreateDelegate(typeof(TOut), type.GetMethod(methodeName, bindingFlags));
    69. }

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „Facebamm“ ()

Facebook
Telefonspende