Changeset 794db28 for libcfa/src

Timestamp:

Aug 18, 2020, 11:35:50 AM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

93526ef

Parents:

d2b5d2d (diff), 36de20d (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

Location:

libcfa/src

Files:

• common.hfa (modified) (2 diffs)
• concurrency/coroutine.cfa (modified) (1 diff)
• concurrency/invoke.c (modified) (2 diffs)
• concurrency/invoke.h (modified) (1 diff)
• exception.c (modified) (1 diff)
• heap.cfa (modified) (3 diffs)
• stdlib.hfa (modified) (5 diffs)

libcfa/src/common.hfa

@@ -10 +10 @@
 // Created On       : Wed Jul 11 17:54:36 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jul 12 08:02:18 2018
-// Update Count     : 5
+// Last Modified On : Sat Aug 15 08:51:29 2020
+// Update Count     : 14
 // 
 
@@ -67 +67 @@
 
 static inline {
+        char min( char t1, char t2 ) { return t1 < t2 ? t1 : t2; } // optimization
+        intptr_t min( intptr_t t1, intptr_t t2 ) { return t1 < t2 ? t1 : t2; } // optimization
+        uintptr_t min( uintptr_t t1, uintptr_t t2 ) { return t1 < t2 ? t1 : t2; } // optimization
         forall( otype T | { int ?<?( T, T ); } )
         T min( T t1, T t2 ) { return t1 < t2 ? t1 : t2; }
 
+        char max( char t1, char t2 ) { return t1 > t2 ? t1 : t2; } // optimization
+        intptr_t max( intptr_t t1, intptr_t t2 ) { return t1 > t2 ? t1 : t2; } // optimization
+        uintptr_t max( uintptr_t t1, uintptr_t t2 ) { return t1 > t2 ? t1 : t2; } // optimization
         forall( otype T | { int ?>?( T, T ); } )
         T max( T t1, T t2 ) { return t1 > t2 ? t1 : t2; }

libcfa/src/concurrency/coroutine.cfa

@@ -215 +215 @@
                 return cor;
         }
+
+        struct $coroutine * __cfactx_cor_active(void) {
+                return active_coroutine();
+        }
 }
 

libcfa/src/concurrency/invoke.c

@@ -29 +29 @@
 // Called from the kernel when starting a coroutine or task so must switch back to user mode.
 
+extern struct $coroutine * __cfactx_cor_active(void);
 extern struct $coroutine * __cfactx_cor_finish(void);
 extern void __cfactx_cor_leave ( struct $coroutine * );
@@ -35 +36 @@
 extern void disable_interrupts() OPTIONAL_THREAD;
 extern void enable_interrupts( __cfaabi_dbg_ctx_param );
+
+struct exception_context_t * this_exception_context() {
+        return &__get_stack( __cfactx_cor_active() )->exception_context;
+}
 
 void __cfactx_invoke_coroutine(

libcfa/src/concurrency/invoke.h

@@ -98 +98 @@
         }
 
+        struct exception_context_t * this_exception_context();
+
         // struct which calls the monitor is accepting
         struct __waitfor_mask_t {

libcfa/src/exception.c

@@ -59 +59 @@
 
 
-// Temperary global exception context. Does not work with concurency.
-static struct exception_context_t shared_stack = {NULL, NULL};
-
 // Get the current exception context.
 // There can be a single global until multithreading occurs, then each stack
-// needs its own. It will have to be updated to handle that.
-struct exception_context_t * this_exception_context() {
+// needs its own. We get this from libcfathreads (no weak attribute).
+__attribute__((weak)) struct exception_context_t * this_exception_context() {
+        static struct exception_context_t shared_stack = {NULL, NULL};
         return &shared_stack;
 }

libcfa/src/heap.cfa

@@ -10 +10 @@
 // Created On       : Tue Dec 19 21:58:35 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Aug  9 12:23:20 2020
-// Update Count     : 894
+// Last Modified On : Wed Aug 12 16:43:38 2020
+// Update Count     : 902
 //
 
@@ -650 +650 @@
                 for ( HeapManager.Storage * p = freeLists[i].freeList; p != 0p; p = p->header.kind.real.next ) {
                 #else
-                for ( HeapManager.Storage * p = top( freeLists[i].freeList ); p != 0p; p = (p)`next->top ) {
+                // for ( HeapManager.Storage * p = top( freeLists[i].freeList ); p != 0p; p = (p)`next->top ) {
+                for ( HeapManager.Storage * p = top( freeLists[i].freeList ); p != 0p; /* p = getNext( p )->top */) {
+                        typeof(p) temp = (( p )`next)->top;                     // FIX ME: direct assignent fails, initialization works
+                        p = temp;
                 #endif // BUCKETLOCK
                         total += size;
@@ -1162 +1165 @@
                 choose( option ) {
                   case M_TOP_PAD:
-                        heapExpand = ceiling( value, pageSize ); return 1;
+                        heapExpand = ceiling2( value, pageSize ); return 1;
                   case M_MMAP_THRESHOLD:
                         if ( setMmapStart( value ) ) return 1;

libcfa/src/stdlib.hfa

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Aug 11 21:11:46 2020
-// Update Count     : 495
+// Last Modified On : Fri Aug 14 23:38:50 2020
+// Update Count     : 504
 //
 
@@ -39 +39 @@
 //---------------------------------------
 
+#include "common.hfa"
+
+//---------------------------------------
+
 // Macro because of returns
 #define $VAR_ALLOC( allocation, alignment ) \
@@ -152 +156 @@
         } // alloc_set
 
-        T * alloc_set( size_t dim, const T fill[] ) {
-                return (T *)memcpy( (T *)alloc( dim ), fill, dim * sizeof(T) ); // initialize with fill value
+        T * alloc_set( size_t dimNew, const T fill[], size_t dimOld ) {
+                return (T *)memcpy( (T *)alloc( dimNew ), fill, min( dimNew, dimOld ) * sizeof(T) ); // initialize with fill value
         } // alloc_set
 
@@ -220 +224 @@
         } // alloc_align_set
 
-        T * alloc_align_set( size_t align, size_t dim, const T fill[] ) {
-                return (T *)memcpy( (T *)alloc_align( align, dim ), fill, dim * sizeof(T) );
+        T * alloc_align_set( size_t align, size_t dimNew, const T fill[], size_t dimOld ) {
+                return (T *)memcpy( (T *)alloc_align( align, dimNew ), fill, min( dimNew, dimOld ) * sizeof(T) );
         } // alloc_align_set
 
@@ -374 +378 @@
 //---------------------------------------
 
-#include "common.hfa"
-
-//---------------------------------------
-
 extern bool threading_enabled(void) OPTIONAL_THREAD;