public void AccountMinimalRunWithTask() { bool bugfound = false; while (!bugfound) { NekaraManagedClient nekara = RuntimeEnvironment.Client; nekara.Api.CreateSession(); nekara.Api.Attach(); bool flag1 = nekara.Api.IsDetached(); balance = 0; var t1 = Task.Run(() => TransactWithApi(100)); var t2 = Task.Run(() => TransactWithApi(200)); Task.WaitAll(t1, t2); nekara.Api.WaitForMainTask(); if (balance != 300) { bugfound = true; } nekara.Api.Detach(); } // nekara.Api.Assert(balance == 300, $"Bug Found! Balance does not equal 300 - it is {balance}"); }
public void RunMultipleBlocking() { NekaraManagedClient nekara = RuntimeEnvironment.Client; nekara.Api.CreateSession(); nekara.Api.CreateTask(); nekara.Api.CreateResource(1000); var t1 = Task.Run(() => FooInstrumented(1)); nekara.Api.CreateTask(); nekara.Api.CreateResource(2000); var t2 = Task.Run(() => FooInstrumented(2)); nekara.Api.CreateTask(); nekara.Api.CreateResource(3000); var t3 = Task.Run(() => FooInstrumented(3)); if (t1.Status != TaskStatus.RanToCompletion) { nekara.Api.BlockedOnResource(1000); } if (t2.Status != TaskStatus.RanToCompletion) { nekara.Api.BlockedOnResource(2000); } if (t3.Status != TaskStatus.RanToCompletion) { nekara.Api.BlockedOnResource(3000); } Task.WaitAll(t1, t2, t3); nekara.Api.WaitForMainTask(); }
public void TestWaitAllWithTwoParallelAsynchronousTaskResults() { NekaraManagedClient nekara = RuntimeEnvironment.Client; nekara.Api.CreateSession(); Task <int> task1 = Task.Run(async() => { return(await GetWriteResultWithDelayAsync(5)); }); Task <int> task2 = Task.Run(async() => { return(await GetWriteResultWithDelayAsync(3)); }); Task.WaitAll(task1, task2); nekara.Api.WaitForMainTask(); // nekara.Api.Assert(task1.IsCompleted && task2.IsCompleted, "At least one task has not completed."); // nekara.Api.Assert(task1.Result == 5 && task2.Result == 3, "Found unexpected value."); Assert.True(task1.IsCompleted && task2.IsCompleted); Assert.True(task1.Result == 5 && task2.Result == 3); }
public Task RunBluetoothDriver() { NekaraManagedClient nekara = RuntimeEnvironment.Client; DeviceExtension e = new DeviceExtension { PendingIo = 1, StoppingFlag = false, StoppingEvent = false }; this.Lock = new Lock(1); this.Stopped = false; var mt = Task.Run(() => { nekara.Api.ContextSwitch(); e.StoppingFlag = true; BCSP_IoDecrement(e); nekara.Api.ContextSwitch(); if (e.StoppingEvent) { // Release allocated resource. nekara.Api.ContextSwitch(); this.Stopped = true; } }); BCSP_PnpAdd(e); return(mt); }
public Task RunNekaraTask() { NekaraManagedClient nekara = RuntimeEnvironment.Client; bugfound = false; while (!bugfound) { nekara.Api.CreateSession(); var tasks = Dine(N); var all = Task.WhenAll(tasks); all.ContinueWith(prev => { nekara.Api.Assert(phil == N, $"Bug found! Only {phil} philosophers ate"); }); all.Wait(); System.Threading.Tasks.Task.Run(() => nekara.Api.WaitForMainTask()).Wait(); if (bugfound) { return(all); } } return(new Task()); }
public void Run3() { NekaraManagedClient nekara = RuntimeEnvironment.Client; bugfound = false; while (!bugfound) { N = 3; nekara.Api.CreateSession(); temp1 = new int[N]; blkresourceID = new HashSet <int>(); var tasks = Dine(N); var all = Task.WhenAll(tasks); all.ContinueWith(prev => { // nekara.Api.Assert(phil == N, $"Bug found! Only {phil} philosophers ate"); Assert.True(phil == N); }); all.Wait(); System.Threading.Tasks.Task.Run(() => nekara.Api.WaitForMainTask()).Wait(); } return; }
public int Bar() { NekaraManagedClient nekara = RuntimeEnvironment.Client; nekara.Api.ContextSwitch(); return(1); }
static void Foo() { NekaraManagedClient nekara = RuntimeEnvironment.Client; nekara.Api.StartTask(1); Console.WriteLine("Foo/Acquire()"); lck.Acquire(); Console.WriteLine("Foo/ContextSwitch()"); nekara.Api.ContextSwitch(); int lx1 = x; Console.WriteLine("Foo/ContextSwitch()"); nekara.Api.ContextSwitch(); int lx2 = x; Console.WriteLine("Foo/Release()"); lck.Release(); // nekara.Api.Assert(lx1 == lx2, "Race!"); if (!(lx1 == lx2)) { bugfound = true; } Console.WriteLine("Foo EndTask"); nekara.Api.EndTask(1); }
internal void Acquire(int taskId) { NekaraManagedClient nekara = RuntimeEnvironment.Client; Console.WriteLine("Task {0}: Acquire()", taskId); nekara.Api.ContextSwitch(); while (true) { if (lck == false) { //nekara.ContextSwitch(); lck = true; Console.WriteLine("Task {0}: Inside Acquire, critical path - lock value: {1}", taskId, lck); //nekara.ContextSwitch(); break; } else { //nekara.ContextSwitch(); Console.WriteLine("Task {0}: Inside Acquire, blocked on the lock - lock value: {1}", taskId, lck); nekara.Api.BlockedOnResource(0); //nekara.ContextSwitch(); continue; } } }
public void TestWaitAllWithTwoParallelTasks() { NekaraManagedClient nekara = RuntimeEnvironment.Client; nekara.Api.CreateSession(); SharedEntry entry = new SharedEntry(); Task task1 = Task.Run(async() => { await WriteAsync(entry, 3); }); Task task2 = Task.Run(async() => { await WriteAsync(entry, 5); }); Task.WaitAll(task1, task2); nekara.Api.WaitForMainTask(); // nekara.Api.Assert(task1.IsCompleted && task2.IsCompleted, "At least one task has not completed."); // nekara.Api.Assert(entry.Value == 5 || entry.Value == 3, "Found unexpected value."); Assert.True(task1.IsCompleted && task2.IsCompleted); Assert.True(entry.Value == 5 || entry.Value == 3); }
public DeadlockWithNekaraLockAndAsync() { this.nekara = RuntimeEnvironment.Client; this.nekara.Api.CreateSession(); this.lck = new Nekara.Models.Lock(0); this.bugFound = false; this.x = 0; }
internal void Acquire(bool flag, int rid) { NekaraManagedClient nekara = RuntimeEnvironment.Client; Console.WriteLine("Acquire()"); nekara.Api.ContextSwitch(); if (rid == 0) { while (true) { if (!flag) { if (lck1) { bugFoundDl = true; break; } } if (lck1 == false) { lck1 = true; break; } else { nekara.Api.BlockedOnResource(rid); continue; } } } else { if (flag) { if (lck2) { bugFoundDl = true; return; } } while (true) { if (lck2 == false) { lck2 = true; break; } else { nekara.Api.BlockedOnResource(rid); continue; } } } }
internal Lock(int resourceId, string label = "") { NekaraManagedClient nekara = RuntimeEnvironment.Client; this.id = resourceId; this.locked = false; nekara.Api.CreateResource(resourceId); }
void TransactWithApi(int amount) { NekaraManagedClient nekara = RuntimeEnvironment.Client; int current = balance; nekara.Api.ContextSwitch(); balance = current + amount; }
public void RunOneControlled() { NekaraManagedClient nekara = RuntimeEnvironment.Client; nekara.Api.CreateSession(); var t1 = Nekara.Models.Task.Run(() => Foo()); nekara.Api.WaitForMainTask(); }
public void RunOneControlledGeneric() { NekaraManagedClient nekara = RuntimeEnvironment.Client; nekara.Api.CreateSession(); var t1 = Nekara.Models.Task <int> .Run(Bar); nekara.Api.WaitForMainTask(); }
internal void PerformReorder(int numSTasks, int numCTasks) { bool bugfound = false; while (!bugfound) { NekaraManagedClient nekara = RuntimeEnvironment.Client; nekara.Api.CreateSession(); int numSetTasks = numSTasks; int numCheckTasks = numCTasks; int a = 0; int b = 0; Task[] setPool = new Task[numSetTasks]; Task[] checkPool = new Task[numCheckTasks]; for (int i = 0; i < numSetTasks; i++) { setPool[i] = Task.Run(() => { nekara.Api.ContextSwitch(); a = 1; nekara.Api.ContextSwitch(); b = -1; }); } for (int i = 0; i < numCheckTasks; i++) { checkPool[i] = Task.Run(() => { nekara.Api.ContextSwitch(); int localA = a; nekara.Api.ContextSwitch(); int localB = b; // nekara.Assert((localA == 0 && localB == 0) || (localA == 1 && localB == -1), "Bug found!"); if (!((localA == 0 && localB == 0) || (localA == 1 && localB == -1))) { bugfound = true; } }); } Task.WaitAll(setPool); Task.WaitAll(checkPool); nekara.Api.WaitForMainTask(); } Assert.True(bugfound); }
public Task RunCircularBuffer() { NekaraManagedClient nekara = RuntimeEnvironment.Client; this.Buffer = new char[10]; this.BufferSize = 10; this.First = 0; this.Next = 0; this.Send = true; this.Receive = false; int n = 7; var l = new Lock(1); Task t1 = Task.Run(() => { for (int i = 0; i < n; i++) { nekara.Api.ContextSwitch(); using (l.Acquire()) { if (this.Send) { InsertLogElement(i); this.Send = false; this.Receive = true; } } } }); Task t2 = Task.Run(() => { for (int i = 0; i < n; i++) { nekara.Api.ContextSwitch(); using (l.Acquire()) { if (this.Receive) { // nekara.Assert(RemoveLogElement() == i, "Bug found!"); if (!(RemoveLogElement() == i)) { bugFoundCircularBuffer = true; } this.Receive = false; this.Send = true; } } } }); return(Task.WhenAll(t1, t2)); }
public Releaser Acquire(int id) { NekaraManagedClient nekara = RuntimeEnvironment.Client; nekara.Api.ContextSwitch(); while (true) { if (this.locked == false) { this.locked = true; break; } else { int blocked_tasks = 0; int live_tasks = 0; for (int i = 0; i < N; i++) { if (temp1[i] == 0) { live_tasks++; } else if (temp1[i] == 1) { blocked_tasks++; } } if (blocked_tasks > 0 && live_tasks == 1) { bugfound = true; foreach (int j in blkresourceID) { nekara.Api.SignalUpdatedResource(j); } break; } else { temp1[id] = 1; } if (bugfound) { break; } blkresourceID.Add(this.id); nekara.Api.BlockedOnResource(this.id); continue; } } return(new Releaser(this)); }
public void RunOne() { NekaraManagedClient nekara = RuntimeEnvironment.Client; nekara.Api.CreateSession(); nekara.Api.CreateTask(); nekara.Api.CreateResource(1000); var t1 = Task.Run(() => FooInstrumented()); nekara.Api.WaitForMainTask(); }
public void CircularBuffer() { while (!bugFoundCircularBuffer) { NekaraManagedClient nekara = RuntimeEnvironment.Client; nekara.Api.CreateSession(); RunCircularBuffer().Wait(); nekara.Api.WaitForMainTask(); } }
public void RunFive() { NekaraManagedClient nekara = RuntimeEnvironment.Client; nekara.Api.CreateSession(); nekara.Api.CreateResource(0); lck = false; Enumerable.Range(1, 5).ToList().ForEach(i => Nekara.Models.Task.Run(() => LockContender(i))); nekara.Api.WaitForMainTask(); }
public static void TestCompletedTask() { NekaraManagedClient nekara = RuntimeEnvironment.Client; nekara.Api.CreateSession(); Task task = Task.CompletedTask; nekara.Api.WaitForMainTask(); // nekara.Api.Assert(task.IsCompleted, "The task has not completed."); Assert.True(task.IsCompleted); }
public void BluetoothDriver() { while (!bugFoundBluetoothDriver) { NekaraManagedClient nekara = RuntimeEnvironment.Client; nekara.Api.CreateSession(); RunBluetoothDriver().Wait(); nekara.Api.WaitForMainTask(); } }
public static void TestCanceledTask() { NekaraManagedClient nekara = RuntimeEnvironment.Client; nekara.Api.CreateSession(); CancellationToken token = new CancellationToken(true); Task task = Task.FromCanceled(token); nekara.Api.WaitForMainTask(); // nekara.Api.Assert(task.IsCanceled, "The task is not cancelled."); Assert.True(task.IsCanceled); }
internal void Release(int taskId) { NekaraManagedClient nekara = RuntimeEnvironment.Client; Console.WriteLine("Task {0}: Release()", taskId); nekara.Api.Assert(lck == true, "Release called on non-acquired lock"); //nekara.ContextSwitch(); lck = false; //nekara.ContextSwitch(); nekara.Api.SignalUpdatedResource(0); //nekara.ContextSwitch(); }
public void RunLazyTest() { bool bugfound = false; while (!bugfound) { NekaraManagedClient nekara = RuntimeEnvironment.Client; nekara.Api.CreateSession(); int data = 0; var l = new Lock(1); Task t1 = Task.Run(() => { nekara.Api.ContextSwitch(); using (l.Acquire()) { data++; } }); Task t2 = Task.Run(() => { nekara.Api.ContextSwitch(); using (l.Acquire()) { data += 2; } }); Task t3 = Task.Run(() => { nekara.Api.ContextSwitch(); using (l.Acquire()) { // nekara.Api.Assert(data < 3, "Bug found!"); if (!(data < 3)) { bugfound = true; } } }); Task.WaitAll(t1, t2, t3); nekara.Api.WaitForMainTask(); } Assert.True(bugfound); }
public void Release() { NekaraManagedClient nekara = RuntimeEnvironment.Client; if (!bugfound) { nekara.Api.Assert(this.locked == true, "Release called on non-acquired lock"); this.locked = false; blkresourceID.Remove(this.id); nekara.Api.SignalUpdatedResource(this.id); } }
static void Bar() { NekaraManagedClient nekara = RuntimeEnvironment.Client; nekara.Api.StartTask(2); //lck.Acquire(); nekara.Api.ContextSwitch(); x = 1; //lck.Release(); Console.WriteLine("Bar EndTask"); nekara.Api.EndTask(2); }
internal void FooInstrumented(int taskId = 1) { NekaraManagedClient nekara = RuntimeEnvironment.Client; nekara.Api.StartTask(taskId); //Console.WriteLine("FooInstrumented ContextSwitch"); nekara.Api.ContextSwitch(); //Console.WriteLine("FooInstrumented ContextSwitch"); nekara.Api.ContextSwitch(); //Console.WriteLine("FooInstrumented ContextSwitch"); nekara.Api.ContextSwitch(); nekara.Api.SignalUpdatedResource(taskId * 1000); nekara.Api.DeleteResource(taskId * 1000); nekara.Api.EndTask(taskId); }