public AbstractBlittableJsonTextWriter(JsonOperationContext context, Stream stream) { _context = context; _stream = stream; _returnBuffer = context.GetManagedBuffer(out _pinnedBuffer); _buffer = _pinnedBuffer.Pointer; _parserAuxiliarMemory = context.GetMemory(32); }
public void Return(AllocatedMemoryData allocation) { if (_isDisposed) { return; } var address = allocation.Address; #if DEBUG Debug.Assert(address != _ptrCurrent); Debug.Assert(allocation.IsReturned == false); allocation.IsReturned = true; #endif #if MEM_GUARD #if MEM_GUARD_STACK if (allocation.FreedBy == null) { allocation.FreedBy = Environment.StackTrace; } #endif ElectricFencedMemory.Free(address); #else if (address != _ptrCurrent - allocation.SizeInBytes || address < _ptrStart) { // we have fragmentation, so'll just store the values that we need here // in the memory we just freed :-) // note that this fragmentation will be healed by the call to ResetArena // trying to do this on the fly is too expensive. Debug.Assert(Bits.NextPowerOf2(allocation.SizeInBytes) == allocation.SizeInBytes, "Allocation size must always be a power of two" ); Debug.Assert(allocation.SizeInBytes >= sizeof(FreeSection)); var index = Bits.MostSignificantBit(allocation.SizeInBytes) - 1; var section = (FreeSection *)address; section->SizeInBytes = allocation.SizeInBytes; section->Previous = _freed[index]; _freed[index] = section; return; } // since the returned allocation is at the end of the arena, we can just move // the pointer back _used -= allocation.SizeInBytes; TotalUsed -= allocation.SizeInBytes; _ptrCurrent -= allocation.SizeInBytes; #endif }
public void Reset() { _unmanagedWriteBuffer.Dispose(); if (_compressionBuffer != null) { _context.ReturnMemory(_compressionBuffer); _compressionBuffer = null; } if (_innerBuffer != null) { _context.ReturnMemory(_innerBuffer); _innerBuffer = null; } }
private unsafe byte *GetCompressionBuffer(int minSize) { // enlarge buffer if needed if (_compressionBuffer == null || minSize > _compressionBuffer.SizeInBytes) { if (_compressionBuffer != null) { _context.ReturnMemory(_compressionBuffer); } _compressionBuffer = _context.GetMemory(minSize); } return(_compressionBuffer.Address); }
public void Return(AllocatedMemoryData returned) { #if MEM_GUARD ElectricFencedMemory.Free(returned.Address); GC.SuppressFinalize(returned); #else if (returned == null) { throw new ArgumentNullException(nameof(returned)); } var index = GetIndexFromSize(returned.SizeInBytes); if (index == -1) { NativeMemory.Free(returned.Address, returned.SizeInBytes, returned.AllocatingThread); return; // strange size, just free it } _freeSegments[index].Push(returned); #endif }
public UnmanagedWriteBuffer(JsonOperationContext context, AllocatedMemoryData allocatedMemoryData) { Debug.Assert(context != null); Debug.Assert(allocatedMemoryData != null); _context = context; _head = new Segment { Previous = null, DeallocationPendingPrevious = null, Allocation = allocatedMemoryData, Address = allocatedMemoryData.Address, Used = 0, AccumulatedSizeInBytes = 0 }; #if MEM_GUARD AllocatedBy = Environment.StackTrace; FreedBy = null; #endif }
public bool GrowAllocation(AllocatedMemoryData allocation, int sizeIncrease) { byte *end = allocation.Address + allocation.SizeInBytes; var distance = end - _ptrCurrent; if (distance != 0) { return(false); } // we need to keep the total allocation size as power of 2 sizeIncrease = Bits.NextPowerOf2(allocation.SizeInBytes + sizeIncrease) - allocation.SizeInBytes; if (_used + sizeIncrease > _allocated) { return(false); } _ptrCurrent += sizeIncrease; _used += sizeIncrease; TotalUsed += sizeIncrease; allocation.SizeInBytes += sizeIncrease; return(true); }
public BlittableWriter(JsonOperationContext context) { _context = context; _innerBuffer = _context.GetMemory(32); }
public BlittableWriter(JsonOperationContext context, TWriter writer) { _context = context; _unmanagedWriteBuffer = writer; _innerBuffer = _context.GetMemory(32); }