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

// Use aco in multithread.

#include "aco.h"

#include <stdlib.h>

#include <stdio.h>

#include <unistd.h>

#include <pthread.h>

#include <inttypes.h>

#include "aco_assert_override.h"

uint64_t gl_race_aco_yield_ct = 0;

pthread_mutex_t gl_race_aco_yield_ct_mutex = PTHREAD_MUTEX_INITIALIZER;

void foo(int ct){

printf(

"co:%p save_stack:%p share_stack:%p yield_ct:%d\n",

aco_get_co(), aco_get_co()->save_stack.ptr,

aco_get_co()->share_stack->ptr, ct

);

pthread_mutex_lock(&gl_race_aco_yield_ct_mutex);

gl_race_aco_yield_ct++;

pthread_mutex_unlock(&gl_race_aco_yield_ct_mutex);

aco_yield();

(*((int*)(aco_get_arg())))++;

}

void co_fp0()

{

aco_t* this_co = aco_get_co();

assert(!aco_is_main_co(this_co));

assert(this_co->fp == (void*)co_fp0);

assert(this_co->is_end == 0);

int ct = 0;

while(ct < 6){

foo(ct);

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

);

pthread_mutex_lock(&gl_race_aco_yield_ct_mutex);

gl_race_aco_yield_ct++;

pthread_mutex_unlock(&gl_race_aco_yield_ct_mutex);

aco_exit();

assert(0);

}

void* pmain(void* pthread_in_arg) {

pthread_t t = pthread_self();

size_t idx = 0;

assert(sizeof(t) > 0);

printf("\ntid:0x");

while(idx < sizeof(t)){

printf("%02x", *(((uint8_t*)(&t)) + idx));

idx++;

}

printf("\n");

aco_thread_init(NULL);

aco_t* main_co = aco_create(NULL, NULL, 0, NULL, NULL);

assertptr(main_co);

aco_share_stack_t* sstk = aco_share_stack_new(0);

assertptr(sstk);

aco_share_stack_t* sstk2 = aco_share_stack_new(0);

assertptr(sstk2);

int co_ct_arg_point_to_me = 0;

int co2_ct_arg_point_to_me = 0;

int co3_ct_arg_point_to_me = 0;

aco_t* co = aco_create(main_co, sstk, 0, co_fp0, &co_ct_arg_point_to_me);

assertptr(co);

aco_t* co2 = aco_create(main_co, sstk2, 0, co_fp0, &co2_ct_arg_point_to_me);

aco_t* co3 = aco_create(main_co, sstk2, 0, co_fp0, &co3_ct_arg_point_to_me);

assertptr(co2);

assertptr(co3);

int ct = 0;

while(ct < 6){

assert(co->is_end == 0);

aco_resume(co);

assert(co_ct_arg_point_to_me == ct);

assert(co2->is_end == 0);

aco_resume(co2);

assert(co2_ct_arg_point_to_me == ct);

assert(co3->is_end == 0);

aco_resume(co3);

assert(co3_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);

assert(co->is_end);

aco_resume(co2);

assert(co2_ct_arg_point_to_me == ct);

assert(co2->is_end);

aco_resume(co3);

assert(co3_ct_arg_point_to_me == ct);

assert(co3->is_end);

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

printf(

"\ncopy-stack co:%p:\n max stack copy size:%zu\n"

" save (from share stack to save stack) counter of the private save stack:%zu\n"

" restore (from save stack to share stack) counter of the private save stack:%zu\n",

co, co->save_stack.max_cpsz,

co->save_stack.ct_save,

co->save_stack.ct_restore

);

printf("\n(Since the share stack used by the co has only one user `co`, "

"so there is no need to save/restore the stack every time during resume &"

" yield execution, thus you can call it a co has 'standalone stack' "

"which just is a very special case of copy-stack.)\n");

printf(

"\ncopy-stack co2:%p:\n max stack copy size:%zu\n"

" save (from share stack to save stack) counter of the private save stack:%zu\n"

" restore (from save stack to share stack) counter of the private save stack:%zu\n",

co2, co2->save_stack.max_cpsz,

co2->save_stack.ct_save,

co2->save_stack.ct_restore

);

printf(

"\ncopy-stack co3:%p:\n max stack copy size:%zu\n"

" save (from share stack to save stack) counter of the private save stack:%zu\n"

" restore (from save stack to share stack) counter of the private save stack:%zu\n",

co3, co3->save_stack.max_cpsz,

co3->save_stack.ct_save,

co3->save_stack.ct_restore

);

printf("\n(The co2 & co3 share the share stack sstk2, thus it is "

"necessary to save/restore the stack every time during resume &"

" yield execution, thus it is a ordinary case of copy-stack.)\n");

uint64_t tmp_gl_ct;

pthread_mutex_lock(&gl_race_aco_yield_ct_mutex);

tmp_gl_ct = gl_race_aco_yield_ct;

pthread_mutex_unlock(&gl_race_aco_yield_ct_mutex);

printf("\ngl_race_aco_yield_ct:%" PRIu64"\n", tmp_gl_ct);

aco_destroy(co);

co = NULL;

aco_destroy(co2);

co2 = NULL;

aco_destroy(co3);

co3 = NULL;

aco_share_stack_destroy(sstk);

sstk = NULL;

aco_share_stack_destroy(sstk2);

sstk2 = NULL;

aco_destroy(main_co);

main_co = NULL;

return 0;

}

int main(){

#ifdef ACO_USE_VALGRIND

if(1){

printf("%s doesn't have valgrind test yet, "

"so bypass this test right now.\n",__FILE__

);

exit(0);

}

#endif

pthread_t t1,t2;

assert(0 == pthread_create(

&t1, NULL, pmain, NULL

));

assert(0 == pthread_create(

&t2, NULL, pmain, NULL

));

assert(0 == pthread_join(t1, NULL));

assert(0 == pthread_join(t2, NULL));

return 0;

}