test_aco_tutorial_0.c

// 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.

// Hello aco demo.

#include "aco.h"    
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include "aco_assert_override.h"

void co_fp0() {
    // Get co->arg. The caller of `aco_get_arg()` must be a non-main co.
    int *iretp = (int *)aco_get_arg();
    // Get current co. The caller of `aco_get_co()` must be a non-main co.
    aco_t* this_co = aco_get_co();
    int ct = 0;
    while(ct < 6){
        printf(
            "co:%p save_stack:%p share_stack:%p yield_ct:%d\n",
            this_co, this_co->save_stack.ptr,
            this_co->share_stack->ptr, ct
        );
        // Yield the execution of current co and resume the execution of
        // `co->main_co`. The caller of `aco_yield()` must be a non-main co.
        aco_yield();
        (*iretp)++;
        ct++;
    }
    printf(
        "co:%p save_stack:%p share_stack:%p co_exit()\n",
        this_co, this_co->save_stack.ptr,
        this_co->share_stack->ptr
    );
    // In addition do the same as `aco_yield()`, `aco_exit()` also set 
    // `co->is_end` to `1` thus to mark the `co` at the status of "END".
    aco_exit();
}

int main() {
#ifdef ACO_USE_VALGRIND
    if(0){
        printf("%s doesn't have valgrind test yet, "
            "so bypass this test right now.\n",__FILE__
        );
        exit(0);
    }
#endif
    // Initialize the aco environment in the current thread.
    aco_thread_init(NULL);

    // Create a main coroutine whose "share stack" is the default stack 
    // of the current thread. And it doesn't need any private save stack 
    // since it is definitely a standalone coroutine (which coroutine 
    // monopolizes it's share stack).
    aco_t* main_co = aco_create(NULL, NULL, 0, NULL, NULL);

    // Create a share stack with the default size of 2MB and also with a 
    // read-only guard page for the detection of stack overflow.
    aco_share_stack_t* sstk = aco_share_stack_new(0);

    int co_ct_arg_point_to_me = 0;
    // Create a non-main coroutine whose share stack is `sstk` and has a
    // default 64 bytes size private save stack. The entry function of the 
    // coroutine is `co_fp0`. Set `co->arg` to the address of the int 
    // variable `co_ct_arg_point_to_me`.
    aco_t* co = aco_create(main_co, sstk, 0, co_fp0, &co_ct_arg_point_to_me);

    int ct = 0;
    while(ct < 6){
        assert(co->is_end == 0);
        // Start or continue the execution of `co`. The caller of this function
        // must be main_co.
        aco_resume(co);
        // Check whether the co has completed the job it promised.
        assert(co_ct_arg_point_to_me == ct);
        printf("main_co:%p\n", main_co);
        ct++;
    }
    aco_resume(co);
    assert(co_ct_arg_point_to_me == ct);
    // The value of `co->is_end` must be `1` now since it just suspended 
    // itself by calling `aco_exit()`.
    assert(co->is_end);

    printf("main_co:%p\n", main_co);

    // Destroy co and its private save stack.
    aco_destroy(co);
    co = NULL;
    // Destroy the share stack sstk.
    aco_share_stack_destroy(sstk);
    sstk = NULL;
    // Destroy the main_co.
    aco_destroy(main_co);
    main_co = NULL;

    return 0;
}