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