Changeset a182ad5

Timestamp:

Feb 22, 2022, 12:23:14 PM (3 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

f53afafb

Parents:

f69fac7

Message:

Revert "removed old memory allocator and replaced it with the concurrent allocator"

This reverts commit 5614a1915d68cb593dc2a2076d1d7e51433b157e.

Location:

libcfa/src

Files:

• Makefile.am (modified) (3 diffs)
• concurrency/coroutine.cfa (modified) (4 diffs)
• concurrency/kernel/startup.cfa (modified) (5 diffs)
• heap.cc (deleted)
• heap.cfa (added)
• heap.h (deleted)
• heap.hfa (added)
• startup.cfa (modified) (1 diff)
• stdhdr/malloc.h (modified) (1 diff)
• stdlib.hfa (modified) (1 diff)

libcfa/src/Makefile.am

@@ -72 +72 @@
         common.hfa \
         fstream.hfa \
+        heap.hfa \
         iostream.hfa \
         iterator.hfa \
@@ -101 +102 @@
         startup.hfa \
         virtual.c \
-        virtual.h \
-        heap.cc \
-        heap.h
+        virtual.h
 
 # not all platforms support concurrency, add option do disable it
@@ -173 +172 @@
 
 -include $(libdeps)
--include $(DEPDIR)/heap.Plo
 
 thread_libdeps = $(join \

libcfa/src/concurrency/coroutine.cfa

@@ -85 +85 @@
 // minimum feasible stack size in bytes
 static const size_t MinStackSize = 1000;
-
-extern "C" {
-        extern size_t __cfa_page_size;                          // architecture pagesize HACK, should go in proper runtime singleton
-        extern int __map_prot;
-}
+extern size_t __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 );
@@ -160 +157 @@
 [void *, size_t] __stack_alloc( size_t storageSize ) {
         const size_t stack_data_size = libCeiling( sizeof(__stack_t), 16 ); // minimum alignment
-        assert(__cfa_page_size != 0l);
+        assert(__page_size != 0l);
         size_t size = libCeiling( storageSize, 16 ) + stack_data_size;
-        size = ceiling(size, __cfa_page_size);
+        size = ceiling(size, __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 + __cfa_page_size, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
+                storage = mmap(0p, size + __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, __cfa_page_size, PROT_NONE ) == -1 ) {
+                if ( mprotect( storage, __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) + __cfa_page_size);
+                storage = (void *)(((intptr_t)storage) + __page_size);
         #else
                 __cfaabi_dbg_debug_do(
-                        storage = memalign( __cfa_page_size, size + __cfa_page_size );
+                        storage = memalign( __page_size, size + __page_size );
                 );
                 __cfaabi_dbg_no_debug_do(
@@ -184 +181 @@
 
                 __cfaabi_dbg_debug_do(
-                        if ( mprotect( storage, __cfa_page_size, PROT_NONE ) == -1 ) {
+                        if ( mprotect( storage, __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) + __cfa_page_size);
+                        storage = (void *)(((intptr_t)storage) + __page_size);
                 );
         #endif
@@ -201 +198 @@
         #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) - __cfa_page_size);
-                if(munmap(storage, size + __cfa_page_size) == -1) {
+                storage = (void *)(((intptr_t)storage) - __page_size);
+                if(munmap(storage, size + __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) - __cfa_page_size;
-                        if ( mprotect( storage, __cfa_page_size, __map_prot ) == -1 ) {
+                        storage = (char*)(storage) - __page_size;
+                        if ( mprotect( storage, __page_size, __map_prot ) == -1 ) {
                                 abort( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) );
                         }

libcfa/src/concurrency/kernel/startup.cfa

@@ -122 +122 @@
 extern "C" {
         struct { __dllist_t(cluster) list; __spinlock_t lock; } __cfa_dbg_global_clusters;
-        extern size_t __cfa_page_size;
-        extern int __map_prot;
-}
+}
+
+extern size_t __page_size;
+extern int __map_prot;
 
 //-----------------------------------------------------------------------------
@@ -573 +574 @@
 }
 
+extern size_t __page_size;
 void ^?{}(processor & this) with( this ){
         /* paranoid */ verify( !__atomic_load_n(&do_terminate, __ATOMIC_ACQUIRE) );
@@ -738 +740 @@
         void * stack;
         #if CFA_PROCESSOR_USE_MMAP
-                stacksize = ceiling( stacksize, __cfa_page_size ) + __cfa_page_size;
+                stacksize = ceiling( stacksize, __page_size ) + __page_size;
                 stack = mmap(0p, stacksize, __map_prot, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
                 if(stack == ((void*)-1)) {
                         abort( "pthread stack creation : internal error, mmap failure, error(%d) %s.", errno, strerror( errno ) );
                 }
-                if ( mprotect( stack, __cfa_page_size, PROT_NONE ) == -1 ) {
+                if ( mprotect( stack, __page_size, PROT_NONE ) == -1 ) {
                         abort( "pthread stack creation : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
                 } // if
         #else
                 __cfaabi_dbg_debug_do(
-                        stack = memalign( __cfa_page_size, stacksize + __cfa_page_size );
+                        stack = memalign( __page_size, stacksize + __page_size );
                         // pthread has no mechanism to create the guard page in user supplied stack.
-                        if ( mprotect( stack, __cfa_page_size, PROT_NONE ) == -1 ) {
+                        if ( mprotect( stack, __page_size, PROT_NONE ) == -1 ) {
                                 abort( "mprotect : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
                         } // if
@@ -777 +779 @@
                 check( pthread_attr_getstacksize( &attr, &stacksize ), "pthread_attr_getstacksize" );
                 assert( stacksize >= PTHREAD_STACK_MIN );
-                stacksize += __cfa_page_size;
+                stacksize += __page_size;
 
                 if(munmap(stack, stacksize) == -1) {
@@ -785 +787 @@
                 __cfaabi_dbg_debug_do(
                         // pthread has no mechanism to create the guard page in user supplied stack.
-                        if ( mprotect( stack, __cfa_page_size, __map_prot ) == -1 ) {
+                        if ( mprotect( stack, __page_size, __map_prot ) == -1 ) {
                                 abort( "mprotect : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
                         } // if

libcfa/src/startup.cfa

@@ -27 +27 @@
         void __cfaabi_appready_startup( void ) {
                 tzset();                                                                                // initialize time global variables
-                #ifdef __CFA_DEBUG__FIXME
+                #ifdef __CFA_DEBUG__
                 extern void heapAppStart();
                 heapAppStart();
-                #endif // __CFA_DEBUG__FIXME
+                #endif // __CFA_DEBUG__
         } // __cfaabi_appready_startup
 
         void __cfaabi_appready_shutdown( void ) __attribute__(( destructor( STARTUP_PRIORITY_APPREADY ) ));
         void __cfaabi_appready_shutdown( void ) {
-                #ifdef __CFA_DEBUG__FIXME
+                #ifdef __CFA_DEBUG__
                 extern void heapAppStop();
                 heapAppStop();
-                #endif // __CFA_DEBUG__FIXME
+                #endif // __CFA_DEBUG__
         } // __cfaabi_appready_shutdown
 

libcfa/src/stdhdr/malloc.h

@@ -18 +18 @@
 } // extern "C"
 
-#include <heap.h>
+#include <heap.hfa>
 
 // Local Variables: //

libcfa/src/stdlib.hfa

@@ -21 +21 @@
 
 #include <stdlib.h>                                                                             // *alloc, strto*, ato*
-#include <heap.h>
+#include <heap.hfa>