Changes in uspace/lib/c/generic/malloc.c [21799398:6aeca0d] in mainline

File:

• uspace/lib/c/generic/malloc.c (modified) (13 diffs)

uspace/lib/c/generic/malloc.c

@@ -200 +200 @@
         do { \
                 if (!(expr)) {\
-                        futex_up(&malloc_futex); \
+                        heap_unlock(); \
                         assert_abort(#expr, __FILE__, __LINE__); \
                 } \
@@ -210 +210 @@
 
 #endif /* NDEBUG */
+
+
+#ifdef FUTEX_UPGRADABLE
+/** True if the heap may be accessed from multiple threads. */
+static bool multithreaded = false;
+
+/** Makes accesses to the heap thread safe. */
+void malloc_enable_multithreaded(void)
+{
+        multithreaded = true;
+}
+
+/** Serializes access to the heap from multiple threads. */
+static inline void heap_lock(void)
+{
+        if (multithreaded) {
+                futex_down(&malloc_futex);
+        } else {
+                /*
+                 * Malloc never switches fibrils while the heap is locked.
+                 * Similarly, it never creates new threads from within the 
+                 * locked region. Therefore, if there are no other threads 
+                 * except this one, the whole operation will complete without 
+                 * any interruptions.
+                 */
+        }
+}
+
+/** Serializes access to the heap from multiple threads. */
+static inline void heap_unlock(void)
+{
+        if (multithreaded) {
+                futex_up(&malloc_futex);
+        } else {
+                /*
+                 * Malloc never switches fibrils while the heap is locked.
+                 * Similarly, it never creates new threads from within the 
+                 * locked region. Therefore, if there are no other threads 
+                 * except this one, the whole operation will complete without 
+                 * any interruptions.
+                 */
+        }
+}
+
+#else
+
+/** Makes accesses to the heap thread safe. */
+void malloc_enable_multithreaded(void)
+{
+        /* No-op. Already using thread-safe heap locking operations. */
+}
+
+/** Serializes access to the heap from multiple threads. */
+static inline void heap_lock(void)
+{
+        futex_down(&malloc_futex);
+}
+
+/** Serializes access to the heap from multiple threads. */
+static inline void heap_unlock(void)
+{
+        futex_up(&malloc_futex);
+}
+#endif
+
 
 /** Initialize a heap block
@@ -289 +354 @@
         size_t asize = ALIGN_UP(size, PAGE_SIZE);
         void *astart = as_area_create(AS_AREA_ANY, asize,
-            AS_AREA_WRITE | AS_AREA_READ | AS_AREA_CACHEABLE);
+            AS_AREA_WRITE | AS_AREA_READ | AS_AREA_CACHEABLE, AS_AREA_UNPAGED);
         if (astart == AS_MAP_FAILED)
                 return false;
@@ -785 +850 @@
 void *malloc(const size_t size)
 {
-        futex_down(&malloc_futex);
+        heap_lock();
         void *block = malloc_internal(size, BASE_ALIGN);
-        futex_up(&malloc_futex);
-        
+        heap_unlock();
+
         return block;
 }
@@ -807 +872 @@
         size_t palign =
             1 << (fnzb(max(sizeof(void *), align) - 1) + 1);
-        
-        futex_down(&malloc_futex);
+
+        heap_lock();
         void *block = malloc_internal(size, palign);
-        futex_up(&malloc_futex);
-        
+        heap_unlock();
+
         return block;
 }
@@ -828 +893 @@
                 return malloc(size);
         
-        futex_down(&malloc_futex);
+        heap_lock();
         
         /* Calculate the position of the header. */
@@ -885 +950 @@
         }
         
-        futex_up(&malloc_futex);
+        heap_unlock();
         
         if (reloc) {
@@ -908 +973 @@
                 return;
         
-        futex_down(&malloc_futex);
+        heap_lock();
         
         /* Calculate the position of the header. */
@@ -953 +1018 @@
         heap_shrink(area);
         
-        futex_up(&malloc_futex);
+        heap_unlock();
 }
 
 void *heap_check(void)
 {
-        futex_down(&malloc_futex);
+        heap_lock();
         
         if (first_heap_area == NULL) {
-                futex_up(&malloc_futex);
+                heap_unlock();
                 return (void *) -1;
         }
@@ -975 +1040 @@
                     (((uintptr_t) area->start % PAGE_SIZE) != 0) ||
                     (((uintptr_t) area->end % PAGE_SIZE) != 0)) {
-                        futex_up(&malloc_futex);
+                        heap_unlock();
                         return (void *) area;
                 }
@@ -986 +1051 @@
                         /* Check heap block consistency */
                         if (head->magic != HEAP_BLOCK_HEAD_MAGIC) {
-                                futex_up(&malloc_futex);
+                                heap_unlock();
                                 return (void *) head;
                         }
@@ -994 +1059 @@
                         if ((foot->magic != HEAP_BLOCK_FOOT_MAGIC) ||
                             (head->size != foot->size)) {
-                                futex_up(&malloc_futex);
+                                heap_unlock();
                                 return (void *) foot;
                         }
@@ -1000 +1065 @@
         }
         
-        futex_up(&malloc_futex);
+        heap_unlock();
         
         return NULL;