public static MemoryFragment Serialize <T>(this T o, IMemoryHighway hw, Action <MemoryStream> pre = null)
{
if (hw == null || hw.IsDisposed)
{
throw new ArgumentNullException("hw");
}
using (var ms = new MemoryStream())
{
if (pre != null)
{
pre(ms);
}
var bf = new BinaryFormatter();
bf.Serialize(ms, o);
var f = hw.AllocFragment((int)ms.Length);
var fs = f.CreateStream();
ms.Seek(0, SeekOrigin.Begin);
fs.Seek(0, SeekOrigin.Begin);
ms.CopyTo(fs);
return(f);
}
}
internal Exchange(
XPU xpu,
int refID,
int xflags,
int errorCode,
string resID,
Span <byte> data,
IMemoryHighway hw)
{
XPU = xpu;
var resBytes = Encoding.UTF8.GetBytes(resID);
ResIDLen = (ushort)resBytes.Length;
var fl = data.Length + ResIDLen + HEADER_LEN;
Fragment = hw.AllocFragment(fl);
if (Fragment == null)
{
throw new ArgumentNullException("Fragment");
}
var pos = 0;
this.ID = xpu.nextExchangeID();
this.RefID = refID;
this.Flags = xflags;
this.Created = DateTime.Now.Ticks;
this.ErrorCode = errorCode;
this.state = (int)XState.Created;
this.ResID = resID;
pos = Fragment.Write(EXCHANGE_TYPE_ID, pos);
pos = Fragment.Write(ID, pos);
pos = Fragment.Write(refID, pos);
pos = Fragment.Write((int)xflags, pos);
pos = Fragment.Write(Created, pos);
pos = Fragment.Write(errorCode, pos);
pos = Fragment.Write(ResIDLen, pos);
if (resBytes.Length > 0)
{
pos = Fragment.Write(resBytes, pos);
}
DataOffset = pos;
if (data.Length > 0)
{
Fragment.Write(data, pos);
}
}
public Block(int id, int totalSize, ushort tileSize, IMemoryHighway hw)
{
ID = id;
TileSize = tileSize;
TotalSize = totalSize;
TilesCount = totalSize / tileSize;
if (TotalSize > tileSize && TotalSize % tileSize != 0)
{
TilesCount++;
}
if (TilesCount == 0)
{
TilesCount = 1;
}
IsIncoming = true;
fragment = hw.AllocFragment(totalSize);
tileMap = new BitMask(TilesCount);
}
public static void AllocAndWait(this IMemoryHighway hw, AllocTestArgs args)
{
var rdm = new Random();
var hwType = hw.GetType().Name;
var inParallel = args.InParallel > 0 ? args.InParallel : Environment.ProcessorCount;
var T = new Task[inParallel];
var part = args.Count / inParallel;
var rem = args.Count % inParallel;
var dispCounter = new CountdownEvent(args.Count);
for (int i = 0; i < inParallel; i++)
{
T[i] = Task.Run(async() =>
{
// [!] Do not try catch
// Someone must process the remainder
var subCount = rem > 0 ? part + Interlocked.Exchange(ref rem, 0) : part;
for (int j = 0; j < subCount; j++)
{
var size = args.RandomizeLength ? rdm.Next(1, args.Size) : args.Size;
var allocDelayMS = args.RandomizeAllocDelay && args.AllocDelayMS > 0 ? rdm.Next(0, args.AllocDelayMS) : args.AllocDelayMS;
var dispDelayMS = args.RandomizeFragDisposal ? rdm.Next(0, args.FragmentDisposeAfterMS) : args.FragmentDisposeAfterMS;
if (allocDelayMS > 0)
{
await Task.Delay(allocDelayMS);
}
var frag = hw.AllocFragment(size, args.AllocTries);
if (frag == null)
{
"failed to allocate a fragment. The Highway is full.".AsInfo(ConsoleColor.DarkMagenta);
dispCounter.Signal();
continue;
}
if (args.Trace > 0)
{
Print.Trace("alloc {0,8} bytes on {1} thread: {2} ",
ConsoleColor.Magenta, size, hwType,
Thread.CurrentThread.ManagedThreadId);
}
var t = Task.Run(async() =>
{
if (dispDelayMS > 0)
{
await Task.Delay(dispDelayMS);
}
if (args.Trace > 0)
{
Print.Trace("free {0,8} bytes on {1} thread: {2} ",
ConsoleColor.Green, frag.Length, hwType,
Thread.CurrentThread.ManagedThreadId);
}
frag.Dispose();
dispCounter.Signal();
});
}
});
}
Task.WaitAll(T);
if (args.AwaitFragmentDisposal)
{
dispCounter.Wait();
}
}
