public void NestedVectorTest()
{
var name = Guid.NewGuid().ToString();
using (var memory = SharedMemory.Create(name, 1024 * 1024))
using (var vv = Factory.Make <IVector <IVector <int> > >(memory))
{
const int N = 5;
const int x = 123;
for (int i = 0; i < N; ++i)
{
using (var v = Factory.Make <IVector <int> >(memory))
{
v.Resize(N, x);
Assert.AreEqual(N, v.Count);
vv.Add(v);
}
}
Assert.AreEqual(N, vv.Count);
Assert.AreEqual(N * N * x, vv.Sum((v) => { using (v) return(v.Sum()); }));
}
}
public void SerializerTest()
{
using (var memory = SharedMemory.Create(Guid.NewGuid().ToString(), 4 * 1024 * 1024))
using (var pool = new BufferPool(memory))
{
foreach (var protocol in new global::Bond.ProtocolType[] { global::Bond.ProtocolType.COMPACT_PROTOCOL, global::Bond.ProtocolType.FAST_PROTOCOL, global::Bond.ProtocolType.SIMPLE_PROTOCOL })
{
foreach (var marshal in new bool[] { true, false })
{
var serializer = new Serializer(protocol, marshal, pool, memory);
Assert.AreEqual(protocol, serializer.ProtocolType);
Assert.AreEqual(marshal, serializer.IsMarshaled);
var s1 = MakeRandomStruct();
TestStruct s2;
using (var buffer = serializer.Serialize(s1))
{
s2 = serializer.Deserialize <TestStruct>(buffer);
}
// Bond.Comparer.Equal does not properly work with Bonded<T> fields.
Assert.IsTrue(global::Bond.Comparer.Equal(s1.FieldBonded.Deserialize(), s2.FieldBonded.Deserialize()));
s1.FieldBonded = s2.FieldBonded = global::Bond.Bonded <ValueStruct> .Empty;
Assert.IsTrue(global::Bond.Comparer.Equal(s1, s2));
}
}
}
}
internal unsafe SharedMemory RentNative(int bucketSize)
{
var bucketIndex = SelectBucketIndex(bucketSize);
BufferRef.EnsureBucketIndexInRange(bucketIndex);
// We must init the buffer header before allocating.
// We know from inside BRA.Allocate txn the value or BufferRef
// before committing. For new we must init the header,
// for one from the free list we must assert the buffer is disposed
// and not owned (it may be in Releasing state though).
var br = _bra.Allocate((byte)bucketIndex, out _, _buckets);
var db = _buckets.DangerousGet(br);
var sm = SharedMemory.Create(db, br, this);
Debug.Assert(sm.IsDisposed);
Debug.Assert(Unsafe.Read <uint>(sm.HeaderPointer) == (HeaderFlags.Releasing | HeaderFlags.IsDisposed));
sm.FromReleasingDisposedToOwned();
Debug.Assert(!sm.IsDisposed);
Debug.Assert(sm.ReferenceCount == 0);
Debug.Assert(Unsafe.Read <uint>(sm.HeaderPointer) == HeaderFlags.IsOwned);
return(sm);
}
static void Main(string[] args)
{
Console.Title = "HostA";
SharedMemory sm = SharedMemory.Create("SM1", 1024);
using (var w = sm.AsWriter())
{
w.Write(1);
w.Write(2);
w.Write(3);
w.Write(new byte[5] {
0x4, 0x5, 0x6, 0x7, 0x8
});
}
Console.WriteLine("Values written to shared memory = {0}", sm.Name);
Console.ReadLine();
SharedMemory sm2 = SharedMemory.Create("SM2", 2L * 1024);
using (var w = sm2.AsWriter(offset: 0L, size: 1L * 1024))
{
var buffer1 = new byte[1 * 1024];
for (int i = 0; i < buffer1.Length; i += 2)
{
buffer1[i] = 0xA;
buffer1[i + 1] = 0xB;
}
w.Write(buffer1);
Console.WriteLine("Values written to shared memory = {0} offset = {1} size = {2}", w.Source.Name, w.Offset, w.Size);
}
Console.ReadLine();
using (var w = sm2.AsWriter(offset: 1L * 1024, size: 1L * 1024))
{
var buffer2 = new byte[1 * 1024];
for (int i = 0; i < buffer2.Length; i += 2)
{
buffer2[i] = 0xD;
buffer2[i + 1] = 0xE;
}
w.Write(buffer2);
Console.WriteLine("Values written to shared memory = {0} offset = {1} size = {2}", w.Source.Name, w.Offset, w.Size);
}
Console.ReadLine();
using (var w = sm2.AsWriter(offset: 0L, size: 1L * 1024))
{
var buffer1 = new byte[1 * 1024];
for (int i = 0; i < buffer1.Length; i += 2)
{
buffer1[i] = 0xC;
buffer1[i + 1] = 0xF;
}
w.Write(buffer1);
Console.WriteLine("Values written to shared memory = {0} offset = {1} size = {2}", w.Source.Name, w.Offset, w.Size);
}
Console.ReadLine();
}
public void VectorTest()
{
var name = Guid.NewGuid().ToString();
using (var memory = SharedMemory.Create(name, 1024 * 1024))
using (var v = Factory.Make <IVector <int> >(memory))
{
const int N = 100;
for (int i = 0; i < N; ++i)
{
v.Add(i);
}
v.Resize(2 * N, 1);
Assert.AreEqual(2 * N, v.Count);
Assert.AreEqual(N + (N - 1) * N / 2, v.Sum());
}
}