add test_aco_tutorial_7.c to test and examplify aco_yield_to()

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
 

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
 '''

test_aco_tutorial_7.c

@@ -0,0 +1,126 @@
+// Copyright 2018 Sen Han <[email protected]>
+//
+// 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;
+}