Changes in uspace/lib/c/generic/malloc.c [3e6a98c5:5b46ec8] in mainline

File:

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

uspace/lib/c/generic/malloc.c

@@ -67 +67 @@
 /** Heap shrink granularity
  *
- * Try not to pump and stress the heap to much
+ * Try not to pump and stress the heap too much
  * by shrinking and enlarging it too often.
- * A heap area won't shrunk if it the released
+ * A heap area won't shrink if the released
  * free block is smaller than this constant.
  *
@@ -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. */
@@ -863 +928 @@
                 ptr = ((void *) head) + sizeof(heap_block_head_t);
         } else {
+                heap_block_head_t *next_head =
+                    (heap_block_head_t *) (((void *) head) + head->size);
+                bool have_next = ((void *) next_head < area->end);
+
+                if (((void *) head) + real_size > area->end) {
+                        /*
+                         * The current area is too small to hold the resized
+                         * block. Make sure there are no used blocks standing
+                         * in our way and try to grow the area using real_size
+                         * as a safe upper bound.
+                         */
+
+                        bool have_next_next;
+
+                        if (have_next) {
+                                have_next_next = (((void *) next_head) +
+                                    next_head->size < area->end);
+                        }
+                        if (!have_next || (next_head->free && !have_next_next)) {
+                                /*
+                                 * There is no next block in this area or
+                                 * it is a free block and there is no used
+                                 * block following it. There can't be any
+                                 * free block following it either as
+                                 * two free blocks would be merged.
+                                 */
+                                (void) area_grow(area, real_size);
+                        }
+                }
+                
                 /*
                  * Look at the next block. If it is free and the size is
-                 * sufficient then merge the two. Otherwise just allocate
-                 * a new block, copy the original data into it and
-                 * free the original block.
+                 * sufficient then merge the two. Otherwise just allocate a new
+                 * block, copy the original data into it and free the original
+                 * block.
                  */
-                heap_block_head_t *next_head =
-                    (heap_block_head_t *) (((void *) head) + head->size);
-                
-                if (((void *) next_head < area->end) &&
-                    (head->size + next_head->size >= real_size) &&
-                    (next_head->free)) {
+
+                if (have_next && (head->size + next_head->size >= real_size) &&
+                    next_head->free) {
                         block_check(next_head);
-                        block_init(head, head->size + next_head->size, false, area);
+                        block_init(head, head->size + next_head->size, false,
+                            area);
                         split_mark(head, real_size);
                         
                         ptr = ((void *) head) + sizeof(heap_block_head_t);
                         next_fit = NULL;
-                } else
+                } else {
                         reloc = true;
-        }
-        
-        futex_up(&malloc_futex);
+                }
+        }
+        
+        heap_unlock();
         
         if (reloc) {
@@ -908 +1002 @@
                 return;
         
-        futex_down(&malloc_futex);
+        heap_lock();
         
         /* Calculate the position of the header. */
@@ -953 +1047 @@
         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 +1069 @@
                     (((uintptr_t) area->start % PAGE_SIZE) != 0) ||
                     (((uintptr_t) area->end % PAGE_SIZE) != 0)) {
-                        futex_up(&malloc_futex);
+                        heap_unlock();
                         return (void *) area;
                 }
@@ -986 +1080 @@
                         /* Check heap block consistency */
                         if (head->magic != HEAP_BLOCK_HEAD_MAGIC) {
-                                futex_up(&malloc_futex);
+                                heap_unlock();
                                 return (void *) head;
                         }
@@ -994 +1088 @@
                         if ((foot->magic != HEAP_BLOCK_FOOT_MAGIC) ||
                             (head->size != foot->size)) {
-                                futex_up(&malloc_futex);
+                                heap_unlock();
                                 return (void *) foot;
                         }
@@ -1000 +1094 @@
         }
         
-        futex_up(&malloc_futex);
+        heap_unlock();
         
         return NULL;