internal static void UnsafeWait(Scheduler sr, int ms, WorkerEvent ev)
{
ev.Next = sr.WaiterStack;
sr.WaiterStack = ev.Me;
UnsafeDec(sr);
Exit(sr);
ev.Wait(ms);
Enter(sr);
if (ev.IsSet)
{
ev.Reset();
}
else
{
Debug.Assert(0 <= sr.NumActive);
sr.NumActive += 1;
int i = sr.WaiterStack;
int me = ev.Me;
if (i == me)
{
sr.WaiterStack = ev.Next;
}
else
{
WorkerEvent p = sr.Events[i];
while (p.Next != me)
{
p = sr.Events[p.Next];
}
p.Next = ev.Next;
}
}
}
internal Scheduler(bool foreground,
Job <int> idleHandler,
int maxStackSize,
int numWorkers,
ThreadPriority priority,
FSharpFunc <Exception, Job <Unit> > topLevelHandler)
{
StaticData.Init();
TopLevelHandler = topLevelHandler;
IdleHandler = idleHandler;
WaiterStack = -1;
NumActive = numWorkers;
Events = new WorkerEvent[numWorkers];
var threads = new Thread[numWorkers];
for (int i = 0; i < numWorkers; ++i)
{
Events[i] = new WorkerEvent(i);
var index = i;
var thread = new Thread(() => Worker.Run(this, index), maxStackSize);
threads[i] = thread;
thread.Priority = priority;
thread.IsBackground = !foreground;
}
for (int i = 0; i < numWorkers; ++i)
{
threads[i].Start();
}
}
private async Async.Task <HttpResponseData> Post(HttpRequestData req)
{
var request = await RequestHandling.ParseRequest <NodeStateEnvelope>(req);
if (!request.IsOk)
{
return(await _context.RequestHandling.NotOk(req, request.ErrorV, context : "node event"));
}
var envelope = request.OkV;
_log.Info($"node event: machine_id: {envelope.MachineId} event: {EntityConverter.ToJsonString(envelope)}");
var error = envelope.Event switch {
NodeStateUpdate updateEvent => await OnStateUpdate(envelope.MachineId, updateEvent),
WorkerEvent workerEvent => await OnWorkerEvent(envelope.MachineId, workerEvent),
NodeEvent nodeEvent => await OnNodeEvent(envelope.MachineId, nodeEvent),
_ => new Error(ErrorCode.INVALID_REQUEST, new string[] { $"invalid node event: {envelope.Event.GetType().Name}" }),
};
if (error is Error e)
{
return(await _context.RequestHandling.NotOk(req, e, context : "node event"));
}
else
{
return(await RequestHandling.Ok(req, new BoolResult(true)));
}
}
internal static void UnsafeWait(Scheduler sr, int ms, WorkerEvent ev)
{
ev.Next = sr.WaiterStack;
sr.WaiterStack = ev.Me;
UnsafeDec(sr);
Exit(sr);
ev.Wait(ms);
ev.Reset();
}
protected override bool DispatchThreadEvents(WorkerEvent workerEvent)
{
switch (workerEvent.EventType)
{
case WorkerEventType.RedrawLayer:
{
DrawLayer(new Rectangle(0, 0, Width, Height));
return(true);
}
}
return(base.DispatchThreadEvents(workerEvent));
}
private void storeResult(uint result)
{
if (ExpManager.sharedInstance.orderedStorage)
{
if (outcomes.Count == 0)
{
ResultObject r = new ResultObject
{
amount = 1,
roll = result
};
outcomes.Add(r);
}
else if (result == outcomes.Last().roll)
{
ResultObject r = outcomes.Last();
outcomes.RemoveAt(outcomes.Count - 1);
++r.amount;
outcomes.Add(r);
}
else
{
ResultObject r = new ResultObject
{
amount = 1,
roll = result
};
try
{
outcomes.Add(r);
} catch (OutOfMemoryException)
{
outcomes.TrimExcess();
try
{
outcomes.Add(r);
} catch (OutOfMemoryException)
{
WorkerEvent.Invoke("Thread " + System.Threading.Thread.CurrentThread.Name + " ran out of memory and garbage collection failed. Aborting thread.");
abort = true;
}
}
}
}
else
{
++unorderedOutcomes[result];
}
}
private async Async.Task <Error?> OnWorkerEvent(Guid machineId, WorkerEvent ev)
{
if (ev.Done is not null)
{
return(await OnWorkerEventDone(machineId, ev.Done));
}
if (ev.Running is not null)
{
return(await OnWorkerEventRunning(machineId, ev.Running));
}
return(new Error(
Code: ErrorCode.INVALID_REQUEST,
Errors: new string[] { "WorkerEvent should have either 'done' or 'running' set" }));
}
protected override bool DispatchThreadEvents(WorkerEvent workerEvent)
{
var res = base.DispatchThreadEvents(workerEvent);
if (!res && workerEvent is NetWorkerEvent)
{
switch (workerEvent.EventType)
{
case WorkerEventType.ReloadData:
{
ReadDbData();
return(true);
}
}
}
return(res);
}
protected override bool DispatchThreadEvents(WorkerEvent workerEvent)
{
var res = base.DispatchThreadEvents(workerEvent);
if (!res && workerEvent is MapWorkerEvent)
{
switch (workerEvent.EventType)
{
case WorkerEventType.DownloadImage:
{
DownloadImage(((MapWorkerEvent)workerEvent).Block);
return(true);
}
case WorkerEventType.DrawImage:
{
DrawImage(((MapWorkerEvent)workerEvent).Block);
return(true);
}
}
}
return(res);
}
private static string GetEventType(WorkerEvent ev)
{
return(ev.GetType().Name);
}
private static string GetEventData(WorkerEvent ev)
{
return(ev.Done != null ? $"exit status: {ev.Done.ExitStatus}" :
ev.Running != null ? string.Empty : "Unrecognized event: {ev}");
}
internal static void UnsafeWait(Scheduler sr, int ms, WorkerEvent ev) {
ev.Next = sr.WaiterStack;
sr.WaiterStack = ev.Me;
UnsafeDec(sr);
Exit(sr);
ev.Wait(ms);
Enter(sr);
if (ev.IsSet) {
ev.Reset();
} else {
Debug.Assert(0 <= sr.NumActive);
sr.NumActive += 1;
int i = sr.WaiterStack;
int me = ev.Me;
if (i == me) {
sr.WaiterStack = ev.Next;
} else {
WorkerEvent p = sr.Events[i];
while (p.Next != me) {
p = sr.Events[p.Next];
}
p.Next = ev.Next;
}
}
}
