Changeset 5614a191

Timestamp:

Feb 17, 2022, 12:56:46 PM (3 years ago)

Author:

m3zulfiq <m3zulfiq@…>

Branches:

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

Children:

8ee163e2

Parents:

3263e2a4

Message:

removed old memory allocator and replaced it with the concurrent allocator

Location:

libcfa/src

Files:

• Makefile.am (modified) (3 diffs)
• concurrency/coroutine.cfa (modified) (4 diffs)
• concurrency/kernel/startup.cfa (modified) (5 diffs)
• heap.cc (added)
• heap.cfa (deleted)
• heap.h (added)
• heap.hfa (deleted)
• 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 \
@@ -102 +101 @@
         startup.hfa \
         virtual.c \
-        virtual.h
+        virtual.h \
+        heap.cc \
+        heap.h
 
 # not all platforms support concurrency, add option do disable it
@@ -172 +173 @@
 
 -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 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 ) );
                         }

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 __page_size;
-extern int __map_prot;
+        extern size_t __cfa_page_size;
+        extern int __map_prot;
+}
 
 //-----------------------------------------------------------------------------
@@ -574 +573 @@
 }
 
-extern size_t __page_size;
 void ^?{}(processor & this) with( this ){
         /* paranoid */ verify( !__atomic_load_n(&do_terminate, __ATOMIC_ACQUIRE) );
@@ -740 +738 @@
         void * stack;
         #if CFA_PROCESSOR_USE_MMAP
-                stacksize = ceiling( stacksize, __page_size ) + __page_size;
+                stacksize = ceiling( stacksize, __cfa_page_size ) + __cfa_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, __page_size, PROT_NONE ) == -1 ) {
+                if ( mprotect( stack, __cfa_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( __page_size, stacksize + __page_size );
+                        stack = memalign( __cfa_page_size, stacksize + __cfa_page_size );
                         // pthread has no mechanism to create the guard page in user supplied stack.
-                        if ( mprotect( stack, __page_size, PROT_NONE ) == -1 ) {
+                        if ( mprotect( stack, __cfa_page_size, PROT_NONE ) == -1 ) {
                                 abort( "mprotect : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
                         } // if
@@ -779 +777 @@
                 check( pthread_attr_getstacksize( &attr, &stacksize ), "pthread_attr_getstacksize" );
                 assert( stacksize >= PTHREAD_STACK_MIN );
-                stacksize += __page_size;
+                stacksize += __cfa_page_size;
 
                 if(munmap(stack, stacksize) == -1) {
@@ -787 +785 @@
                 __cfaabi_dbg_debug_do(
                         // pthread has no mechanism to create the guard page in user supplied stack.
-                        if ( mprotect( stack, __page_size, __map_prot ) == -1 ) {
+                        if ( mprotect( stack, __cfa_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__
+                #ifdef __CFA_DEBUG__FIXME
                 extern void heapAppStart();
                 heapAppStart();
-                #endif // __CFA_DEBUG__
+                #endif // __CFA_DEBUG__FIXME
         } // __cfaabi_appready_startup
 
         void __cfaabi_appready_shutdown( void ) __attribute__(( destructor( STARTUP_PRIORITY_APPREADY ) ));
         void __cfaabi_appready_shutdown( void ) {
-                #ifdef __CFA_DEBUG__
+                #ifdef __CFA_DEBUG__FIXME
                 extern void heapAppStop();
                 heapAppStop();
-                #endif // __CFA_DEBUG__
+                #endif // __CFA_DEBUG__FIXME
         } // __cfaabi_appready_shutdown
 

libcfa/src/stdhdr/malloc.h

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

libcfa/src/stdlib.hfa

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