diff options
Diffstat (limited to 'coroutine.c')
| -rw-r--r-- | coroutine.c | 63 |
1 files changed, 40 insertions, 23 deletions
diff --git a/coroutine.c b/coroutine.c index 2c265a3..f138fcf 100644 --- a/coroutine.c +++ b/coroutine.c @@ -14,10 +14,24 @@ /* Configuration **************************************************************/ -#define COROUTINE_NUM 5 -#define COROUTINE_MEASURE_STACK 1 -#define COROUTINE_PROTECT_STACK 1 -#define COROUTINE_DEBUG 0 +#define USE_CONFIG_COROUTINE +#include "config.h" + +#ifndef CONFIG_COROUTINE_DEFAULT_STACK_SIZE +# error config.h must define CONFIG_COROUTINE_DEFAULT_STACK_SIZE +#endif +#ifndef CONFIG_COROUTINE_NUM +# error config.h must define CONFIG_COROUTINE_NUM +#endif +#ifndef CONFIG_COROUTINE_MEASURE_STACK +# error config.h must define CONFIG_COROUTINE_MEASURE_STACK +#endif +#ifndef CONFIG_COROUTINE_PROTECT_STACK +# error config.h must define CONFIG_COROUTINE_PROTECT_STACK +#endif +#ifndef CONFIG_COROUTINE_DEBUG +# error config.h must define CONFIG_COROUTINE_DEBUG +#endif /* Implementation *************************************************************/ @@ -77,7 +91,7 @@ * sizes. (2) Leaving it uninitialized just gives me the willies. * * - Because embedded programs should be adverse to using the heap, - * COROUTINE_NUM is fixed, instead of having coroutine_add() + * CONFIG_COROUTINE_NUM is fixed, instead of having coroutine_add() * dynamically grow the coroutine_table as-needed. * * - On the flip-side, coroutine stacks are allocated on the heap @@ -105,7 +119,7 @@ * and a few bytes. */ -#if COROUTINE_DEBUG +#if CONFIG_COROUTINE_DEBUG # define debugf(...) printf("dbg: " __VA_ARGS__) #else # define debugf(...) @@ -146,8 +160,8 @@ struct coroutine { void *stack; }; -static struct coroutine coroutine_table[COROUTINE_NUM] = {0}; -static cid_t coroutine_running = 0; +static struct coroutine coroutine_table[CONFIG_COROUTINE_NUM] = {0}; +static cid_t coroutine_running = 0; static void call_with_stack(void *stack, cr_fn_t fn, void *args) { static void *saved_sp = NULL; @@ -193,13 +207,13 @@ static void call_with_stack(void *stack, cr_fn_t fn, void *args) { #endif } -#if COROUTINE_MEASURE_STACK || COROUTINE_PROTECT_STACK +#if CONFIG_COROUTINE_MEASURE_STACK || CONFIG_COROUTINE_PROTECT_STACK /* We just need a pattern that is unlikely to occur naturaly; this is * just a few bytes that I read from /dev/random. */ -static const uint8_t const stack_pattern[] = {0x1e, 0x15, 0x16, 0x0a, 0xcc, 0x52, 0x7e, 0xb7}; +static const uint8_t stack_pattern[] = {0x1e, 0x15, 0x16, 0x0a, 0xcc, 0x52, 0x7e, 0xb7}; #endif -#if COROUTINE_PROTECT_STACK +#if CONFIG_COROUTINE_PROTECT_STACK void assert_stack_protection(cid_t cid) { assert(coroutine_table[cid-1].stack_size); assert(coroutine_table[cid-1].stack); @@ -215,7 +229,7 @@ void assert_stack_protection(cid_t cid) { #define assert_cid_state(cid, opstate) do { \ assert((cid) > 0); \ - assert((cid) <= COROUTINE_NUM); \ + assert((cid) <= CONFIG_COROUTINE_NUM); \ assert(coroutine_table[(cid)-1].state opstate); \ assert_stack_protection(cid); \ } while (0) @@ -224,6 +238,9 @@ cid_t coroutine_add_with_stack_size(size_t stack_size, cr_fn_t fn, void *args) { static cid_t last_created = 0; cid_t parent = coroutine_running; + if (!stack_size) + stack_size = CONFIG_COROUTINE_DEFAULT_STACK_SIZE; + if (parent) assert_cid_state(parent, == CR_RUNNING); assert(stack_size); @@ -233,8 +250,8 @@ cid_t coroutine_add_with_stack_size(size_t stack_size, cr_fn_t fn, void *args) { cid_t child; { size_t idx_base = last_created; - for (size_t idx_shift = 0; idx_shift < COROUTINE_NUM; idx_shift++) { - child = ((idx_base + idx_shift) % COROUTINE_NUM) + 1; + for (size_t idx_shift = 0; idx_shift < CONFIG_COROUTINE_NUM; idx_shift++) { + child = ((idx_base + idx_shift) % CONFIG_COROUTINE_NUM) + 1; if (coroutine_table[child-1].state == CR_NONE) goto found; } @@ -247,7 +264,7 @@ cid_t coroutine_add_with_stack_size(size_t stack_size, cr_fn_t fn, void *args) { coroutine_table[child-1].stack_size = stack_size; coroutine_table[child-1].stack = malloc(stack_size); -#if COROUTINE_MEASURE_STACK || COROUTINE_PROTECT_STACK +#if CONFIG_COROUTINE_MEASURE_STACK || CONFIG_COROUTINE_PROTECT_STACK for (size_t i = 0; i < stack_size; i++) ((uint8_t*)coroutine_table[child-1].stack)[i] = stack_pattern[i%sizeof(stack_pattern)]; #endif @@ -256,7 +273,7 @@ cid_t coroutine_add_with_stack_size(size_t stack_size, cr_fn_t fn, void *args) { coroutine_table[child-1].state = CR_INITIALIZING; if (!setjmp(coroutine_add_env)) { /* point=a */ void *stack_base = coroutine_table[child-1].stack + (STACK_GROWS_DOWNWARD ? stack_size : 0); -#if COROUTINE_PROTECT_STACK +#if CONFIG_COROUTINE_PROTECT_STACK # if STACK_GROWS_DOWNWARD stack_base -= sizeof(stack_pattern); # else @@ -280,7 +297,7 @@ cid_t coroutine_add_with_stack_size(size_t stack_size, cr_fn_t fn, void *args) { void coroutine_main(void) { debugf("coroutine_main()\n"); bool ran; - for (coroutine_running = 1;; coroutine_running = (coroutine_running%COROUTINE_NUM)+1) { + for (coroutine_running = 1;; coroutine_running = (coroutine_running%CONFIG_COROUTINE_NUM)+1) { if (coroutine_running == 1) ran = false; struct coroutine *cr = &coroutine_table[coroutine_running-1]; @@ -294,13 +311,13 @@ void coroutine_main(void) { } assert_cid_state(coroutine_running, != CR_RUNNING); if (cr->state == CR_NONE) { -#if COROUTINE_MEASURE_STACK - size_t stack_size = cr->stack_size - (COROUTINE_PROTECT_STACK ? 2*sizeof(stack_pattern) : 0); +#if CONFIG_COROUTINE_MEASURE_STACK + size_t stack_size = cr->stack_size - (CONFIG_COROUTINE_PROTECT_STACK ? 2*sizeof(stack_pattern) : 0); size_t stack_used = stack_size; for (;;) { size_t i = STACK_GROWS_DOWNWARD - ? (COROUTINE_PROTECT_STACK ? sizeof(stack_pattern) : 0) + stack_size - stack_used - : stack_used - 1 - (COROUTINE_PROTECT_STACK ? sizeof(stack_pattern) : 0); + ? (CONFIG_COROUTINE_PROTECT_STACK ? sizeof(stack_pattern) : 0) + stack_size - stack_used + : stack_used - 1 - (CONFIG_COROUTINE_PROTECT_STACK ? sizeof(stack_pattern) : 0); if (stack_used == 0 || ((uint8_t*)cr->stack)[i] != stack_pattern[i%sizeof(stack_pattern)]) break; stack_used--; @@ -311,14 +328,14 @@ void coroutine_main(void) { coroutine_table[coroutine_running-1] = (struct coroutine){0}; } } - if (coroutine_running == COROUTINE_NUM && !ran) { + if (coroutine_running == CONFIG_COROUTINE_NUM && !ran) { fprintf(stderr, "error: no runnable coroutines\n"); return; } } } -bool cr_begin(void) { +void cr_begin(void) { assert_cid_state(coroutine_running, == CR_INITIALIZING); coroutine_table[coroutine_running-1].state = CR_RUNNABLE; |