protected virtual void Dispose(bool disposing) { #if DEBUG if (_id == _badDispose) { Debugger.Break(); } #endif if (!_disposed) { _disposed = true; Memory.Free(); } }
public static void Free(UnsafeHashSet *set) { if (set == null) { return; } if (set->_collection.Entries.Dynamic == 1) { UnsafeHashCollection.Free(&set->_collection); } *set = default; Memory.Free(set); }
private void Dispose(bool disposing) { if (!disposed) { if (disposing) { } if (pointer != IntPtr.Zero) { Memory.Free(pointer); pointer = IntPtr.Zero; } disposed = true; } }
public void ResetWriteCopyBufferNull() { BitStreamer bs = new BitStreamer(); IntPtr buff = Memory.Alloc(16); *(byte *)buff = 212; bs.ResetWrite(buff, 16, true); Assert.AreEqual(16, bs.ByteLength); Assert.AreEqual(16, bs.ByteOffset); bs.ResetRead(); Assert.AreEqual(212, bs.ReadByte()); Assert.IsTrue(bs.OwnsBuffer); Memory.Free(buff); }
public static void Free(UnsafeSortedDictionary *map) { if (map == null) { return; } if (map->_collection.Entries.Dynamic == 1) { UnsafeBuffer.Free(&map->_collection.Entries); } // clear memory *map = default; // free it Memory.Free(map); }
public static void Free(UnsafeList *list) { if (list == null) { return; } // free dynamic items separately if (list->_items.Dynamic == 1) { UnsafeBuffer.Free(&list->_items); } // clear memory *list = default; // free list Memory.Free(list); }
public static void Free(UnsafeStack *stack) { if (stack == null) { return; } // if this is a dynamic sized stack, we need to free the buffer by hand if (stack->_items.Dynamic == 1) { UnsafeBuffer.Free(&stack->_items); } // clear stack memory just in case *stack = default; // free stack memory (if this is a fixed size stack, it frees the _items memory also) Memory.Free(stack); }
public void ReallocZeroedTest() { var arr = CreateArray(); arr = (byte *)Memory.ReallocZeroed((IntPtr)arr, 8, 16); // Check the original bytes. for (int i = 0; i < 8; i++) { Assert.AreEqual(i, arr[i]); } // Verify that the remainder is zeroed. for (int i = 8; i < 16; i++) { Assert.AreEqual(0, arr[i]); } Memory.Free(arr); }
public static void Free(UnsafeMPMCQueue *queue) { if (queue == null) { return; } // Free all segments var segment = queue->_head; do { var next = segment->_nextSegment; QueueSegment.Free(segment); segment = next; }while (segment != null); // Clear queue memory (just in case) *queue = default; // Free queue memory, if this is a fixed queue it frees the items memory at the same time Memory.Free(queue); }
private unsafe IntPtr PSBufferNew(uint *requestedSize, uint minimumSize) { IntPtr ptr = IntPtr.Zero; try { if (requestedSize != null && *requestedSize > minimumSize) { uint allocatedSize = 0; uint size = *requestedSize; while (size > minimumSize) { // Allocate the largest buffer we can that is greater than the specified minimum size. ptr = Memory.Allocate(size, MemoryAllocationFlags.ReturnZeroOnOutOfMemory); if (ptr != IntPtr.Zero) { buffers.Add(ptr, new BufferEntry(ptr, size)); allocatedSize = size; break; } size /= 2; } if (ptr == IntPtr.Zero) { // If we cannot allocate a buffer larger than the minimum size // attempt to allocate a buffer at the minimum size. ptr = Memory.Allocate(minimumSize, MemoryAllocationFlags.ReturnZeroOnOutOfMemory); if (ptr != IntPtr.Zero) { buffers.Add(ptr, new BufferEntry(ptr, minimumSize)); allocatedSize = minimumSize; } } // The requested size pointer is used as an output parameter to return the actual number of bytes allocated. *requestedSize = allocatedSize; } else { ptr = Memory.Allocate(minimumSize, MemoryAllocationFlags.ReturnZeroOnOutOfMemory); if (ptr != IntPtr.Zero) { buffers.Add(ptr, new BufferEntry(ptr, minimumSize)); } } } catch (OutOfMemoryException) { // Free the buffer memory if the framework throws an OutOfMemoryException when adding to the buffers list. if (ptr != IntPtr.Zero) { Memory.Free(ptr); ptr = IntPtr.Zero; } } return(ptr); }
public void PluginMemoryHandlerTest() { // Arrange // ensure delegates are not garbage collected from managed code var malloc = new MemoryMalloc(Malloc); var free = new MemoryFree(Free); var realloc = new MemoryRealloc(Realloc); var nonContextualMalloc = new MemoryNonContextualMalloc(NonContextualMalloc); var nonContextualFree = new MemoryNonContextualFree(NonContextualFree); PluginMemoryHandler memoryHandler = new PluginMemoryHandler { Base = new PluginBase { Magic = Cms.PluginMagicNumber, ExpectedVersion = (uint)Cms.EncodedCMMVersion, // >= 2.8 Type = PluginType.MemoryHandler, Next = IntPtr.Zero }, Malloc = Marshal.GetFunctionPointerForDelegate(malloc), Free = Marshal.GetFunctionPointerForDelegate(free), Realloc = Marshal.GetFunctionPointerForDelegate(realloc), MallocZero = IntPtr.Zero, // optional Calloc = IntPtr.Zero, // optional Duplicate = IntPtr.Zero, // optional NonContextualMalloc = Marshal.GetFunctionPointerForDelegate(nonContextualMalloc), NonContextualFree = Marshal.GetFunctionPointerForDelegate(nonContextualFree) }; int rawsize = Marshal.SizeOf(memoryHandler); IntPtr memoryHandlerPlugin = Marshal.AllocHGlobal(rawsize); Marshal.StructureToPtr(memoryHandler, memoryHandlerPlugin, false); // Act try { using (var context = Context.Create(memoryHandlerPlugin, IntPtr.Zero)) { // Assert IntPtr mallocPtr = Memory.Malloc(context, 0x200); Assert.AreNotEqual(IntPtr.Zero, mallocPtr); IntPtr reallocPtr = Memory.Realloc(context, mallocPtr, 0x300); Assert.AreNotEqual(IntPtr.Zero, mallocPtr); Memory.Free(context, reallocPtr); } } finally { Marshal.DestroyStructure(memoryHandlerPlugin, typeof(PluginMemoryHandler)); Marshal.FreeHGlobal(memoryHandlerPlugin); } // allocates memory IntPtr Malloc(IntPtr contextID, uint size) { TestContext.WriteLine($"Malloc(contextId: {contextID}, size: {size})"); try { return(Marshal.AllocHGlobal((int)size)); } catch (Exception) { return(IntPtr.Zero); } } // frees memory void Free(IntPtr contextID, IntPtr ptr) { TestContext.WriteLine($"Free(contextId: {contextID}, ptr: 0x{ptr:X})"); Marshal.FreeHGlobal(ptr); } // reallocates memory IntPtr Realloc(IntPtr contextID, IntPtr ptr, uint newSize) { TestContext.WriteLine($"Realloc(contextId: {contextID}, ptr: 0x{ptr:X}, newSize: {newSize})"); try { return(Marshal.ReAllocHGlobal(ptr, (IntPtr)newSize)); } catch (Exception) { return(IntPtr.Zero); } } // allocates non-contextual memory IntPtr NonContextualMalloc(IntPtr userData, uint size) { TestContext.WriteLine($"NonContextualMalloc(userData: {userData}, size: {size})"); try { return(Marshal.AllocHGlobal((int)size)); } catch (Exception) { return(IntPtr.Zero); } } // frees non-contextual memory void NonContextualFree(IntPtr userData, IntPtr ptr) { TestContext.WriteLine($"NonContextualFree(userData: {userData}, ptr: 0x{ptr:X})"); Marshal.FreeHGlobal(ptr); } }
public void PluginTagTypeTest() { // Arrange const TagSignature SigInt = (TagSignature)0x74747448; // 'tttH' const TagTypeSignature SigIntType = (TagTypeSignature)0x74747448; // 'tttH' PluginTag tag = new PluginTag { Base = new PluginBase { Magic = Cms.PluginMagicNumber, ExpectedVersion = (uint)Cms.EncodedCMMVersion, // >= 2.8 Type = PluginType.Tag, Next = IntPtr.Zero }, Signature = SigInt, Descriptor = new TagDescriptor { ElemCount = 1, nSupportedTypes = 1, SupportedTypes = new TagTypeSignature[TagDescriptor.MAX_TYPES_IN_LCMS_PLUGIN], Decider = IntPtr.Zero } }; tag.Descriptor.SupportedTypes[0] = SigIntType; int rawsize = Marshal.SizeOf(tag); IntPtr tagPlugin = Marshal.AllocHGlobal(rawsize); Marshal.StructureToPtr(tag, tagPlugin, false); // ensure delegates are not garbage collected from managed code var read = new TagTypeRead(Read); var write = new TagTypeWrite(Write); var duplicate = new TagTypeDuplicate(Duplicate); var free = new TagTypeFree(Free); PluginTagType tagType = new PluginTagType { Base = new PluginBase { Magic = Cms.PluginMagicNumber, ExpectedVersion = (uint)Cms.EncodedCMMVersion, // >= 2.8 Type = PluginType.TagType, Next = tagPlugin }, Handler = new TagTypeHandler { Signature = SigIntType, Read = Marshal.GetFunctionPointerForDelegate(read), Write = Marshal.GetFunctionPointerForDelegate(write), Duplicate = Marshal.GetFunctionPointerForDelegate(duplicate), Free = Marshal.GetFunctionPointerForDelegate(free) } }; rawsize = Marshal.SizeOf(tagType); IntPtr tagTypePlugin = Marshal.AllocHGlobal(rawsize); Marshal.StructureToPtr(tagType, tagTypePlugin, false); // Act try { using (var context = Context.Create(tagTypePlugin, IntPtr.Zero)) using (var profile = Profile.CreatePlaceholder(context)) { var errorHandler = new ErrorHandler(HandleError); context.SetErrorHandler(errorHandler); uint expected = 1234; bool written = profile.WriteTag(SigInt, expected); Assert.IsTrue(written); profile.Save(null, out uint bytesNeeded); Assert.AreNotEqual(0, bytesNeeded); byte[] profileMemory = new byte[bytesNeeded]; bool saved = profile.Save(profileMemory, out uint bytesWritten); Assert.IsTrue(saved); // close original profile to flush caches profile.Close(); // re-open profile from memory using (var profile2 = Profile.Open(context, profileMemory)) { IntPtr data = profile2.ReadTag(SigInt); uint[] u = new uint[1]; Marshal.Copy(data, (int[])(object)u, 0, 1); uint actual = u[0]; // Assert Assert.AreEqual(expected, actual); } } } finally { Marshal.DestroyStructure(tagPlugin, typeof(PluginTag)); Marshal.FreeHGlobal(tagPlugin); Marshal.DestroyStructure(tagTypePlugin, typeof(PluginTagType)); Marshal.FreeHGlobal(tagTypePlugin); } // allocates unmanaged memory for a single 'uint' and reads from i/o handler into it IntPtr Read(in TagTypeHandler self, IntPtr io, out uint nItems, uint tagSize) { TestContext.WriteLine($"Read(self: {self}, io: 0x{io:X}, out nItems, tagSize: {tagSize})"); using (var context = Context.FromHandle(self.ContextID)) using (var iohandler = IOHandler.FromHandle(io)) { nItems = 1; IntPtr ptr = Memory.Malloc(context, sizeof(uint)); if (ptr == IntPtr.Zero) { return(IntPtr.Zero); } // unsafe, but faster... unsafe { if (!iohandler.Read(ref *(uint *)ptr)) { return(IntPtr.Zero); } } // - or - // verifiable, but slower... //uint[] arr = new uint[1]; //if (!iohandler.Read(ref arr[0])) return IntPtr.Zero; //Marshal.Copy((int[])(object)arr, 0, ptr, 1); return(ptr); } } // uses the i/o handler to write a single 'uint' read from unmanaged memory 'ptr' int Write(in TagTypeHandler self, IntPtr io, IntPtr ptr, uint nItems) { TestContext.WriteLine($"Write(self: {self}, io: 0x{io:X}, ptr: 0x{ptr:X}, nItems: {nItems})"); using (var iohandler = IOHandler.FromHandle(io)) { // unsafe, but faster... unsafe { return(iohandler.Write(*(uint *)ptr) ? 1 : 0); } // - or - // verifiable, but slower... //uint[] arr = new uint[1]; //Marshal.Copy(ptr, (int[])(object)arr, 0, 1); //return iohandler.Write(arr[0]) ? 1 : 0; } } // duplicates the unmanaged memory 'ptr' into a new block of size 'n x sizeof(uint)' IntPtr Duplicate(in TagTypeHandler self, IntPtr ptr, uint n) { TestContext.WriteLine($"Duplicate(self: {self}, ptr: 0x{ptr:X}, n: {n})"); using (var context = Context.FromHandle(self.ContextID)) { return(Memory.Duplicate(context, ptr, n * sizeof(uint))); } } // frees the unmanaged memory 'ptr' void Free(in TagTypeHandler self, IntPtr ptr) { TestContext.WriteLine($"Free(self: {self}, ptr: 0x{ptr:X})"); using (var context = Context.FromHandle(self.ContextID)) { Memory.Free(context, ptr); } } void HandleError(IntPtr contextID, int errorCode, string errorText) { TestContext.WriteLine($"Error!!! contextID: {contextID}, errorCode: {errorCode}, errorText: '{errorText}'"); } }