/// <summary>
/// Reads the content of the BitFieldArray using the supplied reader
/// </summary>
/// <param name="reader"></param>
public void Read(BinaryReader reader)
{
NumBits = reader.ReadInt32();
if (NumBits == 0)
{
return;
}
AllocateBuffer();
var bufferSize = NumStorageElements() * sizeof(ulong);
byte[] buffer = GenericArrayPoolCacheHelper <byte> .Caches().Rent(bufferSize);
try
{
reader.Read(buffer, 0, bufferSize);
Buffer.BlockCopy(buffer, 0, Storage, 0, bufferSize);
}
finally
{
GenericArrayPoolCacheHelper <byte> .Caches().Return(ref buffer);
}
}
public void GenericArrayPool_T_RentAndReturn_SingleItem()
{
for (int i = 0; i < 20; i++)
{
byte[] b = GenericArrayPoolCacheHelper <byte> .Caches().Rent(1 << i + 1);
GenericArrayPoolCacheHelper <byte> .Caches().Return(ref b);
}
}
public void Dispose()
{
if (!_disposed)
{
if (Storage != null)
{
GenericArrayPoolCacheHelper <ulong> .Caches().Return(ref Storage);
}
_disposed = true;
}
}
public void GlobalSetup()
{
_arrayPool = ArrayPool <byte> .Shared;
DIBuilder.New().AddLogging()
.Add(x => x.AddSingleton <IGenericArrayPoolCaches <byte> >(new GenericArrayPoolCaches <byte>())).Build()
.Complete();
_genericArrayPoolIntf = GenericArrayPoolCacheHelper <byte> .Caches();
_genericArrayPoolObj = GenericArrayPoolCacheHelper <byte> .Caches() as GenericArrayPoolCaches <byte>;
}
public void GenericArrayPool_T_RentAndReturn_MultipleItems()
{
for (int i = 0; i < 20; i++)
{
byte[] b1 = GenericArrayPoolCacheHelper <byte> .Caches().Rent(1 << i + 1);
byte[] b2 = GenericArrayPoolCacheHelper <byte> .Caches().Rent(1 << i + 1);
GenericArrayPoolCacheHelper <byte> .Caches().Return(ref b1);
GenericArrayPoolCacheHelper <byte> .Caches().Return(ref b2);
}
}
public void Read(BinaryReader reader)
{
segmentPassCount = reader.ReadInt32();
var passCountBuffer = GenericArrayPoolCacheHelper <long> .Caches().Rent(SubGridTreeConsts.CellsPerSubGrid);
try
{
var fieldDescriptor = new EncodedBitFieldDescriptor();
fieldDescriptor.Read(reader);
using (var bfa = new BitFieldArray())
{
bfa.Read(reader);
int bitLocation = 0;
bfa.ReadBitFieldVector(ref bitLocation, fieldDescriptor, SubGridTreeConsts.CellsPerSubGrid, passCountBuffer);
}
var counter = 0;
for (var i = 0; i < SubGridTreeConsts.SubGridTreeDimension; i++)
{
for (var j = 0; j < SubGridTreeConsts.SubGridTreeDimension; j++)
{
var passCount = (int)passCountBuffer[counter++];
if (passCount > 0)
{
AllocatePasses(i, j, passCount);
_passData[i, j].Passes.Count = passCount;
var passes = _passData[i, j].Passes;
for (int cpi = passes.Offset, limit = passes.OffsetPlusCount; cpi < limit; cpi++)
{
passes.Elements[cpi].Read(reader);
}
}
}
}
}
finally
{
GenericArrayPoolCacheHelper <long> .Caches().Return(ref passCountBuffer);
}
}
/// <summary>
/// Write the contents of the Items array using the supplied writer
/// </summary>
public override void Write(BinaryWriter writer)
{
base.Write(writer);
const int BUFFER_SIZE = SubGridTreeConsts.SubGridTreeCellsPerSubGrid * sizeof(long);
var buffer = GenericArrayPoolCacheHelper <byte> .Caches().Rent(BUFFER_SIZE);
try
{
Buffer.BlockCopy(Times, 0, buffer, 0, BUFFER_SIZE);
writer.Write(buffer, 0, BUFFER_SIZE);
}
finally
{
GenericArrayPoolCacheHelper <byte> .Caches().Return(ref buffer);
}
}
/// <summary>
/// Fill the items array by reading the binary representation using the provided reader.
/// </summary>
/// <param name="reader"></param>
public override void Read(BinaryReader reader)
{
base.Read(reader);
const int BUFFER_SIZE = SubGridTreeConsts.SubGridTreeCellsPerSubGrid * sizeof(long);
var buffer = GenericArrayPoolCacheHelper <byte> .Caches().Rent(BUFFER_SIZE);
try
{
reader.Read(buffer, 0, BUFFER_SIZE);
Buffer.BlockCopy(buffer, 0, Times, 0, BUFFER_SIZE);
}
finally
{
GenericArrayPoolCacheHelper <byte> .Caches().Return(ref buffer);
}
}
public int NumStorageElements() => MemorySize() % N_BYTES_TO_READ_AT_A_TIME == 0 ? MemorySize() / N_BYTES_TO_READ_AT_A_TIME : (MemorySize() / N_BYTES_TO_READ_AT_A_TIME) + 1; // FNumBits % N_BITS_TO_READ_AT_A_TIME == 0 ? FNumBits / N_BITS_TO_READ_AT_A_TIME : FNumBits / N_BITS_TO_READ_AT_A_TIME + 1;
/// <summary>
/// Allocates the storage array for storing the block that comprise the bit field array
/// </summary>
/// <returns></returns>
private ulong[] NewStorage()
{
if (Storage != null)
{
GenericArrayPoolCacheHelper <ulong> .Caches().Return(ref Storage);
}
var numElements = NumStorageElements();
var buffer = GenericArrayPoolCacheHelper <ulong> .Caches().Rent(numElements);
// Clear the buffer TODO: Move this logic to write side only
for (int i = 0; i < numElements; i++)
{
buffer[i] = 0;
}
return(buffer);
}
/// <summary>
/// Fill the items array by reading the binary representation using the provided reader.
/// This is an unimplemented override; a generic BinaryReader based implementation is not provided.
/// Override to implement if needed.
/// </summary>
/// <param name="reader"></param>
public override void Read(BinaryReader reader)
{
base.Read(reader);
const int bufferSize = SubGridTreeConsts.SubGridTreeCellsPerSubGrid * sizeof(ushort);
var buffer = GenericArrayPoolCacheHelper <byte> .Caches().Rent(bufferSize);
try
{
reader.Read(buffer, 0, bufferSize);
Buffer.BlockCopy(buffer, 0, Cells, 0, bufferSize);
}
finally
{
GenericArrayPoolCacheHelper <byte> .Caches().Return(ref buffer);
}
}
/// <summary>
/// Write the contents of the Items array using the supplied writer
/// This is an unimplemented override; a generic BinaryReader based implementation is not provided.
/// Override to implement if needed.
/// </summary>
/// <param name="writer"></param>
public override void Write(BinaryWriter writer)
{
base.Write(writer);
const int bufferSize = SubGridTreeConsts.SubGridTreeCellsPerSubGrid * sizeof(ushort);
var buffer = GenericArrayPoolCacheHelper <byte> .Caches().Rent(bufferSize);
try
{
Buffer.BlockCopy(Cells, 0, buffer, 0, bufferSize);
writer.Write(buffer, 0, bufferSize);
}
finally
{
GenericArrayPoolCacheHelper <byte> .Caches().Return(ref buffer);
}
}
/// <summary>
/// Add adds a value recorded at DateTime to the list. It is assumed
/// that the date time of this item is after the date time
/// of any previously added item in the list
/// </summary>
/// <param name="dateTime"></param>
/// <param name="value"></param>
public void Add(DateTime dateTime, T value)
{
if (dateTime.Kind != DateTimeKind.Utc)
{
throw new ArgumentException("Attribute time must be a UTC cell pass time", nameof(dateTime));
}
// If there are available entries to reuse, then reuse them...
if (NumAttrs >= list.Length)
{
var newList = GenericArrayPoolCacheHelper <AccumulatedAttribute <T> > .Caches().Rent(list.Length + DEFAULT_ACCUMULATOR_LIST_SIZE_INCREMENT);
Array.Copy(list, 0, newList, 0, list.Length);
GenericArrayPoolCacheHelper <AccumulatedAttribute <T> > .Caches().Return(ref list);
list = newList;
}
list[NumAttrs++].Set(dateTime, value);
}
/// <summary>
/// Writes the content of the BitFieldArray using the supplied BinaryWriter
/// </summary>
/// <param name="writer"></param>
public void Write(BinaryWriter writer)
{
writer.Write(NumBits);
if (NumBits == 0)
{
return;
}
var bufferSize = NumStorageElements() * sizeof(ulong);
byte[] buffer = GenericArrayPoolCacheHelper <byte> .Caches().Rent(bufferSize);
try
{
Buffer.BlockCopy(Storage, 0, buffer, 0, bufferSize);
writer.Write(buffer, 0, bufferSize);
}
finally
{
GenericArrayPoolCacheHelper <byte> .Caches().Return(ref buffer);
}
}
public AccumulatedAttributes(int initialSize)
{
NumAttrs = 0;
list = GenericArrayPoolCacheHelper <AccumulatedAttribute <T> > .Caches().Rent(initialSize);
}
