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; } } }