/// <summary>
/// Reads the next available node for reading into the specified struct array
/// </summary>
/// <typeparam name="T">The structure type to be read</typeparam>
/// <param name="buffer">Reference to the buffer</param>
/// <param name="timeout">The maximum number of milliseconds to wait for a node to become available for reading (default 1000ms)</param>
/// <returns>The number of bytes read</returns>
/// <remarks>The maximum number of bytes that can be read is the minimum of the length of <paramref name="buffer"/> multiplied by <code>Marshal.SizeOf(typeof(T))</code> and <see cref="NodeBufferSize"/>.</remarks>
public virtual int Read <T>(T[] buffer, int timeout = 1000)
where T : struct
{
Node *node = GetNodeForReading(timeout);
if (node == null)
{
return(0);
}
// Copy the data using the FastStructure class (much faster than the MemoryMappedViewAccessor ReadArray<T> method)
int amount = Math.Min(buffer.Length, NodeBufferSize / FastStructure.SizeOf <T>());
base.ReadArray <T>(buffer, node->Offset, 0, amount);
// Return the node for further writing
ReturnNode(node);
return(amount);
}
/// <summary>
/// Writes the struct array buffer to the next available node for writing
/// </summary>
/// <param name="buffer">Reference to the buffer to write</param>
/// <param name="timeout">The maximum number of milliseconds to wait for a node to become available for writing (default 1000ms)</param>
/// <returns>The number of bytes written</returns>
/// <remarks>The maximum number of bytes that can be written is the minimum of the length of <paramref name="buffer"/> multiplied by <code>Marshal.SizeOf(typeof(T))</code> and <see cref="NodeBufferSize"/>.</remarks>
public virtual int Write <T>(T[] buffer, int timeout = 1000)
where T : struct
{
// Grab a node for writing
Node *node = GetNodeForWriting(timeout);
if (node == null)
{
return(0);
}
// Write the data using the FastStructure class (much faster than the MemoryMappedViewAccessor WriteArray<T> method)
int amount = Math.Min(buffer.Length, NodeBufferSize / FastStructure.SizeOf <T>());
base.WriteArray <T>(node->Offset, buffer, 0, amount);
// Writing is complete, make node readable
PostNode(node);
return(amount);
}
/// <summary>
/// Writes the structure array buffer to the next available node for writing
/// </summary>
/// <param name="source">Reference to the buffer to write</param>
/// <param name="startIndex">The index within the buffer to start writing from</param>
/// <param name="timeout">The maximum number of milliseconds to wait for a node to become available for writing (default 1000ms)</param>
/// <returns>The number of elements written</returns>
/// <remarks>The maximum number of elements that can be written is the minimum of the length of <paramref name="source"/> subtracted by <paramref name="startIndex"/> and <see cref="NodeBufferSize"/> divided by <code>FastStructure.SizeOf>T<()</code>.</remarks>
public virtual int Write <T>(T[] source, int startIndex = 0)
where T : struct
{
// Grab a node for writing
Node *node = GetNodeForWriting();
if (node == null)
{
return(0);
}
// Write the data using the FastStructure class (much faster than the MemoryMappedViewAccessor WriteArray<T> method)
int count = Math.Min(source.Length - startIndex, NodeBufferSize / FastStructure.SizeOf <T>());
base.WriteArray <T>(source, startIndex, count, node->Offset);
node->AmountWritten = count * FastStructure.SizeOf <T>();
// Writing is complete, make node readable
PostNode(node);
return(count);
}
/// <summary>
/// Reads the next available node for reading into the specified structure array
/// </summary>
/// <typeparam name="T">The structure type to be read</typeparam>
/// <param name="destination">Reference to the buffer</param>
/// <param name="startIndex">The index within the destination to start writing to.</param>
/// <param name="timeout">The maximum number of milliseconds to wait for a node to become available for reading (default 1000ms)</param>
/// <returns>The number of elements read into destination</returns>
/// <remarks>The maximum number of elements that can be read is the minimum of the length of <paramref name="destination"/> subtracted by <paramref name="startIndex"/> and <see cref="Node.AmountWritten"/> divided by <code>FastStructure.SizeOf>T<()</code>.</remarks>
public virtual int Read <T>(T[] destination, int startIndex = 0, int timeout = 1000)
where T : struct
{
Node *node = GetNodeForReading(timeout);
if (node == null)
{
return(0);
}
// Copy the data using the FastStructure class (much faster than the MemoryMappedViewAccessor ReadArray<T> method)
int count = Math.Min(destination.Length - startIndex, node->AmountWritten / FastStructure.SizeOf <T>());
base.ReadArray <T>(destination, startIndex, count, node->Offset);
// Return the node for further writing
ReturnNode(node);
return(count);
}
/// <summary>
/// Construct a new RpcBuffer
/// </summary>
/// <param name="name">The unique channel name. This is the name to be shared between the master/slave pair. Each pair must have a unique value.</param>
/// <param name="bufferCapacity">Master only: Maximum buffer capacity. Messages will be split into packets that fit this capacity (including a packet header of 64-bytes). The slave will use the same size as defined by the master</param>
/// <param name="protocolVersion">ProtocolVersion.V1 = 64-byte header for each packet</param>
/// <param name="bufferNodeCount">Master only: The number of nodes in the underlying circular buffers, each with a size of <paramref name="bufferCapacity"/></param>
public RpcBuffer(string name, int bufferCapacity = 50000, RpcProtocol protocolVersion = RpcProtocol.V1, int bufferNodeCount = 10)
{
if (bufferCapacity < 256) // min 256 bytes
{
throw new ArgumentOutOfRangeException(nameof(bufferCapacity), "cannot be less than 256 bytes");
}
if (bufferCapacity > 1024 * 1024) // max 1MB
{
throw new ArgumentOutOfRangeException(nameof(bufferCapacity), "cannot be larger than 1MB");
}
Statistics = new RpcStatistics();
masterMutex = new Mutex(true, name + "SharedMemory_MasterMutex", out bool createdNew);
if (createdNew && masterMutex.WaitOne(500))
{
instanceType = InstanceType.Master;
}
else
{
instanceType = InstanceType.Slave;
if (masterMutex != null)
{
masterMutex.Close();
masterMutex.Dispose();
masterMutex = null;
}
}
switch (protocolVersion)
{
case RpcProtocol.V1:
this.protocolVersion = protocolVersion;
protocolLength = FastStructure.SizeOf <RpcProtocolHeaderV1>();
Statistics.ProtocolOverheadPerPacket = protocolLength;
break;
}
this.bufferCapacity = bufferCapacity;
this.bufferNodeCount = bufferNodeCount;
if (instanceType == InstanceType.Master)
{
WriteBuffer = new CircularBuffer(name + "_Slave_SharedMemory_MMF", bufferNodeCount, this.bufferCapacity);
ReadBuffer = new CircularBuffer(name + "_Master_SharedMemory_MMF", bufferNodeCount, this.bufferCapacity);
}
else
{
ReadBuffer = new CircularBuffer(name + "_Slave_SharedMemory_MMF");
WriteBuffer = new CircularBuffer(name + "_Master_SharedMemory_MMF");
this.bufferCapacity = ReadBuffer.NodeBufferSize;
this.bufferNodeCount = ReadBuffer.NodeCount;
}
this.msgBufferLength = Convert.ToInt32(this.bufferCapacity) - protocolLength;
Task.Run(() =>
{
switch (protocolVersion)
{
case RpcProtocol.V1:
ReadThreadV1();
break;
}
});
}