public override void Free(OffHeapBlockAllocator_MemoryBlock block, MemoryAllocationTracker tracker)
{
if (_released || !IsCacheable(block.Size))
{
DoFree(block, tracker);
return;
}
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.BlockingQueue<OffHeapBlockAllocator_MemoryBlock> cache = caches[log2floor(block.size)];
BlockingQueue <OffHeapBlockAllocator_MemoryBlock> cache = _caches[log2floor(block.Size)];
if (!cache.offer(block))
{
DoFree(block, tracker);
return;
}
// it is possible that allocator is released just before we put the block into queue;
// in such case case we need to free memory right away, since release() will never be called again
if (_released && cache.remove(block))
{
DoFree(block, tracker);
return;
}
tracker.Deallocated(block.UnalignedSize);
}
public override Memory Copy()
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.util.collection.OffHeapBlockAllocator_MemoryBlock copy = blockAllocator.allocate(block.size, tracker);
OffHeapBlockAllocator_MemoryBlock copy = outerInstance.blockAllocator.Allocate(Block.size, outerInstance.tracker);
copyMemory(Block.addr, copy.Addr, Block.size);
return(new OffHeapMemory(_outerInstance, copy));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void freeAfterRelease()
internal virtual void FreeAfterRelease()
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.util.collection.OffHeapBlockAllocator_MemoryBlock block = allocator.allocate(128, memoryTracker);
OffHeapBlockAllocator_MemoryBlock block = _allocator.allocate(128, _memoryTracker);
_allocator.release();
_allocator.free(block, _memoryTracker);
verify(_allocator).doFree(eq(block), any());
}
public override void Free(OffHeapBlockAllocator_MemoryBlock block, MemoryAllocationTracker tracker)
{
try
{
_impl.free(block, tracker);
}
finally
{
_usedMemory.addAndGet(-block.Size);
}
}
public override Memory Allocate(long size, bool zeroed)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.util.collection.OffHeapBlockAllocator_MemoryBlock block = blockAllocator.allocate(size, tracker);
OffHeapBlockAllocator_MemoryBlock block = _blockAllocator.allocate(size, _tracker);
if (zeroed)
{
setMemory(block.UnalignedAddr, block.UnalignedSize, ( sbyte )0);
}
return(new OffHeapMemory(this, block));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @ParameterizedTest @ValueSource(longs = {8, 64, 128}) void allocateCacheableSize(long bytes)
internal virtual void AllocateCacheableSize(long bytes)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.util.collection.OffHeapBlockAllocator_MemoryBlock block1 = allocator.allocate(bytes, memoryTracker);
OffHeapBlockAllocator_MemoryBlock block1 = _allocator.allocate(bytes, _memoryTracker);
_allocator.free(block1, _memoryTracker);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.util.collection.OffHeapBlockAllocator_MemoryBlock block2 = allocator.allocate(bytes, memoryTracker);
OffHeapBlockAllocator_MemoryBlock block2 = _allocator.allocate(bytes, _memoryTracker);
_allocator.free(block2, _memoryTracker);
verify(_allocator).allocateNew(eq(bytes), any());
verify(_allocator, never()).doFree(any(), any());
assertEquals(0, _memoryTracker.usedDirectMemory());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void maxMemoryLimit()
internal virtual void MaxMemoryLimit()
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.memory.MemoryAllocationTracker tracker = mock(org.neo4j.memory.MemoryAllocationTracker.class);
MemoryAllocationTracker tracker = mock(typeof(MemoryAllocationTracker));
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final OffHeapBlockAllocator allocator = mock(OffHeapBlockAllocator.class);
OffHeapBlockAllocator allocator = mock(typeof(OffHeapBlockAllocator));
when(allocator.Allocate(anyLong(), any(typeof(MemoryAllocationTracker)))).then(invocation =>
{
long size = invocation.getArgument <long>(0);
return(new MemoryBlock(0, size, 0, size));
});
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final CapacityLimitingBlockAllocatorDecorator decorator = new CapacityLimitingBlockAllocatorDecorator(allocator, 1024);
CapacityLimitingBlockAllocatorDecorator decorator = new CapacityLimitingBlockAllocatorDecorator(allocator, 1024);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.List<org.neo4j.kernel.impl.util.collection.OffHeapBlockAllocator_MemoryBlock> blocks = new java.util.ArrayList<>();
IList <OffHeapBlockAllocator_MemoryBlock> blocks = new List <OffHeapBlockAllocator_MemoryBlock>();
for (int i = 0; i < 8; i++)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.util.collection.OffHeapBlockAllocator_MemoryBlock block = decorator.allocate(128, tracker);
OffHeapBlockAllocator_MemoryBlock block = decorator.Allocate(128, tracker);
blocks.Add(block);
}
assertThrows(typeof(Exception), () => decorator.Allocate(128, tracker));
decorator.Free(blocks.RemoveAt(0), tracker);
assertDoesNotThrow(() => decorator.Allocate(128, tracker));
assertThrows(typeof(Exception), () => decorator.Allocate(256, tracker));
decorator.Free(blocks.RemoveAt(0), tracker);
assertThrows(typeof(Exception), () => decorator.Allocate(256, tracker));
decorator.Free(blocks.RemoveAt(0), tracker);
assertDoesNotThrow(() => decorator.Allocate(256, tracker));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void allocateAndFree()
internal virtual void AllocateAndFree()
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.util.collection.OffHeapBlockAllocator_MemoryBlock block1 = allocator.allocate(128, memoryTracker);
OffHeapBlockAllocator_MemoryBlock block1 = _allocator.allocate(128, _memoryTracker);
assertEquals(block1.Size, 128);
assertEquals(128 + Long.BYTES - 1, block1.UnalignedSize);
assertEquals(block1.UnalignedSize, _memoryTracker.usedDirectMemory());
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.util.collection.OffHeapBlockAllocator_MemoryBlock block2 = allocator.allocate(256, memoryTracker);
OffHeapBlockAllocator_MemoryBlock block2 = _allocator.allocate(256, _memoryTracker);
assertEquals(block2.Size, 256);
assertEquals(256 + Long.BYTES - 1, block2.UnalignedSize);
assertEquals(block1.UnalignedSize + block2.UnalignedSize, _memoryTracker.usedDirectMemory());
_allocator.free(block1, _memoryTracker);
_allocator.free(block2, _memoryTracker);
assertEquals(0, _memoryTracker.usedDirectMemory());
}
public override OffHeapBlockAllocator_MemoryBlock Allocate(long size, MemoryAllocationTracker tracker)
{
requirePositive(size);
checkState(!_released, "Allocator is already released");
if (!IsCacheable(size))
{
return(AllocateNew(size, tracker));
}
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.BlockingQueue<OffHeapBlockAllocator_MemoryBlock> cache = caches[log2floor(size)];
BlockingQueue <OffHeapBlockAllocator_MemoryBlock> cache = _caches[log2floor(size)];
OffHeapBlockAllocator_MemoryBlock block = cache.poll();
if (block == null)
{
block = AllocateNew(size, tracker);
}
else
{
tracker.Allocated(block.UnalignedSize);
}
return(block);
}
internal OffHeapMemory(OffHeapMemoryAllocator outerInstance, OffHeapBlockAllocator_MemoryBlock block)
{
this._outerInstance = outerInstance;
this.Block = block;
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @VisibleForTesting void doFree(OffHeapBlockAllocator_MemoryBlock block, org.neo4j.memory.MemoryAllocationTracker tracker)
internal virtual void DoFree(OffHeapBlockAllocator_MemoryBlock block, MemoryAllocationTracker tracker)
{
UnsafeUtil.free(block.UnalignedAddr, block.UnalignedSize, tracker);
}
