namespace MonoTests.System
{
[TestFixture]
- public class ContinuationsTest {
-
- private Continuation _contA = new Continuation();
-
- private int total = 0;
-
- [Test]
- public void TestContinuationsLoop() {
- _contA.Mark();
- int value = 0;
- int ret = _contA.Store(0);
- for(int i = ret; i < 10; i++) {
- value += i;
- }
-
- if(value > 0) {
- total += value;
- _contA.Restore(ret + 1);
- }
-
- Assert.AreEqual(total,330);
- }
-
- private int yields = 0;
-
- [Test]
- public void Yielding() {
- Continuation baseCont = new Continuation();
- Continuation taskCont = new Continuation();
-
- baseCont.Mark();
- taskCont.Mark();
-
- // Store the base continuation to start the task
- if (baseCont.Store(0) == 0) {
- bool done = false;
- int count = 0;
-
- while (!done) {
- // Do stuff for the task.
- ++count;
-
- // This task is counting to 100.
- if (count == 100) {
- done = true;
- }
-
- // Yield every 10 loops
- else if (count % 10 == 0) {
-
- // To yield, store the task continuation then restore
- // the base continuation.
- if (taskCont.Store(0) == 0) {
- baseCont.Restore(1);
- }
- }
- }
- }
- // When restored, 'Store' will return what was passed to Restore, in this case 1 so fall here.
- else {
- // Count the yields, then go back to the task.
- ++yields;
- taskCont.Restore(1);
- }
-
- Assert.AreEqual(9, yields);
- }
-
-
- public class MicroThread {
-
- public void Yield() {
- if (MyThread.Store(0) == 0) {
- MainThread.Restore(1);
- }
- }
-
- public void Resume() {
- if (MainThread.Store(0) == 0) {
- MyThread.Restore(1);
- }
- }
-
- public void DoWork(Action action) {
- if (MainThread.Store(0) == 0) {
- action();
- Done = true;
- MainThread.Restore(1);
- }
- }
-
- public bool Done = false;
- public Continuation MainThread = new Continuation();
- public Continuation MyThread = new Continuation();
- }
-
- public class MicroBJob {
- private int _Count = 0;
- public int Count {
- get { return _Count; }
- set { _Count = value;}
- }
-
- public MicroThread MicroThread;
- public void Work() {
- while (Count < 100) {
- ++Count;
- if (Count % 10 == 0) {
- MicroThread.Yield();
- }
- }
- }
- }
-
- [Test]
- public void MicroThreadTest() {
- MicroThread microA = new MicroThread();
- MicroThread microB = new MicroThread();
-
- microA.MainThread.Mark();
- microA.MyThread.Mark();
- microB.MainThread.Mark();
- microB.MyThread.Mark();
-
- Assert.AreEqual(false,microA.Done);
- Assert.AreEqual(false,microB.Done);
-
- microA.DoWork( () => {
- int count = 0;
- while (count < 100) {
- ++count;
- if (count % 10 == 0) {
- microA.Yield();
- }
- }
- });
-
- MicroBJob jobB = new MicroBJob();
- jobB.MicroThread = microB;
-
- microB.DoWork(jobB.Work);
-
- Assert.AreEqual(false,microA.Done);
- Assert.AreEqual(false,microB.Done);
-
- int yields = 0;
- while (yields < 20) {
- if (!microA.Done) microA.Resume();
- if (!microB.Done) microB.Resume();
- if (microA.Done && microB.Done) break;
- ++yields;
- }
-
- Assert.AreEqual(true,microA.Done);
- Assert.AreEqual(true,microB.Done);
- Assert.AreEqual(100,jobB.Count);
- Assert.AreEqual(9,yields);
- }
- }
+ public class ContinuationsTest
+ {
+ [TestFixtureSetUp]
+ public void FixtureSetUp ()
+ {
+ try {
+ var temp = new Continuation ();
+ } catch (NotImplementedException) {
+ Assert.Ignore ("This platform doesn't support Tasklets.");
+ }
+ }
+
+ int total = 0;
+
+ [Test]
+ public void TestContinuationsLoop()
+ {
+ Continuation _contA = new Continuation();
+
+ _contA.Mark();
+ int value = 0;
+ int ret = _contA.Store(0);
+ for (int i = ret; i < 10; i++) {
+ value += i;
+ }
+
+ if (value > 0) {
+ total += value;
+ _contA.Restore(ret + 1);
+ }
+
+ Assert.AreEqual(total, 330);
+ }
+
+ private int yields = 0;
+
+ [Test]
+ public void Yielding()
+ {
+ Continuation baseCont = new Continuation();
+ Continuation taskCont = new Continuation();
+
+ baseCont.Mark();
+ taskCont.Mark();
+
+ // Store the base continuation to start the task
+ if (baseCont.Store(0) == 0) {
+ bool done = false;
+ int count = 0;
+
+ while (!done) {
+ // Do stuff for the task.
+ ++count;
+
+ // This task is counting to 100.
+ if (count == 100) {
+ done = true;
+ }
+
+ // Yield every 10 loops
+ else if (count % 10 == 0) {
+
+ // To yield, store the task continuation then restore
+ // the base continuation.
+ if (taskCont.Store(0) == 0) {
+ baseCont.Restore(1);
+ }
+ }
+ }
+ }
+ // When restored, 'Store' will return what was passed to Restore, in this case 1 so fall here.
+ else {
+ // Count the yields, then go back to the task.
+ ++yields;
+ taskCont.Restore(1);
+ }
+
+ Assert.AreEqual(9, yields);
+ }
+
+
+ public class MicroThread
+ {
+
+ public void Yield()
+ {
+ if (MyThread.Store(0) == 0) {
+ MainThread.Restore(1);
+ }
+ }
+
+ public void Resume()
+ {
+ if (MainThread.Store(0) == 0) {
+ MyThread.Restore(1);
+ }
+ }
+
+ public void DoWork(Action action)
+ {
+ if (MainThread.Store(0) == 0) {
+ action();
+ Done = true;
+ MainThread.Restore(1);
+ }
+ }
+
+ public bool Done = false;
+ public Continuation MainThread = new Continuation();
+ public Continuation MyThread = new Continuation();
+ }
+
+ public class MicroBJob
+ {
+ private int _Count = 0;
+ public int Count
+ {
+ get { return _Count; }
+ set { _Count = value; }
+ }
+
+ public MicroThread MicroThread;
+ public void Work()
+ {
+ while (Count < 100) {
+ ++Count;
+ if (Count % 10 == 0) {
+ MicroThread.Yield();
+ }
+ }
+ }
+ }
+
+ [Test]
+ public void MicroThreadTest()
+ {
+ MicroThread microA = new MicroThread();
+ MicroThread microB = new MicroThread();
+
+ microA.MainThread.Mark();
+ microA.MyThread.Mark();
+ microB.MainThread.Mark();
+ microB.MyThread.Mark();
+
+ Assert.AreEqual(false, microA.Done);
+ Assert.AreEqual(false, microB.Done);
+
+ microA.DoWork(() =>
+ {
+ int count = 0;
+ while (count < 100) {
+ ++count;
+ if (count % 10 == 0) {
+ microA.Yield();
+ }
+ }
+ });
+
+ MicroBJob jobB = new MicroBJob();
+ jobB.MicroThread = microB;
+
+ microB.DoWork(jobB.Work);
+
+ Assert.AreEqual(false, microA.Done);
+ Assert.AreEqual(false, microB.Done);
+
+ int yields = 0;
+ while (yields < 20) {
+ if (!microA.Done) microA.Resume();
+ if (!microB.Done) microB.Resume();
+ if (microA.Done && microB.Done) break;
+ ++yields;
+ }
+
+ Assert.AreEqual(true, microA.Done);
+ Assert.AreEqual(true, microB.Done);
+ Assert.AreEqual(100, jobB.Count);
+ Assert.AreEqual(9, yields);
+ }
+ }
}
-
-// vim: noexpandtab
-// Local Variables:
-// tab-width: 4
-// c-basic-offset: 4
-// indent-tabs-mode: t
-// End:
mono_tasklets_cleanup (void)
{
}
+#else
+static
+void continuations_not_supported (void)
+{
+ mono_set_pending_exception (mono_get_exception_not_implemented ("Tasklets are not implemented on this platform."));
+}
+
+static void*
+continuation_alloc (void)
+{
+ continuations_not_supported ();
+ return NULL;
+}
+
+static void
+continuation_free (MonoContinuation *cont)
+{
+ continuations_not_supported ();
+}
+
+static MonoException*
+continuation_mark_frame (MonoContinuation *cont)
+{
+ continuations_not_supported ();
+ return NULL;
+}
+
+static int
+continuation_store (MonoContinuation *cont, int state, MonoException **e)
+{
+ continuations_not_supported ();
+ return 0;
+}
+
+static MonoException*
+continuation_restore (MonoContinuation *cont, int state)
+{
+ continuations_not_supported ();
+ return NULL;
+}
+
+void
+mono_tasklets_init(void)
+{
+ mono_add_internal_call ("Mono.Tasklets.Continuation::alloc", continuation_alloc);
+ mono_add_internal_call ("Mono.Tasklets.Continuation::free", continuation_free);
+ mono_add_internal_call ("Mono.Tasklets.Continuation::mark", continuation_mark_frame);
+ mono_add_internal_call ("Mono.Tasklets.Continuation::store", continuation_store);
+ mono_add_internal_call ("Mono.Tasklets.Continuation::restore", continuation_restore);
+
+}
#endif
projects / mono.git / commitdiff