/// <summary> /// Creates a <see cref="MemoryBuffer"/> and attempts to retrieve it by searching for it in memory. /// </summary> private void GetBuffers(MemoryBufferHelper bufferHelper) { // Options int size = 4096; int repetitions = 128; int increment = 2048; // Setup MemoryBuffer[] memoryBuffers = new MemoryBuffer[repetitions]; for (int x = 0; x < repetitions; x++) { int newSize = size + (x * increment); memoryBuffers[x] = bufferHelper.CreateMemoryBuffer(newSize); } // Search for our buffers with exact originally given buffer sizes and try find the exact buffer. for (int x = 0; x < repetitions; x++) { int newSize = size + (x * increment); var buffers = bufferHelper.FindBuffers(newSize); if (!buffers.Contains(memoryBuffers[x])) { Assert.True(false, $"Failed to find existing buffer in memory of minimum size {newSize} bytes."); } } // Cleanup. for (int x = 0; x < repetitions; x++) { Internal.Testing.Buffers.FreeBuffer(memoryBuffers[x]); } }
/* * ---------- * Core Tests * ---------- */ /// <summary> /// [Testing Purposes] /// Creates a buffer, then frees the memory belonging to the buffer. /// </summary> private void CreateBufferBase(MemoryBufferHelper bufferHelper) { var buffer = bufferHelper.CreateMemoryBuffer(4096); // Cleanup Internal.Testing.Buffers.FreeBuffer(buffer); }
/// <summary> /// Same as <see cref="GetBuffersInRange"/>, except disables the caching when acquiring <see cref="MemoryBuffer"/>s. /// </summary> private unsafe void GetBuffersInRangeNoCache(MemoryBufferHelper bufferHelper, IntPtr maxApplicationAddress) { /* The reason that testing the upper half is sufficient is because the buffer allocation * functions work in such a manner that they allocate from the lowest address. * As such, normally the only allocated addresses would be in the lower half... until enough memory is allocated to cross the upper half. */ // Options int sizeStart = 0; // Default page size for x86 and x64. int repetitions = 128; int increment = 4096; // Equal to allocation granularity. // Minimum address is start of upper half of 32/64 bit address range. // Maximum is the maximum address in 32/64 bit address range. long minAddress = (long)maxApplicationAddress - ((long)maxApplicationAddress / 2); long maxAddress = (long)maxApplicationAddress; MemoryBuffer[] buffers = new MemoryBuffer[repetitions]; // Allocate <repetitions> buffers, and try to find them all. for (int x = 0; x < repetitions; x++) { int newSize = sizeStart + (x * increment); buffers[x] = bufferHelper.CreateMemoryBuffer(newSize, (long)minAddress, (long)maxAddress); } // Validate whether each buffer is present and in range. for (int x = 0; x < repetitions; x++) { int newSize = sizeStart + (x * increment); var foundBuffers = bufferHelper.FindBuffers(newSize, (IntPtr)minAddress, (IntPtr)maxAddress, false); if (!foundBuffers.Contains(buffers[x])) { Assert.True(false, $"Failed to find existing buffer in memory of minimum size {newSize} bytes."); } foreach (var buffer in foundBuffers) { AssertBufferInRange(buffer, (IntPtr)minAddress, (IntPtr)maxAddress); } } // Cleanup for (int x = 0; x < buffers.Length; x++) { Internal.Testing.Buffers.FreeBuffer(buffers[x]); } }
/// <summary> /// Finds an existing <see cref="MemoryBuffer"/> or creates one satisfying the given size. /// </summary> /// <param name="size">The required size of buffer.</param> /// <param name="minimumAddress">Maximum address of the buffer.</param> /// <param name="maximumAddress">Minimum address of the buffer.</param> /// <param name="alignment">Required alignment of the item to add to the buffer.</param> public static MemoryBuffer FindOrCreateBufferInRange(int size, long minimumAddress = 1, long maximumAddress = int.MaxValue, int alignment = 4) { var buffers = _bufferHelper.FindBuffers(size + alignment, (IntPtr)minimumAddress, (IntPtr)maximumAddress); return(buffers.Length > 0 ? buffers[0] : _bufferHelper.CreateMemoryBuffer(size, minimumAddress, maximumAddress)); }
/* * --------------- * Utility Methods * --------------- */ private MemoryBuffer CreateMemoryBuffer(MemoryBufferHelper helper) { return(helper.CreateMemoryBuffer(4096)); }