private static void ConcurrentSequencingWorker(SpinLockUC spinLock, ISequencerUC sequencer) { sequencer.Point(SeqPointTypeUC.Match, ConcurrentSequencingPhase.Begin); sequencer.Point(SeqPointTypeUC.Notify, ConcurrentSequencingPhase.EnteringSpinLock, Interlocked.Increment(ref StepConcurrentSequencing)); using (spinLock.Enter()) { sequencer.Point(SeqPointTypeUC.Match, ConcurrentSequencingPhase.Locked, Interlocked.Decrement(ref StepConcurrentSequencing)); sequencer.Point(SeqPointTypeUC.Notify, ConcurrentSequencingPhase.LockedNotify, Interlocked.Add(ref StepConcurrentSequencing, 0)); } sequencer.Point(SeqPointTypeUC.Match, ConcurrentSequencingPhase.End); }
private async Task Receiver(ISequencerUC sequencer, TaskCompletionSource <object> tcs) { sequencer.Point(SeqPointTypeUC.Notify, TCS.ReceiverInitialize); await tcs.Task; sequencer.Point(SeqPointTypeUC.Notify, TCS.ReceiverRecord, ThreadStaticWorker); //saving Worker state if (ThreadStaticWorker == nameof(Messanger)) { //$"{nameof(Messanger)} is now working for us synchronously!"; } }
private static void ConcurrentSequencingWorker(ILockUC Lock, ISequencerUC sequencer) { sequencer.Point(SeqPointTypeUC.Match, ConcurrentTryEnterDelaySequencingPhase.Begin); sequencer.Point(SeqPointTypeUC.Notify, ConcurrentTryEnterDelaySequencingPhase.EnteringSimpleLock, Interlocked.Increment(ref StepConcurrentSequencing)); using (EntryBlockUC entry = Lock.TryEnter(150)) { sequencer.PointArg(SeqPointTypeUC.Match, ConcurrentTryEnterDelaySequencingPhase.Entry, entry.HasEntry); if (entry.HasEntry) { sequencer.Point(SeqPointTypeUC.Match, ConcurrentTryEnterDelaySequencingPhase.Locked, Interlocked.Decrement(ref StepConcurrentSequencing)); sequencer.Point(SeqPointTypeUC.Notify, ConcurrentTryEnterDelaySequencingPhase.LockedNotify, Interlocked.Add(ref StepConcurrentSequencing, 0)); } } sequencer.Point(SeqPointTypeUC.Match, ConcurrentTryEnterDelaySequencingPhase.End); }
private void Messanger(ISequencerUC sequencer, TaskCompletionSource <object> tcs) { ThreadStaticWorker = nameof(Messanger); //thread static to detect Receiver is taking same thread sequencer.Point(SeqPointTypeUC.Notify, TCS.MessangerSetResult); tcs.SetResult(null); //before the thread is returned to thread pool, the thread static field is cleaned, ThreadStaticWorker = null; }
void PointArg <TEnum, TArg>(ISequencerUC sequencer, SeqPointTypeUC seqPointTypeUC, TEnum registration, TArg arg, Action <object> injectContinuation = null) where TEnum : struct { sequencer?.Point(seqPointTypeUC, registration, arg, injectContinuation); }
void Point <TEnum>(ISequencerUC sequencer, Func <bool> condition, SeqPointTypeUC seqPointTypeUC, TEnum registration, object arg = null, Action <object> injectContinuation = null) where TEnum : struct { sequencer?.Point(seqPointTypeUC, registration, condition, arg, injectContinuation); }
private void LockedWorker(ISequencerUC sequencer, object objLock) { try { sequencer.Point(SeqPointTypeUC.Notify, Worker.BeforeLock, Thread.CurrentThread); lock (objLock) { sequencer.Point(SeqPointTypeUC.Notify, Worker.Locked, Thread.CurrentThread); NamedPipeServerStream pipeServer = new NamedPipeServerStream("testpipe", PipeDirection.Out); sequencer.Point(SeqPointTypeUC.Notify, Worker.Stuck, Thread.CurrentThread); pipeServer.WaitForConnection(); pipeServer.Dispose(); sequencer.Throw(null, $"It was supposed to stuck {nameof(NamedPipeServerStream)}.{nameof(NamedPipeServerStream.WaitForConnection)}in unmanaged part of code, but did not happened!"); } } catch (Exception ex) { sequencer.Throw(ex, $"It was supposed to stuck {nameof(NamedPipeServerStream)}.{nameof(NamedPipeServerStream.WaitForConnection)}in unmanaged part of code, but did not happened!"); } finally { sequencer.Throw(null, $"It was supposed to stuck {nameof(NamedPipeServerStream)}.{nameof(NamedPipeServerStream.WaitForConnection)}in unmanaged part of code, but did not happened!"); } }
public async Task MultipleUnRegistrationsTest() { var tickGenerator = new TickGenerator(10); ISequencerUC sequencer = SequencerUC .Construct() .Register(Steps.Notify, new StrategyOneOnOneUC()) ; Action action = () => { sequencer.Point(SeqPointTypeUC.Notify, Steps.Notify); }; Task t = await tickGenerator.RegisterAsync(action).WrapIntoTask(); Assert.IsTrue(t.IsCompleted); Assert.IsFalse(t.IsCanceled); Assert.IsFalse(t.IsFaulted); for (int i = 0; i < 10; i++) { await sequencer.TestPointAsync(Steps.Notify); } t = await tickGenerator.UnRegisterAsync(action).WrapIntoTask(); Assert.IsTrue(t.IsCompleted); Assert.IsFalse(t.IsCanceled); Assert.IsFalse(t.IsFaulted); t = await tickGenerator.UnRegisterAsync(action).WrapIntoTask(); Assert.IsTrue(t.IsCompleted); Assert.IsFalse(t.IsCanceled); Assert.IsFalse(t.IsFaulted); await sequencer.WhenAll(); sequencer.TryReThrowException(); }
public async Task DisposeBasicTest() { var tickGenerator = new TickGenerator(10); ISequencerUC sequencer = SequencerUC .Construct() .Register(Steps.Notify, new StrategyOneOnOneUC()) ; Action action = () => { sequencer.Point(SeqPointTypeUC.Notify, Steps.Notify); }; tickGenerator.Dispose(); Task t = await tickGenerator.Disposed.WrapIntoTask(); Assert.IsTrue(t.IsCompleted); Assert.IsFalse(t.IsCanceled); Assert.IsFalse(t.IsFaulted); Assert.ThrowsAsync <ObjectDisposedException>(async() => t = await tickGenerator.RegisterAsync(action).WrapIntoTask()); Assert.IsTrue(t.IsCompleted); Assert.IsFalse(t.IsCanceled); Assert.IsFalse(t.IsFaulted); Assert.ThrowsAsync <ObjectDisposedException>(async() => t = await tickGenerator.UnRegisterAsync(action).WrapIntoTask()); Assert.IsTrue(t.IsCompleted); Assert.IsFalse(t.IsCanceled); Assert.IsFalse(t.IsFaulted); await sequencer.WhenAll(); sequencer.TryReThrowException(); }
public async Task ConcurrentTest() { ISequencerUC sequencer = SequencerUC .Construct() .Register(Steps.Notify, new StrategyOneOnOneUC()) .Register(TickGeneratorSequencer.RegisterStatus, new StrategyOneOnOneUC()) .Register(TickGeneratorSequencer.RegisterActiveProcessing, new StrategyOneOnOneUC()) .Register(TickGeneratorSequencer.UnRegisterStatus, new StrategyOneOnOneUC()) .Register(TickGeneratorSequencer.UnRegisterActiveProcessing, new StrategyOneOnOneUC()) .Register(TickGeneratorSequencer.Processing, new StrategyOneOnOneUC()) .Register(TickGeneratorSequencer.ExclusiveProcessing, new StrategyOneOnOneUC()) .Register(TickGeneratorSequencer.BeginActiveProcessing, new StrategyOneOnOneUC()) .Register(TickGeneratorSequencer.EndActiveProcessing, new StrategyOneOnOneUC()) .Register(TickGeneratorSequencer.ActionsProcessing, new StrategyOneOnOneUC()) .Register(TickGeneratorSequencer.ActionsProcessingCount, new StrategyOneOnOneUC()) .Register(TickGeneratorSequencer.TryUpdateTimerBegin, new StrategyOneOnOneUC()) .Register(TickGeneratorSequencer.TryUpdateTimerEnd, new StrategyOneOnOneUC()) .Register(TickGeneratorSequencer.CallBackProcessing, new StrategyOneOnOneUC()) //.Register(TickGeneratorSequencer.CallBackProcessing, new StrategyOneOnOneUC()) //.Register(TickGeneratorSequencer.CallBackProcessing, new StrategyOneOnOneUC()) //.Register(TickGeneratorSequencer.CallBackProcessing, new StrategyOneOnOneUC()) ; var tickGenerator = new TickGenerator(10, sequencer); Action action = () => { sequencer.Point(SeqPointTypeUC.Notify, Steps.Notify); }; Task <Task> tt = Task.Run(() => tickGenerator.RegisterAsync(action).WrapIntoTask()); var rStatus = await sequencer.TestPointAsync(TickGeneratorSequencer.RegisterStatus); Assert.AreEqual(TickGeneratorStatus.Operating, rStatus.ProductionArg); var rActiveProcesing = await sequencer.TestPointAsync(TickGeneratorSequencer.RegisterActiveProcessing); Assert.AreEqual(false, rActiveProcesing.ProductionArg); var processing = await sequencer.TestPointAsync(TickGeneratorSequencer.Processing); var processingResult = (TickGenerator.ProcessingResult)processing.ProductionArg; Assert.AreEqual(TickGenerator.ProcessingResult.Processed, processingResult); var exclusiveProcessing = await sequencer.TestPointAsync(TickGeneratorSequencer.ExclusiveProcessing); exclusiveProcessing.Complete(); var beginActiveProcessing = await sequencer.TestPointAsync(TickGeneratorSequencer.BeginActiveProcessing); beginActiveProcessing.Complete(); var actionProcessing = await sequencer.TestPointAsync(TickGeneratorSequencer.ActionsProcessing); actionProcessing.Complete(); Assert.AreEqual(false, actionProcessing.ProductionArg); var updateTimerBegin = await sequencer.TestPointAsync(TickGeneratorSequencer.TryUpdateTimerBegin); updateTimerBegin.Complete(); Assert.AreEqual(TickGeneratorTimerStatus.None, updateTimerBegin.ProductionArg); var updateTimerEnd = await sequencer.TestPointAsync(TickGeneratorSequencer.TryUpdateTimerEnd); updateTimerEnd.Complete(); Assert.AreEqual(TickGeneratorTimerStatus.Activate | TickGeneratorTimerStatus.IsActive | TickGeneratorTimerStatus.Changed, updateTimerEnd.ProductionArg); var endActiveProcessing = await sequencer.TestPointAsync(TickGeneratorSequencer.EndActiveProcessing); endActiveProcessing.Complete(); Assert.AreEqual(TickGeneratorStatus.Operating, endActiveProcessing.ProductionArg); Task t = await tt; Assert.IsTrue(t.IsCompleted); Assert.IsFalse(t.IsCanceled); Assert.IsFalse(t.IsFaulted); for (int i = 0; i < 10; i++) { var callBackProcessing = await sequencer.TestPointAsync(TickGeneratorSequencer.CallBackProcessing); callBackProcessing.Complete(); var processingCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.Processing); var processingCycleResult = (TickGenerator.ProcessingResult)processingCycle.ProductionArg; Assert.AreEqual(TickGenerator.ProcessingResult.Processed, processingCycleResult); var exclusiveProcessingCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.ExclusiveProcessing); exclusiveProcessingCycle.Complete(); var beginActiveProcessingCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.BeginActiveProcessing); beginActiveProcessingCycle.Complete(); var actionProcessingCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.ActionsProcessing); actionProcessingCycle.Complete(); Assert.AreEqual(true, actionProcessingCycle.ProductionArg); var actionProcessingCountCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.ActionsProcessingCount); Assert.AreEqual(1, actionProcessingCountCycle.ProductionArg); for (int j = 0; j < (int)actionProcessingCountCycle.ProductionArg; j++) { await sequencer.TestPointAsync(Steps.Notify); } var updateTimerBeginCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.TryUpdateTimerBegin); updateTimerBeginCycle.Complete(); Assert.AreEqual(TickGeneratorTimerStatus.IsActive, updateTimerBeginCycle.ProductionArg); var updateTimerEndCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.TryUpdateTimerEnd); updateTimerEndCycle.Complete(); Assert.AreEqual(TickGeneratorTimerStatus.Activate | TickGeneratorTimerStatus.IsActive, updateTimerEndCycle.ProductionArg); var endActiveProcessingCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.EndActiveProcessing); endActiveProcessingCycle.Complete(); Assert.AreEqual(TickGeneratorStatus.Operating, endActiveProcessingCycle.ProductionArg); } for (int i = 0; i < 1; i++) { var callBackProcessing = await sequencer.TestPointAsync(TickGeneratorSequencer.CallBackProcessing); callBackProcessing.Complete(); var processingCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.Processing); var processingCycleResult = (TickGenerator.ProcessingResult)processingCycle.ProductionArg; Assert.AreEqual(TickGenerator.ProcessingResult.Processed, processingCycleResult); var exclusiveProcessingCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.ExclusiveProcessing); exclusiveProcessingCycle.Complete(); var beginActiveProcessingCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.BeginActiveProcessing); beginActiveProcessingCycle.Complete(); //ActiveProcessing tt = Task.Run(() => tickGenerator.UnRegisterAsync(action).WrapIntoTask()); var rStatusCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.UnRegisterStatus); Assert.AreEqual(TickGeneratorStatus.Operating, rStatusCycle.ProductionArg); var rActiveProcesingCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.UnRegisterActiveProcessing); Assert.AreEqual(true, rActiveProcesingCycle.ProductionArg); var actionProcessingCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.ActionsProcessing); actionProcessingCycle.Complete(); Assert.AreEqual(true, actionProcessingCycle.ProductionArg); var actionProcessingCountCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.ActionsProcessingCount); Assert.AreEqual(1, actionProcessingCountCycle.ProductionArg); for (int j = 0; j < (int)actionProcessingCountCycle.ProductionArg; j++) { await sequencer.TestPointAsync(Steps.Notify); } var updateTimerBeginCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.TryUpdateTimerBegin); updateTimerBeginCycle.Complete(); Assert.AreEqual(TickGeneratorTimerStatus.IsActive, updateTimerBeginCycle.ProductionArg); var updateTimerEndCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.TryUpdateTimerEnd); updateTimerEndCycle.Complete(); Assert.AreEqual(TickGeneratorTimerStatus.Changed, updateTimerEndCycle.ProductionArg); var endActiveProcessingCycle = await sequencer.TestPointAsync(TickGeneratorSequencer.EndActiveProcessing); endActiveProcessingCycle.Complete(); Assert.AreEqual(TickGeneratorStatus.Operating, endActiveProcessingCycle.ProductionArg); } t = await tt; Assert.IsTrue(t.IsCompleted); Assert.IsFalse(t.IsCanceled); Assert.IsFalse(t.IsFaulted); await sequencer.WhenAll(); sequencer.TryReThrowException(); }