Changeset fe610ab for libcfa/src/concurrency/coroutine.cfa

Timestamp:

Feb 17, 2022, 6:53:31 PM (2 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, ast-experimental, enum, master, pthread-emulation, qualifiedEnum

Children:

f69fac7

Parents:

778315e (diff), 9ef9644 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• libcfa/src/concurrency/coroutine.cfa (modified) (4 diffs)

libcfa/src/concurrency/coroutine.cfa

@@ -85 +85 @@
 // minimum feasible stack size in bytes
 static const size_t MinStackSize = 1000;
-extern size_t __page_size;                              // architecture pagesize HACK, should go in proper runtime singleton
-extern int __map_prot;
+
+extern "C" {
+        extern size_t __cfa_page_size;                          // architecture pagesize HACK, should go in proper runtime singleton
+        extern int __map_prot;
+}
 
 void __stack_prepare( __stack_info_t * this, size_t create_size );
@@ -157 +160 @@
 [void *, size_t] __stack_alloc( size_t storageSize ) {
         const size_t stack_data_size = libCeiling( sizeof(__stack_t), 16 ); // minimum alignment
-        assert(__page_size != 0l);
+        assert(__cfa_page_size != 0l);
         size_t size = libCeiling( storageSize, 16 ) + stack_data_size;
-        size = ceiling(size, __page_size);
+        size = ceiling(size, __cfa_page_size);
 
         // If we are running debug, we also need to allocate a guardpage to catch stack overflows.
         void * storage;
         #if CFA_COROUTINE_USE_MMAP
-                storage = mmap(0p, size + __page_size, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
+                storage = mmap(0p, size + __cfa_page_size, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
                 if(storage == ((void*)-1)) {
                         abort( "coroutine stack creation : internal error, mmap failure, error(%d) %s.", errno, strerror( errno ) );
                 }
-                if ( mprotect( storage, __page_size, PROT_NONE ) == -1 ) {
+                if ( mprotect( storage, __cfa_page_size, PROT_NONE ) == -1 ) {
                         abort( "coroutine stack creation : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
                 } // if
-                storage = (void *)(((intptr_t)storage) + __page_size);
+                storage = (void *)(((intptr_t)storage) + __cfa_page_size);
         #else
                 __cfaabi_dbg_debug_do(
-                        storage = memalign( __page_size, size + __page_size );
+                        storage = memalign( __cfa_page_size, size + __cfa_page_size );
                 );
                 __cfaabi_dbg_no_debug_do(
@@ -181 +184 @@
 
                 __cfaabi_dbg_debug_do(
-                        if ( mprotect( storage, __page_size, PROT_NONE ) == -1 ) {
+                        if ( mprotect( storage, __cfa_page_size, PROT_NONE ) == -1 ) {
                                 abort( "__stack_alloc : internal error, mprotect failure, error(%d) %s.", (int)errno, strerror( (int)errno ) );
                         }
-                        storage = (void *)(((intptr_t)storage) + __page_size);
+                        storage = (void *)(((intptr_t)storage) + __cfa_page_size);
                 );
         #endif
@@ -198 +201 @@
         #if CFA_COROUTINE_USE_MMAP
                 size_t size = ((intptr_t)this->storage->base) - ((intptr_t)this->storage->limit) + sizeof(__stack_t);
-                storage = (void *)(((intptr_t)storage) - __page_size);
-                if(munmap(storage, size + __page_size) == -1) {
+                storage = (void *)(((intptr_t)storage) - __cfa_page_size);
+                if(munmap(storage, size + __cfa_page_size) == -1) {
                         abort( "coroutine stack destruction : internal error, munmap failure, error(%d) %s.", errno, strerror( errno ) );
                 }
         #else
                 __cfaabi_dbg_debug_do(
-                        storage = (char*)(storage) - __page_size;
-                        if ( mprotect( storage, __page_size, __map_prot ) == -1 ) {
+                        storage = (char*)(storage) - __cfa_page_size;
+                        if ( mprotect( storage, __cfa_page_size, __map_prot ) == -1 ) {
                                 abort( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) );
                         }