public void running_a_scan_when_no_pointers_are_referenced_resets_the_arena() { var bump = (Allocator.ArenaSize / 4) + 1; // three fit in each arena, with some spare var mem = new MemorySimulator(Mega.Bytes(1)); var subject = new Allocator(512, Mega.Bytes(1), mem); subject.Alloc(bump); var ar1 = subject.CurrentArena(); subject.Alloc(bump); subject.Alloc(bump); // fill up first arena var x2 = subject.Alloc(bump).Value; var ar2 = subject.CurrentArena(); Assert.That(ar1, Is.Not.EqualTo(ar2), "Failed to trigger a new arena"); // Check that both arenas are non-empty: Assert.That(subject.GetArenaOccupation(ar1).Value, Is.Not.Zero); Assert.That(subject.GetArenaOccupation(ar2).Value, Is.Not.Zero); // Run the scan (only including the second arena) var list = new Vector <long>(subject, mem); list.Push(x2); subject.ScanAndSweep(list); // Check nothing has been cleared Assert.That(subject.GetArenaOccupation(ar1).Value, Is.Zero, "Unreferenced arena was not reset"); Assert.That(subject.GetArenaOccupation(ar2).Value, Is.Not.Zero); }
public void running_a_scan_when_any_pointers_are_referenced_keeps_the_arena() { // scan takes a list of known references, and assumes anything // that's not in the list in not referenced. Any arena with nothing // referenced is reset. var mem = new MemorySimulator(Mega.Bytes(1)); var bump = (Allocator.ArenaSize / 4) + 1; // three fit in each arena, with some spare var subject = new Allocator(512, Mega.Bytes(1), mem); var x1 = subject.Alloc(bump).Value; var ar1 = subject.CurrentArena(); subject.Alloc(bump); subject.Alloc(bump); // fill up first arena var x2 = subject.Alloc(bump).Value; var ar2 = subject.CurrentArena(); Assert.That(ar1, Is.Not.EqualTo(ar2), "Failed to trigger a new arena"); // Check that both arenas are non-empty: Assert.That(subject.GetArenaOccupation(ar1).Value, Is.Not.Zero); Assert.That(subject.GetArenaOccupation(ar2).Value, Is.Not.Zero); // Run the scan (note we don't need all pointers, just one from each arena) var list = new Vector <long>(subject, mem); list.Push(x1); list.Push(x2); subject.ScanAndSweep(list); // Check nothing has been cleared Assert.That(subject.GetArenaOccupation(ar1).Value, Is.Not.Zero); Assert.That(subject.GetArenaOccupation(ar2).Value, Is.Not.Zero); }
public void a_second_allocation_returns_different_memory() { var mem = new MemorySimulator(Mega.Bytes(1)); var subject = new Allocator(100, Mega.Bytes(10), mem); long ptr1 = subject.Alloc(byteCount: 256).Value; long ptr2 = subject.Alloc(byteCount: 256).Value; Assert.That(ptr1, Is.Not.EqualTo(ptr2)); }
public void allocating_enough_memory_changes_arena() { var mem = new MemorySimulator(Mega.Bytes(1)); var subject = new Allocator(100, Mega.Bytes(1), mem); int first = subject.CurrentArena(); long ptr1 = subject.Alloc(Allocator.ArenaSize).Value; long ptr2 = subject.Alloc(Kilo.Bytes(1)).Value; int second = subject.CurrentArena(); Assert.That(ptr1, Is.Not.EqualTo(ptr2)); Assert.That(first, Is.Not.EqualTo(second)); }
public void deallocating_an_old_allocation_does_nothing() { // Older items just hang around until the entire arena is abandoned var mem = new MemorySimulator(Mega.Bytes(1)); var subject = new Allocator(100, Mega.Bytes(10), mem); long ptr1 = subject.Alloc(byteCount: 256).Value; long ptr2 = subject.Alloc(byteCount: 256).Value; subject.Deref(ptr1); long ptr3 = subject.Alloc(byteCount: 512).Value; Assert.That(ptr3, Is.GreaterThan(ptr2)); }
public static void Set(string tag) { if (Address == IntPtr.Zero) { Allocator alloc = new Allocator(); Address = alloc.Alloc(Size); alloc.Free(); if (Address == IntPtr.Zero) { return; } Buffer.BlockCopy(BitConverter.GetBytes((int)(Address + 18)), 0, Shellcode, 1, 4); Buffer.BlockCopy(BitConverter.GetBytes((int)(Address + 18)), 0, Shellcode, 6, 4); Buffer.BlockCopy(BitConverter.GetBytes(Memory.Engine + signatures.dwSetClanTag), 0, Shellcode, 11, 4); } if (!LocalPlayer.InGame) { return; } byte[] tag_bytes = Encoding.UTF8.GetBytes(tag + "\0"); byte[] reset = new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; Buffer.BlockCopy(reset, 0, Shellcode, 18, reset.Length); Buffer.BlockCopy(tag_bytes, 0, Shellcode, 18, tag.Length > 15 ? 15 : tag.Length); CreateThread.Create(Address, Shellcode); }
public void TestMethod1() { var al = new Allocator(new MyAllocator()); var vi = al.Alloc <int>(); vi = 42; }
[Test] // a stress test of sorts public void can_handle_large_allocation_spaces() { var mem = new OffsetMemorySimulator(Mega.Bytes(1), Giga.Bytes(1)); // only need enough room for arena tables var subject = new Allocator(Giga.Bytes(1), Giga.Bytes(2), mem); // big for an embedded system. 3GB total. var result = subject.Alloc(Allocator.ArenaSize / 2); Assert.That(result.Value - Giga.Bytes(1), Is.EqualTo(131072)); // allocated at bottom of given space, excluding arena tables for (int i = 0; i < 1000; i++) { result = subject.Alloc(Allocator.ArenaSize - 1); } Assert.That(subject.CurrentArena(), Is.GreaterThanOrEqualTo(1000)); Assert.That(result.Value, Is.GreaterThan(Giga.Bytes(1))); }
public void can_allocate_memory_from_a_pool_and_get_a_pointer() { var mem = new MemorySimulator(Mega.Bytes(1)); var subject = new Allocator(100, Mega.Bytes(10), mem); long ptr = subject.Alloc(byteCount: Kilo.Bytes(1)).Value; Assert.That(ptr, Is.GreaterThanOrEqualTo(100)); }
[Test] // The vector class can be used to store larger chunks of data public void requesting_a_block_larger_than_a_single_area_fails() { // Doing this to keep things very simple var mem = new MemorySimulator(Mega.Bytes(1)); var subject = new Allocator(512, Mega.Bytes(1), mem); var result = subject.Alloc(Allocator.ArenaSize * 2); Assert.That(result.Success, Is.False); }
public void deallocating_everything_in_an_arena_resets_it() { var mem = new MemorySimulator(Mega.Bytes(1)); var subject = new Allocator(100, Mega.Bytes(1), mem); long ptr1 = subject.Alloc(512).Value; long ptr2 = subject.Alloc(512).Value; long ptr3 = subject.Alloc(512).Value; subject.Deref(ptr1); subject.Deref(ptr2); long ptr4 = subject.Alloc(512).Value; subject.Deref(ptr3); subject.Deref(ptr4); // should be reset now, and next alloc goes back to start long ptrFinal = subject.Alloc(512).Value; Assert.That(ptrFinal, Is.EqualTo(ptr1)); }
public void can_directly_deallocate_a_pointer() { var mem = new MemorySimulator(Mega.Bytes(1)); var subject = new Allocator(100, Mega.Bytes(10), mem); long ptr = subject.Alloc(byteCount: 256).Value; subject.Deref(ptr); var ar = subject.CurrentArena(); var refs = subject.ArenaRefCount(ar); Assert.That(refs.Value, Is.Zero); }
public void memory_exhaustion_results_in_an_error_code() { var mem = new MemorySimulator(Mega.Bytes(1)); var subject = new Allocator(10, Mega.Bytes(1), mem); Result <long> result = default; for (int i = 0; i < 17; i++) { result = subject.Alloc(Allocator.ArenaSize - 1); } Assert.That(result.Success, Is.False); }
public void can_add_and_remove_current_referenced_pointers() { // This increments and decrements ref counts? // Free is the equivalent of directly setting ref count to zero? Or is it just a synonym for Deref? // We can keep an overall refcount for the arena and ignore the individual references (except for the head, as an optimisation) // We don't protect from double-free var mem = new MemorySimulator(Mega.Bytes(1)); var subject = new Allocator(100, Mega.Bytes(1), mem); long ptr = subject.Alloc(byteCount: 256).Value; subject.Reference(ptr); subject.Reference(ptr); subject.Deref(ptr); Assert.Pass(); }
public void add_and_removing_elements_works_with_pre_existing_allocations() { var mem = new MemorySimulator(Mega.Bytes(1)); var alloc = new Allocator(0, Mega.Bytes(1), mem); alloc.Alloc(174); var subject = new Vector <SampleElement>(alloc, mem); Assert.That(subject.Length(), Is.Zero); subject.Push(Sample1()); subject.Push(Sample2()); Assert.That(subject.Length(), Is.EqualTo(2)); subject.Pop(); subject.Push(Sample3()); Assert.That(subject.Get(1).Value, Is.EqualTo(Sample3()), "Get 1 is wrong"); Assert.That(subject.Get(0).Value, Is.EqualTo(Sample1()), "Get 0 is wrong"); }
public void can_read_the_current_allocation_pressure() { var mem = new MemorySimulator(Mega.Bytes(1)); var subject = new Allocator(10, Mega.Bytes(1), mem); // this is 1048576, which doesn't divide nicely into arenas... // Check the empty state is sane subject.GetState(out var allocatedBytes, out var unallocatedBytes, out var occupiedArenas, out var emptyArenas, out var refCount, out var largestBlock); Assert.That(allocatedBytes, Is.Zero); Assert.That(unallocatedBytes, Is.EqualTo(1048560)); // ... so we end up with slightly less space that's usable. Max loss is < 64K Assert.That(largestBlock, Is.EqualTo(Allocator.ArenaSize)); Assert.That(occupiedArenas, Is.Zero); Assert.That(emptyArenas, Is.EqualTo(16)); // arenas per megabyte Assert.That(refCount, Is.Zero); // Do some allocation var allocd = 0L; var size = Allocator.ArenaSize / 6; for (int i = 0; i < 14; i++) { allocd += size; subject.Alloc(size); } // Check filled state is sane subject.GetState(out allocatedBytes, out unallocatedBytes, out occupiedArenas, out emptyArenas, out refCount, out largestBlock); Assert.That(allocatedBytes, Is.EqualTo(allocd)); Assert.That(unallocatedBytes, Is.EqualTo(1048560 - allocd)); Assert.That(largestBlock, Is.EqualTo(Allocator.ArenaSize)); Assert.That(occupiedArenas, Is.EqualTo(3)); Assert.That(emptyArenas, Is.EqualTo(13)); Assert.That(refCount, Is.EqualTo(14)); }
public static void Exec(string szCmd, bool highPriority = false) { if (Address == IntPtr.Zero) { Allocator Alloc = new Allocator(); Address = Alloc.Alloc(Size); if (Address == IntPtr.Zero) { return; } } if (szCmd.Length > 255) { szCmd = szCmd.Substring(0, 255); } var szCmd_bytes = Encoding.UTF8.GetBytes(szCmd + "\0"); Memory.WriteProcessMemory(Memory.pHandle, Address, szCmd_bytes, szCmd_bytes.Length, 0); IntPtr Thread = DllImport.CreateRemoteThread(Memory.pHandle, (IntPtr)null, IntPtr.Zero, new IntPtr(Memory.Engine + CalcedOffsets.ClientCMD), Address, 0, (IntPtr)null); DllImport.CloseHandle(Thread); DllImport.WaitForSingleObject(Thread, 0xFFFFFFFF); }
public CPtr AllocObject(object value) { return(mObject.Alloc(value)); }
public CPtr AllocDateTime(DateTime dt) { return(mDateTime.Alloc(dt)); }
public CPtr AllocString(string value) { return(mStr.Alloc(value)); }
public CPtr AllocDouble(double value) { return(mDouble.Alloc(value)); }
public CPtr AllocFloat(float value) { return(mFloat.Alloc(value)); }
public CPtr AllocInt64(int value) { return(mInt64.Alloc(value)); }
public CPtr AllocInt32(int value) { return(mInt32.Alloc(value)); }
public CPtr AllocBool(bool value) { return(mBoolean.Alloc(value)); }
private static IntPtr MemAllocCallback(UIntPtr size) => Allocator.Alloc((int)size.ToUInt32());