Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/malloc.c

    r3019612 r13f2461  
    7979        (sizeof(heap_block_head_t) + sizeof(heap_block_foot_t))
    8080
    81 /** Overhead of each area. */
    82 #define AREA_OVERHEAD(size) \
    83         (ALIGN_UP(size + sizeof(heap_area_t), BASE_ALIGN))
    84 
    8581/** Calculate real size of a heap block.
    8682 *
    … …  
    187183
    188184/** Next heap block to examine (next fit algorithm) */
    189 static heap_block_head_t *next_fit = NULL;
     185static heap_block_head_t *next = NULL;
    190186
    191187/** Futex for thread-safe heap manipulation */
    … …  
    198194                if (!(expr)) {\
    199195                        futex_up(&malloc_futex); \
    200                         assert_abort(#expr, __FILE__, __LINE__); \
     196                        assert_abort(#expr, __FILE__, STR2(__LINE__)); \
    201197                } \
    202198        } while (0)
    … …  
    382378       
    383379        /* Eventually try to create a new area */
    384         return area_create(AREA_OVERHEAD(size));
     380        return area_create(AREA_FIRST_BLOCK_HEAD(size));
    385381}
    386382
    … …  
    459455                        /* Update heap area parameters */
    460456                        area->end = end;
    461                         size_t excess = ((size_t) area->end) - ((size_t) last_head);
     457                       
     458                        /* Update block layout */
     459                        void *last = (void *) last_head;
     460                        size_t excess = (size_t) (area->end - last);
    462461                       
    463462                        if (excess > 0) {
    … …  
    468467                                         * create a new free block.
    469468                                         */
    470                                         block_init((void *) last_head, excess, true, area);
     469                                        block_init(last, excess, true, area);
    471470                                } else {
    472471                                        /*
    … …  
    487486        }
    488487       
    489         next_fit = NULL;
     488        next = NULL;
    490489}
    491490
    … …  
    576575                                split_mark(cur, real_size);
    577576                               
    578                                 next_fit = cur;
     577                                next = cur;
    579578                                return addr;
    580579                        } else {
    … …  
    628627                                                split_mark(next_head, real_size);
    629628                                               
    630                                                 next_fit = next_head;
     629                                                next = next_head;
    631630                                                return aligned;
    632631                                        } else {
    … …  
    654653                                                        split_mark(cur, real_size);
    655654                                                       
    656                                                         next_fit = cur;
     655                                                        next = cur;
    657656                                                        return aligned;
    658657                                                }
    … …  
    692691       
    693692        /* Try the next fit approach */
    694         split = next_fit;
     693        split = next;
    695694       
    696695        if (split != NULL) {
    … …  
    848847                       
    849848                        ptr = ((void *) head) + sizeof(heap_block_head_t);
    850                         next_fit = NULL;
     849                        next = NULL;
    851850                } else
    852851                        reloc = true;
    … …  
    873872void free(const void *addr)
    874873{
    875         if (addr == NULL)
    876                 return;
    877 
    878874        futex_down(&malloc_futex);
    879875       
Note: See TracChangeset for help on using the changeset viewer.