public void CoroutineThreadIntShouldBeExecutedTheRightNumberOfCyclesByHundredsOfThings() { // ReSharper disable once ConvertToConstant.Local int cycleLength = 100; int coroutinesCount = 30; int runningTimeMs = 1000; var ft = new CoroutineThread(1); var fl = new List <WaitCoroutine>(); for (int i = 0; i < coroutinesCount; i++) { var fb = new WaitCoroutine(cycleLength); fl.Add(fb); ft.AddCoroutine(fb); } ft.Start(); Thread.Sleep(1000 + 100); ft.Stop(); Thread.Sleep(300); var total = 0; foreach (var fb in fl) { total += fb.Cycles; Console.WriteLine("Result: " + fb.Cycles); } Console.WriteLine("Total: " + total); Assert.IsTrue(total > 100, "Executed " + total); }
public void ShouldBeExecutedTheRightNumberOfCyclesDefaultThreads() { var threadContainer = new CoroutineThread(100); threadContainer.Start(); _reset = new ManualResetEvent(false); // ReSharper disable once ConvertToConstant.Local int hundred = 100; var first = new WaitCoroutine(hundred) { Thread = threadContainer }; var second = new WaitCoroutine(200) { Thread = threadContainer }; var firstt = new Thread(ExecuteTimerCoroutine); var secondt = new Thread(ExecuteTimerCoroutine); firstt.Start(first); secondt.Start(second); _reset.Set(); Thread.Sleep(1000); threadContainer.Stop(); Thread.Sleep(300); Assert.IsTrue((first.Cycles + second.Cycles) < 100); Console.WriteLine("First: " + first.Cycles); Console.WriteLine("Second: " + second.Cycles); }
public void CoroutineThreadIntShouldBePossibleToPauseAndRestart() { // ReSharper disable once ConvertToConstant.Local int hundred = 100; var ft = new CoroutineThread(1); var first = new WaitCoroutine(hundred); var second = new WaitCoroutine(200); ft.AddCoroutine(first, second); ft.Start(); Thread.Sleep(1000); ft.Pause(); Thread.Sleep(300); var firstCycles = first.Cycles; var secondCycles = second.Cycles; Assert.AreEqual(ft.Status, CoroutineThreadStatus.Paused); Thread.Sleep(1500); Assert.AreEqual(firstCycles, first.Cycles); Assert.AreEqual(secondCycles, second.Cycles); ft.Start(); Thread.Sleep(300); Assert.AreEqual(CoroutineThreadStatus.Running, ft.Status); ft.Stop(); Thread.Sleep(300); Assert.AreEqual(CoroutineThreadStatus.Stopped, ft.Status); Assert.IsTrue(firstCycles <= first.Cycles); Assert.IsTrue(secondCycles <= second.Cycles); }
/// <summary> /// Ticks all living coroutines, advancing time by the specified amount. /// </summary> /// <param name="elapsed">The time that has elapsed since the previous tick.</param> /// <returns>Whether any threads are still alive.</returns> public bool Tick(TimeSpan elapsed) { if (elapsed.Ticks < 0) throw new ArgumentOutOfRangeException(nameof(elapsed)); if (_executingThread != null) throw new InvalidOperationException("Recursive ticking not allowed"); _time += elapsed; for (int i = 0; i < _threads.Count; i++) { CoroutineThread thread = _threads[i]; _executingThread = thread; try { thread.Tick(elapsed); } finally { _executingThread = null; } } return _threads.Count != 0; }
public void StopCoroutine() { IsRunning = false; CoroutineThread.Change(Timeout.Infinite, 10); CoroutineTPSCalc.Change(Timeout.Infinite, 1000); GameApplication.Log(Utils.LogEntryType.Info, "Stopped coroutine: " + Name); }
public override void Initialize() { if (Children != null && Children.Count > 0 && _threads.Count <= 0) { foreach (var n in Children) { var thread = new CoroutineThread <Result>(n.Execute, false, 1); _threads.Add(thread); } } }
public void CoroutineIntItShouldBePossibleToDoOneLevelNesting() { var ft = new CoroutineThread(1); var co = new SingleNestedCoroutine(); ft.AddCoroutine(co); ft.Start(); Thread.Sleep(100); Assert.IsTrue(co.RunFinished); Assert.IsTrue(co.FirstCallFinished); ft.Stop(); }
internal void TerminateThread(CoroutineThread <Result> thread) { if (_providersMap.TryGetValue(thread, out var nodes)) { foreach (var node in nodes) { node.Terminate(); } nodes.Clear(); } _manager.TerminateThreadAndDependencies(thread); }
public void CoroutineThreadIntShouldBeExecutedTheRightNumberOfCycles() { var ft = new CoroutineThread(1); var first = new WaitCoroutine(100); var second = new WaitCoroutine(200); ft.AddCoroutine(first, second); ft.Start(); Thread.Sleep(1100); ft.Stop(); Thread.Sleep(300); Assert.IsTrue((first.Cycles + second.Cycles) >= 13, "Cycles were " + (first.Cycles + second.Cycles)); Console.WriteLine("First: " + first.Cycles); Console.WriteLine("Second: " + second.Cycles); }
public void CoroutineIntShouldCallTheCoroutine() { // ReSharper disable once ConvertToConstant.Local int hundred = 100; var ft = new CoroutineThread(1); var co = new CoroutineCallingLocal(); ft.AddCoroutine(co); ft.Start(); Thread.Sleep(100); ft.Stop(); Thread.Sleep(300); Assert.IsTrue(co.LocalCalled); Assert.IsTrue(co.LocalSetted); }
public void CoroutineIntShouldCallTheCoroutineWaitingForIt() { // ReSharper disable once ConvertToConstant.Local int hundred = 100; var ft = new CoroutineThread(1); var co = new LocalCoroutineWithWait(); ft.AddCoroutine(co); ft.Start(); Thread.Sleep(1000); ft.Stop(); Thread.Sleep(300); Assert.IsTrue(co.LocalCalled); Assert.IsTrue(co.LocalSetted); Assert.AreEqual(0, co.Counter); }
public void CoroutineIntShouldCallTheCoroutineWithData() { // ReSharper disable once ConvertToConstant.Local int hundred = 100; var data = new Exception(); var ft = new CoroutineThread(1); var co = new LocalCoroutineWithData(data); ft.AddCoroutine(co); ft.Start(); Thread.Sleep(1000); ft.Stop(); Thread.Sleep(300); Assert.IsTrue(co.LocalCalled); Assert.IsTrue(co.LocalSetted); Assert.AreEqual(data, co.Result); }
public void CoroutineThreadIntShouldHandleCorrectlyTheSubroutines() { // ReSharper disable once ConvertToConstant.Local int hundred = 100; var ft = new CoroutineThread(1); var first = new CoroutineWithSub(hundred); var second = new CoroutineWithSub(200); ft.AddCoroutine(first); //, second); ft.Start(); Thread.Sleep(1000); ft.Stop(); Thread.Sleep(300); //Assert.AreEqual(15, (int)(first.Cycles + second.Cycles)); Console.WriteLine("First: " + first.Cycles); Console.WriteLine("Second: " + second.Cycles); }
public void ShouldBeExecutedTheRightNumberOfCyclesByHundredsOfThingsDefaultThreads() { // ReSharper disable once ConvertToConstant.Local int hundred = 100; _reset = new ManualResetEvent(false); var threadContainer = new CoroutineThread(100); threadContainer.Start(); var fl = new List <WaitCoroutine>(); for (int i = 0; i < MULTIPLE_COUNT; i++) { var fb = new WaitCoroutine(hundred) { Thread = threadContainer }; fl.Add(fb); var flt = new Thread(ExecuteTimerCoroutine); flt.Start(fb); } _reset.Set(); Thread.Sleep(1000); threadContainer.Stop(); Thread.Sleep(300); var total = 0; foreach (var fb in fl) { total += fb.Cycles; Console.WriteLine("Result: " + fb.Cycles); } Console.WriteLine("Total: " + total); Assert.IsTrue(total < 100); }
internal void ProcessThread(CoroutineThread <Result> thread) { _manager.ProcessThread(thread); }
// ReSharper disable once RedundantAssignment public override CoroutineActionBehavior Process(CoroutineThread thread, ref IEnumerable cor) { cor = thread.Executor.Delay(_time); _time = default(TimeSpan); return CoroutineActionBehavior.Push; }
public override CoroutineActionBehavior Process(CoroutineThread thread, ref IEnumerable cor) { thread.SetResult(_value); _value = null; return CoroutineActionBehavior.Pop; }
/// <summary> /// Executes a coroutine in a new thread. /// </summary> /// <param name="cor">An enumerable object that can provide a coroutine.</param> public CoroutineThread Start(IEnumerable cor) { if (cor == null) throw new ArgumentNullException(nameof(cor)); var thread = new CoroutineThread(this, cor); _threads.Add(thread); return thread; }
private static IEnumerable ParallelImpl(CoroutineThread[] threads) { while (true) { { bool allFinished = true; // ReSharper disable once ForCanBeConvertedToForeach for (int i = 0; i < threads.Length; i++) { if (threads[i].Status == CoroutineThreadStatus.Faulted) yield break; if (threads[i].Status != CoroutineThreadStatus.Finished) allFinished = false; } if (allFinished) yield break; } yield return null; } }
internal void OnThreadDisposed(CoroutineThread thread) { _threads.Remove(thread); }
// ReSharper disable once RedundantAssignment public override CoroutineActionBehavior Process(CoroutineThread thread, ref IEnumerable cor) { cor = thread.Executor.Parallel(_enumerables); _enumerables = null; return CoroutineActionBehavior.Push; }
/// <summary> /// Gets the next coroutine to be pushed onto the thread's stack. If null, yield until the next tick. /// </summary> /// <param name="thread">The current thread.</param> /// <param name="cor">A coroutine to push if the behavior is Push.</param> /// <returns>The behavior of the action.</returns> public abstract CoroutineActionBehavior Process(CoroutineThread thread, ref IEnumerable cor);
internal void ProcessThreadAsDependency(CoroutineThread <Result> thread) { _manager.ProcessThreadAsDependency(thread); }