public void BinaryBlockSerializer_Performance()
{
// Goal: Block Read and Write are beyond maximum hard drive performance; >1GB per second.
// My sample array (a maximum common size we'll store) is 64k * 8 = 512KB, so we want to read and write it >2,000 times per second
ulong[] largeArray = new ulong[ushort.MaxValue];
for (int i = 0; i < ushort.MaxValue; ++i)
{
largeArray[i] = (ulong)i;
}
using (SerializationContext context = new SerializationContext(new MemoryStream()))
{
int iterations = 100;
Stopwatch w = Stopwatch.StartNew();
for (int i = 0; i < iterations; ++i)
{
BinaryBlockSerializer.WriteArray(context, largeArray);
context.Stream.Seek(0, SeekOrigin.Begin);
ulong[] readArray = BinaryBlockSerializer.ReadArray <ulong>(context);
context.Stream.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(largeArray.Length, readArray.Length);
}
int operations = (2 * iterations);
double milliseconds = w.ElapsedMilliseconds;
double operationsPerSecond = 1000 * operations / milliseconds;
Trace.Write(String.Format("{0:n0} operations in {1:n0} milliseconds; {2:n0} per second.", operations, milliseconds, operationsPerSecond));
Assert.IsTrue(operationsPerSecond > 1000, "Not within 200% of goal.");
}
}
public void WriteBinary(ISerializationContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
context.Writer.Write(_capacity);
BinaryBlockSerializer.WriteArray(context, _bitVector);
}
public void WriteBinary(ISerializationContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
context.Writer.Write(_itemCount);
BinaryBlockSerializer.Write(context, _default);
BinaryBlockSerializer.WriteArray(context, _values, 0, _itemCount);
}
public void BinaryBlockSerializer_MismatchTypeReadAndWrite()
{
using (SerializationContext context = new SerializationContext(new MemoryStream()))
{
int singleLength = BinaryBlockSerializer.Write(context, (int)500);
context.Stream.Seek(-singleLength, SeekOrigin.Current);
Verify.Exception <IOException>(
() => { ushort wrongType = BinaryBlockSerializer.Read <ushort>(context); }
);
}
}
public void ReadBinary(ISerializationContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
_itemCount = context.Reader.ReadUInt16();
_default = BinaryBlockSerializer.Read <T>(context);
_values = BinaryBlockSerializer.ReadArray <T>(context);
}
public void BinaryBlockSerializer_ByteArrayAsSingle()
{
byte[] value = new byte[] { 0, 127, 128, 255 };
using (SerializationContext context = new SerializationContext(new MemoryStream()))
{
int singleLength = BinaryBlockSerializer.Write(context, value);
context.Stream.Seek(-singleLength, SeekOrigin.Current);
byte[] readValue = BinaryBlockSerializer.Read <byte[]>(context);
Assert.AreEqual(String.Join(", ", value), String.Join(", ", readValue));
}
}
public void ReadBinary(ISerializationContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ushort capacity = context.Reader.ReadUInt16();
Initialize(capacity);
_bitVector = BinaryBlockSerializer.ReadArray <ulong>(context);
}
public void BinaryBlockSerializer_BadTerminatorDetection()
{
using (SerializationContext context = new SerializationContext(new MemoryStream()))
{
int singleLength = BinaryBlockSerializer.WriteArray(context, new int[] { 0, 1, 2, 3 });
context.Stream.Seek(-1, SeekOrigin.Current);
context.Stream.WriteByte(0xBD);
context.Stream.Seek(-singleLength, SeekOrigin.Current);
Verify.Exception <IOException>(
() => { int[] badTerminator = BinaryBlockSerializer.ReadArray <int>(context); }
);
}
}
public void WriteBinary(ISerializationContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
// NOTE: DefaultValue is not preserved here [compat], but Partition serialization re-creates it from ColumnDetails.
context.Writer.Write(_itemCount);
context.Writer.Write(_batchCount);
context.Writer.Write(_appendToBatchIndex);
BinaryBlockSerializer.WriteSerializableArray(context, _index, 0, _itemCount);
BinaryBlockSerializer.WriteSerializableArray(context, _batches, 0, _batchCount);
}
public void ReadBinary(ISerializationContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
// NOTE: DefaultValue is not preserved here [compat], but Partition serialization re-creates it from ColumnDetails.
_itemCount = context.Reader.ReadUInt16();
_batchCount = context.Reader.ReadUInt16();
_appendToBatchIndex = context.Reader.ReadUInt16();
_index = BinaryBlockSerializer.ReadSerializableArray <BlockPosition>(context);
_batches = BinaryBlockSerializer.ReadSerializableArray <BlockBatch>(context);
}
private static void RoundTrip <T>(SerializationContext context, T value)
{
// Test Array Reading
int arrayLength = BinaryBlockSerializer.WriteArray <T>(context, new T[] { value });
context.Stream.Seek(-arrayLength, SeekOrigin.Current);
T[] readArray = BinaryBlockSerializer.ReadArray <T>(context);
Assert.AreEqual(value, readArray[0]);
// Test Single Reading
int singleLength = BinaryBlockSerializer.Write(context, value);
context.Stream.Seek(-singleLength, SeekOrigin.Current);
T readValue = BinaryBlockSerializer.Read <T>(context);
Assert.AreEqual(value, readValue);
}
public void BinaryBlockSerializer_Basic()
{
int[] sampleValueTypeArray = new int[] { 5, 7, 9, -1 };
byte[] sampleByteArray = Encoding.UTF8.GetBytes("Hello");
using (SerializationContext context = new SerializationContext(new MemoryStream()))
{
Assert.AreEqual(0, context.Stream.Length, "No data should be written before any write calls are made.");
BinaryBlockSerializer.WriteArray(context, sampleValueTypeArray);
BinaryBlockSerializer.WriteArray(context, sampleByteArray);
context.Stream.Seek(0, SeekOrigin.Begin);
int[] reloadedValueTypeArray = BinaryBlockSerializer.ReadArray <int>(context);
byte[] reloadedByteArray = BinaryBlockSerializer.ReadArray <byte>(context);
Assert.AreEqual(context.Stream.Position, context.Stream.Length, "Stream wasn't fully read when reloading values.");
Assert.AreEqual(String.Join(", ", sampleValueTypeArray), String.Join(", ", reloadedValueTypeArray));
Assert.AreEqual(Encoding.UTF8.GetString(sampleByteArray), Encoding.UTF8.GetString(reloadedByteArray));
}
}
public void ReadBinary(ISerializationContext context)
{
this.Array = BinaryBlockSerializer.ReadArray <byte>(context);
this.UsedSpace = context.Reader.ReadUInt16();
this.WasteSpace = context.Reader.ReadUInt16();
}
public void BinaryBlockSerializer_ReadArray_UnsupportedType()
{
Verify.Exception <IOException>(
() => { BinaryBlockSerializerTests[] us = BinaryBlockSerializer.ReadArray <BinaryBlockSerializerTests>(new SerializationContext(new MemoryStream())); }
);
}
public void BinaryBlockSerializer_WriteArray_UnsupportedType()
{
Verify.Exception <IOException>(
() => { BinaryBlockSerializer.WriteArray(new SerializationContext(new MemoryStream()), new BinaryBlockSerializerTests[1]); }
);
}
public void WriteBinary(ISerializationContext context)
{
BinaryBlockSerializer.WriteArray(context, this.Array);
context.Writer.Write(this.UsedSpace);
context.Writer.Write(this.WasteSpace);
}
public override void WriteBinary(ISerializationContext context)
{
this.Column.WriteBinary(context);
BinaryBlockSerializer.WriteArray(context, this.SortedIDs, 0, this.Column.Count);
}
public override void ReadBinary(ISerializationContext context)
{
this.Column.ReadBinary(context);
this.SortedIDs = BinaryBlockSerializer.ReadArray <ushort>(context);
this.SortedIDCount = this.Column.Count;
}
