aboutsummaryrefslogtreecommitdiff
path: root/examples/coroutines/aco.c
diff options
context:
space:
mode:
Diffstat (limited to 'examples/coroutines/aco.c')
-rw-r--r--examples/coroutines/aco.c434
1 files changed, 200 insertions, 234 deletions
diff --git a/examples/coroutines/aco.c b/examples/coroutines/aco.c
index 6057466f..258efe28 100644
--- a/examples/coroutines/aco.c
+++ b/examples/coroutines/aco.c
@@ -16,193 +16,194 @@
#define _GNU_SOURCE
#include "aco.h"
-#include <stdio.h>
#include <stdint.h>
+#include <stdio.h>
#ifndef public
-#define public __attribute__ ((visibility ("default")))
+#define public __attribute__((visibility("default")))
#endif
-#define aco_size_t_safe_add_assert(a,b) aco_assert((a)+(b) >= (a))
+#define aco_size_t_safe_add_assert(a, b) aco_assert((a) + (b) >= (a))
-static void aco_default_protector_last_word(void*);
+static void aco_default_protector_last_word(void *);
-void* (*aco_alloc_fn)(size_t) = malloc;
-void (*aco_dealloc_fn)(void*) = free;
+void *(*aco_alloc_fn)(size_t) = malloc;
+void (*aco_dealloc_fn)(void *) = free;
-#define aco_alloc(size) ({ \
- void *_ptr = aco_alloc_fn(size); \
- if (aco_unlikely((_ptr) == NULL)) { \
- fprintf(stderr, "Aborting: failed to allocate memory: %s:%d:%s\n", \
- __FILE__, __LINE__, __PRETTY_FUNCTION__); \
- abort(); \
- } \
- _ptr; \
-})
+#define aco_alloc(size) \
+ ({ \
+ void *_ptr = aco_alloc_fn(size); \
+ if (aco_unlikely((_ptr) == NULL)) { \
+ fprintf(stderr, "Aborting: failed to allocate memory: %s:%d:%s\n", __FILE__, __LINE__, \
+ __PRETTY_FUNCTION__); \
+ abort(); \
+ } \
+ _ptr; \
+ })
// aco's Global Thread Local Storage variable `co`
-public __thread aco_t* aco_gtls_co;
+public
+__thread aco_t *aco_gtls_co;
static __thread aco_cofuncp_t aco_gtls_last_word_fp = aco_default_protector_last_word;
#ifdef __i386__
- static __thread void* aco_gtls_fpucw_mxcsr[2];
-#elif __x86_64__
- static __thread void* aco_gtls_fpucw_mxcsr[1];
+static __thread void *aco_gtls_fpucw_mxcsr[2];
+#elif __x86_64__
+static __thread void *aco_gtls_fpucw_mxcsr[1];
#else
- #error "platform not supporteded yet"
+#error "platform not supporteded yet"
#endif
-public void aco_runtime_test(void) {
+public
+void aco_runtime_test(void) {
#ifdef __i386__
- _Static_assert(sizeof(void*) == 4, "require 'sizeof(void*) == 4'");
-#elif __x86_64__
- _Static_assert(sizeof(void*) == 8, "require 'sizeof(void*) == 8'");
+ _Static_assert(sizeof(void *) == 4, "require 'sizeof(void*) == 4'");
+#elif __x86_64__
+ _Static_assert(sizeof(void *) == 8, "require 'sizeof(void*) == 8'");
_Static_assert(sizeof(__uint128_t) == 16, "require 'sizeof(__uint128_t) == 16'");
#else
- #error "platform not supporteded yet"
+#error "platform not supporteded yet"
#endif
_Static_assert(sizeof(int) >= 4, "require 'sizeof(int) >= 4'");
aco_assert(sizeof(int) >= 4);
- _Static_assert(sizeof(int) <= sizeof(size_t),
- "require 'sizeof(int) <= sizeof(size_t)'");
+ _Static_assert(sizeof(int) <= sizeof(size_t), "require 'sizeof(int) <= sizeof(size_t)'");
aco_assert(sizeof(int) <= sizeof(size_t));
}
#ifdef __x86_64__
static inline void aco_fast_memcpy(void *dst, const void *src, size_t sz) {
- if (((uintptr_t)src & 0x0f) != 0
- || ((uintptr_t)dst & 0x0f) != 0
- || (sz & 0x0f) != 0x08
- || (sz >> 4) > 8) {
+ if (((uintptr_t)src & 0x0f) != 0 || ((uintptr_t)dst & 0x0f) != 0 || (sz & 0x0f) != 0x08 || (sz >> 4) > 8) {
memcpy(dst, src, sz);
return;
}
- __uint128_t xmm0,xmm1,xmm2,xmm3,xmm4,xmm5,xmm6,xmm7;
+ __uint128_t xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7;
switch (sz >> 4) {
- case 0:
- break;
- case 1:
- xmm0 = *((__uint128_t*)src + 0);
- *((__uint128_t*)dst + 0) = xmm0;
- break;
- case 2:
- xmm0 = *((__uint128_t*)src + 0);
- xmm1 = *((__uint128_t*)src + 1);
- *((__uint128_t*)dst + 0) = xmm0;
- *((__uint128_t*)dst + 1) = xmm1;
- break;
- case 3:
- xmm0 = *((__uint128_t*)src + 0);
- xmm1 = *((__uint128_t*)src + 1);
- xmm2 = *((__uint128_t*)src + 2);
- *((__uint128_t*)dst + 0) = xmm0;
- *((__uint128_t*)dst + 1) = xmm1;
- *((__uint128_t*)dst + 2) = xmm2;
- break;
- case 4:
- xmm0 = *((__uint128_t*)src + 0);
- xmm1 = *((__uint128_t*)src + 1);
- xmm2 = *((__uint128_t*)src + 2);
- xmm3 = *((__uint128_t*)src + 3);
- *((__uint128_t*)dst + 0) = xmm0;
- *((__uint128_t*)dst + 1) = xmm1;
- *((__uint128_t*)dst + 2) = xmm2;
- *((__uint128_t*)dst + 3) = xmm3;
- break;
- case 5:
- xmm0 = *((__uint128_t*)src + 0);
- xmm1 = *((__uint128_t*)src + 1);
- xmm2 = *((__uint128_t*)src + 2);
- xmm3 = *((__uint128_t*)src + 3);
- xmm4 = *((__uint128_t*)src + 4);
- *((__uint128_t*)dst + 0) = xmm0;
- *((__uint128_t*)dst + 1) = xmm1;
- *((__uint128_t*)dst + 2) = xmm2;
- *((__uint128_t*)dst + 3) = xmm3;
- *((__uint128_t*)dst + 4) = xmm4;
- break;
- case 6:
- xmm0 = *((__uint128_t*)src + 0);
- xmm1 = *((__uint128_t*)src + 1);
- xmm2 = *((__uint128_t*)src + 2);
- xmm3 = *((__uint128_t*)src + 3);
- xmm4 = *((__uint128_t*)src + 4);
- xmm5 = *((__uint128_t*)src + 5);
- *((__uint128_t*)dst + 0) = xmm0;
- *((__uint128_t*)dst + 1) = xmm1;
- *((__uint128_t*)dst + 2) = xmm2;
- *((__uint128_t*)dst + 3) = xmm3;
- *((__uint128_t*)dst + 4) = xmm4;
- *((__uint128_t*)dst + 5) = xmm5;
- break;
- case 7:
- xmm0 = *((__uint128_t*)src + 0);
- xmm1 = *((__uint128_t*)src + 1);
- xmm2 = *((__uint128_t*)src + 2);
- xmm3 = *((__uint128_t*)src + 3);
- xmm4 = *((__uint128_t*)src + 4);
- xmm5 = *((__uint128_t*)src + 5);
- xmm6 = *((__uint128_t*)src + 6);
- *((__uint128_t*)dst + 0) = xmm0;
- *((__uint128_t*)dst + 1) = xmm1;
- *((__uint128_t*)dst + 2) = xmm2;
- *((__uint128_t*)dst + 3) = xmm3;
- *((__uint128_t*)dst + 4) = xmm4;
- *((__uint128_t*)dst + 5) = xmm5;
- *((__uint128_t*)dst + 6) = xmm6;
- break;
- case 8:
- xmm0 = *((__uint128_t*)src + 0);
- xmm1 = *((__uint128_t*)src + 1);
- xmm2 = *((__uint128_t*)src + 2);
- xmm3 = *((__uint128_t*)src + 3);
- xmm4 = *((__uint128_t*)src + 4);
- xmm5 = *((__uint128_t*)src + 5);
- xmm6 = *((__uint128_t*)src + 6);
- xmm7 = *((__uint128_t*)src + 7);
- *((__uint128_t*)dst + 0) = xmm0;
- *((__uint128_t*)dst + 1) = xmm1;
- *((__uint128_t*)dst + 2) = xmm2;
- *((__uint128_t*)dst + 3) = xmm3;
- *((__uint128_t*)dst + 4) = xmm4;
- *((__uint128_t*)dst + 5) = xmm5;
- *((__uint128_t*)dst + 6) = xmm6;
- *((__uint128_t*)dst + 7) = xmm7;
- break;
+ case 0: break;
+ case 1:
+ xmm0 = *((__uint128_t *)src + 0);
+ *((__uint128_t *)dst + 0) = xmm0;
+ break;
+ case 2:
+ xmm0 = *((__uint128_t *)src + 0);
+ xmm1 = *((__uint128_t *)src + 1);
+ *((__uint128_t *)dst + 0) = xmm0;
+ *((__uint128_t *)dst + 1) = xmm1;
+ break;
+ case 3:
+ xmm0 = *((__uint128_t *)src + 0);
+ xmm1 = *((__uint128_t *)src + 1);
+ xmm2 = *((__uint128_t *)src + 2);
+ *((__uint128_t *)dst + 0) = xmm0;
+ *((__uint128_t *)dst + 1) = xmm1;
+ *((__uint128_t *)dst + 2) = xmm2;
+ break;
+ case 4:
+ xmm0 = *((__uint128_t *)src + 0);
+ xmm1 = *((__uint128_t *)src + 1);
+ xmm2 = *((__uint128_t *)src + 2);
+ xmm3 = *((__uint128_t *)src + 3);
+ *((__uint128_t *)dst + 0) = xmm0;
+ *((__uint128_t *)dst + 1) = xmm1;
+ *((__uint128_t *)dst + 2) = xmm2;
+ *((__uint128_t *)dst + 3) = xmm3;
+ break;
+ case 5:
+ xmm0 = *((__uint128_t *)src + 0);
+ xmm1 = *((__uint128_t *)src + 1);
+ xmm2 = *((__uint128_t *)src + 2);
+ xmm3 = *((__uint128_t *)src + 3);
+ xmm4 = *((__uint128_t *)src + 4);
+ *((__uint128_t *)dst + 0) = xmm0;
+ *((__uint128_t *)dst + 1) = xmm1;
+ *((__uint128_t *)dst + 2) = xmm2;
+ *((__uint128_t *)dst + 3) = xmm3;
+ *((__uint128_t *)dst + 4) = xmm4;
+ break;
+ case 6:
+ xmm0 = *((__uint128_t *)src + 0);
+ xmm1 = *((__uint128_t *)src + 1);
+ xmm2 = *((__uint128_t *)src + 2);
+ xmm3 = *((__uint128_t *)src + 3);
+ xmm4 = *((__uint128_t *)src + 4);
+ xmm5 = *((__uint128_t *)src + 5);
+ *((__uint128_t *)dst + 0) = xmm0;
+ *((__uint128_t *)dst + 1) = xmm1;
+ *((__uint128_t *)dst + 2) = xmm2;
+ *((__uint128_t *)dst + 3) = xmm3;
+ *((__uint128_t *)dst + 4) = xmm4;
+ *((__uint128_t *)dst + 5) = xmm5;
+ break;
+ case 7:
+ xmm0 = *((__uint128_t *)src + 0);
+ xmm1 = *((__uint128_t *)src + 1);
+ xmm2 = *((__uint128_t *)src + 2);
+ xmm3 = *((__uint128_t *)src + 3);
+ xmm4 = *((__uint128_t *)src + 4);
+ xmm5 = *((__uint128_t *)src + 5);
+ xmm6 = *((__uint128_t *)src + 6);
+ *((__uint128_t *)dst + 0) = xmm0;
+ *((__uint128_t *)dst + 1) = xmm1;
+ *((__uint128_t *)dst + 2) = xmm2;
+ *((__uint128_t *)dst + 3) = xmm3;
+ *((__uint128_t *)dst + 4) = xmm4;
+ *((__uint128_t *)dst + 5) = xmm5;
+ *((__uint128_t *)dst + 6) = xmm6;
+ break;
+ case 8:
+ xmm0 = *((__uint128_t *)src + 0);
+ xmm1 = *((__uint128_t *)src + 1);
+ xmm2 = *((__uint128_t *)src + 2);
+ xmm3 = *((__uint128_t *)src + 3);
+ xmm4 = *((__uint128_t *)src + 4);
+ xmm5 = *((__uint128_t *)src + 5);
+ xmm6 = *((__uint128_t *)src + 6);
+ xmm7 = *((__uint128_t *)src + 7);
+ *((__uint128_t *)dst + 0) = xmm0;
+ *((__uint128_t *)dst + 1) = xmm1;
+ *((__uint128_t *)dst + 2) = xmm2;
+ *((__uint128_t *)dst + 3) = xmm3;
+ *((__uint128_t *)dst + 4) = xmm4;
+ *((__uint128_t *)dst + 5) = xmm5;
+ *((__uint128_t *)dst + 6) = xmm6;
+ *((__uint128_t *)dst + 7) = xmm7;
+ break;
}
- *((uint64_t*)((uintptr_t)dst + sz - 8)) = *((uint64_t*)((uintptr_t)src + sz - 8));
+ *((uint64_t *)((uintptr_t)dst + sz - 8)) = *((uint64_t *)((uintptr_t)src + sz - 8));
}
#endif
-void aco_default_protector_last_word(void*_) {
- aco_t* co = aco_get_co();
+void aco_default_protector_last_word(void *_) {
+ aco_t *co = aco_get_co();
// do some log about the offending `co`
- fprintf(stderr,"error: aco_default_protector_last_word triggered\n");
- fprintf(stderr, "error: co:%p should call `aco_exit()` instead of direct "
- "`return` in co_fp:%p to finish its execution\n", co, (void*)co->fp);
+ fprintf(stderr, "error: aco_default_protector_last_word triggered\n");
+ fprintf(stderr,
+ "error: co:%p should call `aco_exit()` instead of direct "
+ "`return` in co_fp:%p to finish its execution\n",
+ co, (void *)co->fp);
aco_assert(0);
}
-public void aco_set_allocator(void* (*alloc)(size_t), void (*dealloc)(void*))
-{
+public
+void aco_set_allocator(void *(*alloc)(size_t), void (*dealloc)(void *)) {
aco_alloc_fn = alloc;
aco_dealloc_fn = dealloc;
}
-public void aco_thread_init(aco_cofuncp_t last_word_co_fp) {
+public
+void aco_thread_init(aco_cofuncp_t last_word_co_fp) {
aco_save_fpucw_mxcsr(aco_gtls_fpucw_mxcsr);
- if ((void*)last_word_co_fp != NULL)
- aco_gtls_last_word_fp = last_word_co_fp;
+ if ((void *)last_word_co_fp != NULL) aco_gtls_last_word_fp = last_word_co_fp;
}
// This function `aco_funcp_protector` should never be
// called. If it's been called, that means the offending
// `co` didn't call aco_exit(co) instead of `return` to
// finish its execution.
-public void aco_funcp_protector(void) {
- if ((void*)(aco_gtls_last_word_fp) != NULL) {
+public
+void aco_funcp_protector(void) {
+ if ((void *)(aco_gtls_last_word_fp) != NULL) {
aco_gtls_last_word_fp(NULL);
} else {
aco_default_protector_last_word(NULL);
@@ -210,11 +211,11 @@ public void aco_funcp_protector(void) {
aco_assert(0);
}
-public aco_shared_stack_t* aco_shared_stack_new(size_t sz) {
- return aco_shared_stack_new2(sz, 1);
-}
+public
+aco_shared_stack_t *aco_shared_stack_new(size_t sz) { return aco_shared_stack_new2(sz, 1); }
-public aco_shared_stack_t* aco_shared_stack_new2(size_t sz, bool guard_page_enabled) {
+public
+aco_shared_stack_t *aco_shared_stack_new2(size_t sz, bool guard_page_enabled) {
if (sz == 0) {
sz = 1024 * 1024 * 2;
}
@@ -253,52 +254,48 @@ public aco_shared_stack_t* aco_shared_stack_new2(size_t sz, bool guard_page_enab
}
}
- aco_shared_stack_t* p = aco_alloc(sizeof(aco_shared_stack_t));
+ aco_shared_stack_t *p = aco_alloc(sizeof(aco_shared_stack_t));
memset(p, 0, sizeof(aco_shared_stack_t));
if (guard_page_enabled) {
- p->real_ptr = mmap(
- NULL, sz, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0
- );
+ p->real_ptr = mmap(NULL, sz, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (aco_unlikely(p->real_ptr == MAP_FAILED)) {
- fprintf(stderr, "Aborting: failed to allocate memory: %s:%d:%s\n",
- __FILE__, __LINE__, __PRETTY_FUNCTION__);
+ fprintf(stderr, "Aborting: failed to allocate memory: %s:%d:%s\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
abort();
}
p->guard_page_enabled = true;
aco_assert(0 == mprotect(p->real_ptr, u_pgsz, PROT_READ));
- p->ptr = (void*)(((uintptr_t)p->real_ptr) + u_pgsz);
+ p->ptr = (void *)(((uintptr_t)p->real_ptr) + u_pgsz);
p->real_sz = sz;
aco_assert(sz >= (u_pgsz << 1));
p->sz = sz - u_pgsz;
} else {
- //p->guard_page_enabled = 0;
+ // p->guard_page_enabled = 0;
p->sz = sz;
p->ptr = aco_alloc(sz);
}
p->owner = NULL;
#ifdef ACO_USE_VALGRIND
- p->valgrind_stk_id = VALGRIND_STACK_REGISTER(
- p->ptr, (void*)((uintptr_t)p->ptr + p->sz)
- );
+ p->valgrind_stk_id = VALGRIND_STACK_REGISTER(p->ptr, (void *)((uintptr_t)p->ptr + p->sz));
#endif
#if defined(__i386__) || defined(__x86_64__)
- uintptr_t u_p = (uintptr_t)(p->sz - (sizeof(void*) << 1) + (uintptr_t)p->ptr);
+ uintptr_t u_p = (uintptr_t)(p->sz - (sizeof(void *) << 1) + (uintptr_t)p->ptr);
u_p = (u_p >> 4) << 4;
- p->align_highptr = (void*)u_p;
- p->align_retptr = (void*)(u_p - sizeof(void*));
- *((void**)(p->align_retptr)) = (void*)(aco_funcp_protector_asm);
- aco_assert(p->sz > (16 + (sizeof(void*) << 1) + sizeof(void*)));
- p->align_limit = p->sz - 16 - (sizeof(void*) << 1);
+ p->align_highptr = (void *)u_p;
+ p->align_retptr = (void *)(u_p - sizeof(void *));
+ *((void **)(p->align_retptr)) = (void *)(aco_funcp_protector_asm);
+ aco_assert(p->sz > (16 + (sizeof(void *) << 1) + sizeof(void *)));
+ p->align_limit = p->sz - 16 - (sizeof(void *) << 1);
#else
- #error "platform not supporteded yet"
+#error "platform not supporteded yet"
#endif
return p;
}
-public void aco_shared_stack_destroy(aco_shared_stack_t* sstk) {
+public
+void aco_shared_stack_destroy(aco_shared_stack_t *sstk) {
aco_assert(sstk != NULL && sstk->ptr != NULL);
#ifdef ACO_USE_VALGRIND
VALGRIND_STACK_DEREGISTER(sstk->valgrind_stk_id);
@@ -314,11 +311,10 @@ public void aco_shared_stack_destroy(aco_shared_stack_t* sstk) {
if (aco_dealloc_fn != NULL) aco_dealloc_fn(sstk);
}
-public aco_t* aco_create(
- aco_t* main_co, aco_shared_stack_t* shared_stack,
- size_t saved_stack_sz, aco_cofuncp_t fp, void* arg
-) {
- aco_t* p = aco_alloc(sizeof(aco_t));
+public
+aco_t *aco_create(aco_t *main_co, aco_shared_stack_t *shared_stack, size_t saved_stack_sz, aco_cofuncp_t fp,
+ void *arg) {
+ aco_t *p = aco_alloc(sizeof(aco_t));
memset(p, 0, sizeof(aco_t));
if (main_co != NULL) { // non-main co
@@ -327,21 +323,21 @@ public aco_t* aco_create(
#ifdef __i386__
// POSIX.1-2008 (IEEE Std 1003.1-2008) - General Information - Data Types - Pointer Types
// http://pubs.opengroup.org/onlinepubs/9699919799.2008edition/functions/V2_chap02.html#tag_15_12_03
- p->reg[ACO_REG_IDX_RETADDR] = (void*)fp;
+ p->reg[ACO_REG_IDX_RETADDR] = (void *)fp;
// push retaddr
p->reg[ACO_REG_IDX_SP] = p->shared_stack->align_retptr;
- #ifndef ACO_CONFIG_SHARE_FPU_MXCSR_ENV
- p->reg[ACO_REG_IDX_FPU] = aco_gtls_fpucw_mxcsr[0];
- p->reg[ACO_REG_IDX_FPU + 1] = aco_gtls_fpucw_mxcsr[1];
- #endif
-#elif __x86_64__
- p->reg[ACO_REG_IDX_RETADDR] = (void*)fp;
+#ifndef ACO_CONFIG_SHARE_FPU_MXCSR_ENV
+ p->reg[ACO_REG_IDX_FPU] = aco_gtls_fpucw_mxcsr[0];
+ p->reg[ACO_REG_IDX_FPU + 1] = aco_gtls_fpucw_mxcsr[1];
+#endif
+#elif __x86_64__
+ p->reg[ACO_REG_IDX_RETADDR] = (void *)fp;
p->reg[ACO_REG_IDX_SP] = p->shared_stack->align_retptr;
- #ifndef ACO_CONFIG_SHARE_FPU_MXCSR_ENV
- p->reg[ACO_REG_IDX_FPU] = aco_gtls_fpucw_mxcsr[0];
- #endif
+#ifndef ACO_CONFIG_SHARE_FPU_MXCSR_ENV
+ p->reg[ACO_REG_IDX_FPU] = aco_gtls_fpucw_mxcsr[0];
+#endif
#else
- #error "platform not supporteded yet"
+#error "platform not supporteded yet"
#endif
p->main_co = main_co;
p->arg = arg;
@@ -354,7 +350,7 @@ public aco_t* aco_create(
#if defined(__i386__) || defined(__x86_64__)
p->saved_stack.valid_sz = 0;
#else
- #error "platform not supporteded yet"
+#error "platform not supporteded yet"
#endif
return p;
} else { // main co
@@ -368,35 +364,20 @@ public aco_t* aco_create(
aco_assert(0);
}
-public aco_attr_no_asan
-void aco_resume(aco_t* resume_co) {
- aco_assert(resume_co != NULL && resume_co->main_co != NULL
- && !resume_co->is_finished
- );
+public
+aco_attr_no_asan void aco_resume(aco_t *resume_co) {
+ aco_assert(resume_co != NULL && resume_co->main_co != NULL && !resume_co->is_finished);
if (resume_co->shared_stack->owner != resume_co) {
if (resume_co->shared_stack->owner != NULL) {
- aco_t* owner_co = resume_co->shared_stack->owner;
+ aco_t *owner_co = resume_co->shared_stack->owner;
aco_assert(owner_co->shared_stack == resume_co->shared_stack);
#if defined(__i386__) || defined(__x86_64__)
- aco_assert(
- (
- (uintptr_t)(owner_co->shared_stack->align_retptr)
- >=
- (uintptr_t)(owner_co->reg[ACO_REG_IDX_SP])
- )
- &&
- (
- (uintptr_t)(owner_co->shared_stack->align_highptr)
- -
- (uintptr_t)(owner_co->shared_stack->align_limit)
- <=
- (uintptr_t)(owner_co->reg[ACO_REG_IDX_SP])
- )
- );
+ aco_assert(((uintptr_t)(owner_co->shared_stack->align_retptr) >= (uintptr_t)(owner_co->reg[ACO_REG_IDX_SP]))
+ && ((uintptr_t)(owner_co->shared_stack->align_highptr)
+ - (uintptr_t)(owner_co->shared_stack->align_limit)
+ <= (uintptr_t)(owner_co->reg[ACO_REG_IDX_SP])));
owner_co->saved_stack.valid_sz =
- (uintptr_t)(owner_co->shared_stack->align_retptr)
- -
- (uintptr_t)(owner_co->reg[ACO_REG_IDX_SP]);
+ (uintptr_t)(owner_co->shared_stack->align_retptr) - (uintptr_t)(owner_co->reg[ACO_REG_IDX_SP]);
if (owner_co->saved_stack.sz < owner_co->saved_stack.valid_sz) {
if (aco_dealloc_fn != NULL) aco_dealloc_fn(owner_co->saved_stack.ptr);
owner_co->saved_stack.ptr = NULL;
@@ -412,19 +393,12 @@ void aco_resume(aco_t* resume_co) {
// TODO: optimize the performance penalty of memcpy function call
// for very short memory span
if (owner_co->saved_stack.valid_sz > 0) {
- #ifdef __x86_64__
- aco_fast_memcpy(
- owner_co->saved_stack.ptr,
- owner_co->reg[ACO_REG_IDX_SP],
- owner_co->saved_stack.valid_sz
- );
- #else
- memcpy(
- owner_co->saved_stack.ptr,
- owner_co->reg[ACO_REG_IDX_SP],
- owner_co->saved_stack.valid_sz
- );
- #endif
+#ifdef __x86_64__
+ aco_fast_memcpy(owner_co->saved_stack.ptr, owner_co->reg[ACO_REG_IDX_SP],
+ owner_co->saved_stack.valid_sz);
+#else
+ memcpy(owner_co->saved_stack.ptr, owner_co->reg[ACO_REG_IDX_SP], owner_co->saved_stack.valid_sz);
+#endif
owner_co->saved_stack.ct_save++;
}
if (owner_co->saved_stack.valid_sz > owner_co->saved_stack.max_cpsz) {
@@ -433,36 +407,30 @@ void aco_resume(aco_t* resume_co) {
owner_co->shared_stack->owner = NULL;
owner_co->shared_stack->align_validsz = 0;
#else
- #error "platform not supporteded yet"
+#error "platform not supporteded yet"
#endif
}
aco_assert(resume_co->shared_stack->owner == NULL);
#if defined(__i386__) || defined(__x86_64__)
- aco_assert(
- resume_co->saved_stack.valid_sz
- <=
- resume_co->shared_stack->align_limit - sizeof(void*)
- );
+ aco_assert(resume_co->saved_stack.valid_sz <= resume_co->shared_stack->align_limit - sizeof(void *));
// TODO: optimize the performance penalty of memcpy function call
// for very short memory span
if (resume_co->saved_stack.valid_sz > 0) {
- void *dst = (void*)(
- (uintptr_t)(resume_co->shared_stack->align_retptr)
- - resume_co->saved_stack.valid_sz);
- #ifdef __x86_64__
+ void *dst = (void *)((uintptr_t)(resume_co->shared_stack->align_retptr) - resume_co->saved_stack.valid_sz);
+#ifdef __x86_64__
aco_fast_memcpy(dst, resume_co->saved_stack.ptr, resume_co->saved_stack.valid_sz);
- #else
+#else
memcpy(dst, resume_co->saved_stack.ptr, resume_co->saved_stack.valid_sz);
- #endif
+#endif
resume_co->saved_stack.ct_restore++;
}
if (resume_co->saved_stack.valid_sz > resume_co->saved_stack.max_cpsz) {
resume_co->saved_stack.max_cpsz = resume_co->saved_stack.valid_sz;
}
- resume_co->shared_stack->align_validsz = resume_co->saved_stack.valid_sz + sizeof(void*);
+ resume_co->shared_stack->align_validsz = resume_co->saved_stack.valid_sz + sizeof(void *);
resume_co->shared_stack->owner = resume_co;
#else
- #error "platform not supporteded yet"
+#error "platform not supporteded yet"
#endif
}
aco_gtls_co = resume_co;
@@ -470,7 +438,8 @@ void aco_resume(aco_t* resume_co) {
aco_gtls_co = resume_co->main_co;
}
-public void aco_destroy(aco_t* co) {
+public
+void aco_destroy(aco_t *co) {
aco_assertptr(co);
if (aco_is_main_co(co)) {
if (aco_dealloc_fn != NULL) aco_dealloc_fn(co);
@@ -479,14 +448,11 @@ public void aco_destroy(aco_t* co) {
co->shared_stack->owner = NULL;
co->shared_stack->align_validsz = 0;
}
- if (aco_dealloc_fn != NULL)
- aco_dealloc_fn(co->saved_stack.ptr);
+ if (aco_dealloc_fn != NULL) aco_dealloc_fn(co->saved_stack.ptr);
co->saved_stack.ptr = NULL;
- if (aco_dealloc_fn != NULL)
- aco_dealloc_fn(co);
+ if (aco_dealloc_fn != NULL) aco_dealloc_fn(co);
}
}
-public void aco_exit_fn(void*_) {
- aco_exit();
-}
+public
+void aco_exit_fn(void *_) { aco_exit(); }
generated by cgit v1.2.3 (git 2.25.1) at 2026-03-01 05:16:59 +0000