From 95a1567b89bd94fb198811895f5f254ae4c1ffca Mon Sep 17 00:00:00 2001
From: Michel Machado <michel@digirati.com.br>
Date: Thu, 24 Oct 2019 16:22:56 -0400
Subject: [PATCH] add test_aco_tutorial_7.c to test and examplify
 aco_yield_to()

---
 README.md             |   2 +-
 make.sh               |   1 +
 test_aco_tutorial_7.c | 126 ++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 128 insertions(+), 1 deletion(-)
 create mode 100644 test_aco_tutorial_7.c

diff --git a/README.md b/README.md
index 1da240e..5f61e3a 100644
--- a/README.md
+++ b/README.md
@@ -266,7 +266,7 @@ One of the rules in libaco is to call `aco_exit()` to terminate the execution of
 
 You could also define your own protector to substitute the default one (to do some customized "last words" stuff). But no matter in what case, the process will be aborted after the protector was executed. The `test_aco_tutorial_5.c` shows how to define the customized last word function.
 
-The last example is a simple coroutine scheduler in `test_aco_tutorial_6.c`.
+The example `test_aco_tutorial_6.c` is a simple coroutine scheduler. And the last example, namely `test_aco_tutorial_7.c`, is the same scheduler using `aco_yield_to`.
 
 # API
 
diff --git a/make.sh b/make.sh
index 82f81bc..7054d87 100644
--- a/make.sh
+++ b/make.sh
@@ -30,6 +30,7 @@ test_aco_tutorial_3 -lpthread
 test_aco_tutorial_4
 test_aco_tutorial_5
 test_aco_tutorial_6
+test_aco_tutorial_7
 test_aco_synopsis
 test_aco_benchmark
 '''
diff --git a/test_aco_tutorial_7.c b/test_aco_tutorial_7.c
new file mode 100644
index 0000000..a0281ef
--- /dev/null
+++ b/test_aco_tutorial_7.c
@@ -0,0 +1,126 @@
+// Copyright 2018 Sen Han <00hnes@gmail.com>
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// A pretty simple scheduler demo using aco_yield_to().
+
+#include "aco.h"    
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include "aco_assert_override.h"
+
+size_t curr_co_amount;
+size_t curr_co_index;
+aco_t** coarray;
+
+aco_t* next_co(){
+    assert(curr_co_amount > 0);
+    curr_co_index = (curr_co_index + 1) % curr_co_amount;
+    return coarray[curr_co_index];
+}
+
+void co_fp0(){
+    int ct = 0;
+    int loop_ct = (int)((uintptr_t)(aco_get_co()->arg));
+    if(loop_ct < 0){
+        loop_ct = 0;
+    }
+    while(ct < loop_ct){
+        aco_yield_to(next_co());
+        ct++;
+    }
+    aco_exit();
+}
+
+int main() {
+    aco_thread_init(NULL);
+
+    time_t seed_t = time(NULL);
+    assert((time_t)-1 != seed_t);
+    srand(seed_t);
+
+    size_t co_amount = 100;
+    curr_co_amount = co_amount;
+
+    // create co
+    assert(co_amount > 0);
+    aco_t* main_co = aco_create(NULL, NULL, 0, NULL, NULL);
+    aco_share_stack_t* sstk = aco_share_stack_new(0);
+    // NOTE: size_t_safe_mul
+    coarray = (aco_t**) malloc(sizeof(void*) * co_amount);
+    assertptr(coarray);
+    memset(coarray, 0, sizeof(void*) * co_amount);
+    size_t ct = 0;
+    while(ct < co_amount){
+#ifdef ACO_USE_VALGRIND
+        aco_share_stack_t* private_sstk = aco_share_stack_new2(
+            0, ct % 2
+        );
+        coarray[ct] = aco_create(
+            main_co, private_sstk, 0, co_fp0,
+            (void*)((uintptr_t)rand() % 1000)
+        );
+        private_sstk = NULL;
+#else
+        coarray[ct] = aco_create(
+            main_co, sstk, 0, co_fp0,
+            (void*)((uintptr_t)rand() % 1000)
+        );
+#endif
+        ct++;
+    }
+
+    // naive scheduler
+    printf("scheduler start: co_amount:%zu\n", co_amount);
+    aco_t* curr_co = coarray[curr_co_index];
+    while(curr_co_amount > 0){
+        aco_resume(curr_co);
+        // Update curr_co because aco_yield_to() may have changed it
+        curr_co = coarray[curr_co_index];
+        assert(curr_co->is_end != 0);
+        printf("aco_destroy: co:%zu\n", curr_co_index);
+        #ifdef ACO_USE_VALGRIND
+            aco_share_stack_t* private_sstk = curr_co->share_stack;
+        #endif
+        aco_destroy(curr_co);
+        #ifdef ACO_USE_VALGRIND
+            aco_share_stack_destroy(private_sstk);
+            private_sstk = NULL;
+        #endif
+        curr_co_amount--;
+        if(curr_co_index < curr_co_amount){
+            coarray[curr_co_index] = coarray[curr_co_amount];
+        }else{
+            curr_co_index = 0;
+        }
+        coarray[curr_co_amount] = NULL;
+        curr_co = coarray[curr_co_index];
+    }
+
+    // co cleaning
+    ct = 0;
+    while(ct < co_amount){
+        assert(coarray[ct] == NULL);
+        ct++;
+    }
+    aco_share_stack_destroy(sstk);
+    sstk = NULL;
+    aco_destroy(main_co);
+    main_co = NULL;
+    free(coarray);
+
+    printf("sheduler exit");
+    
+    return 0;
+}