Changeset 207533f in mainline


Ignore:
Timestamp:
2011-05-23T13:31:10Z (13 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
d8de5d3
Parents:
34efa8a
Message:

make the code slightly more readable (no change in actual functionality)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/c/generic/malloc.c

    r34efa8a r207533f  
    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
    8185/** Calculate real size of a heap block.
    8286 *
     
    183187
    184188/** Next heap block to examine (next fit algorithm) */
    185 static heap_block_head_t *next = NULL;
     189static heap_block_head_t *next_fit = NULL;
    186190
    187191/** Futex for thread-safe heap manipulation */
     
    378382       
    379383        /* Eventually try to create a new area */
    380         return area_create(AREA_FIRST_BLOCK_HEAD(size));
     384        return area_create(AREA_OVERHEAD(size));
    381385}
    382386
     
    455459                        /* Update heap area parameters */
    456460                        area->end = end;
    457                        
    458                         /* Update block layout */
    459                         void *last = (void *) last_head;
    460                         size_t excess = (size_t) (area->end - last);
     461                        size_t excess = ((size_t) area->end) - ((size_t) last_head);
    461462                       
    462463                        if (excess > 0) {
     
    467468                                         * create a new free block.
    468469                                         */
    469                                         block_init(last, excess, true, area);
     470                                        block_init((void *) last_head, excess, true, area);
    470471                                } else {
    471472                                        /*
     
    486487        }
    487488       
    488         next = NULL;
     489        next_fit = NULL;
    489490}
    490491
     
    575576                                split_mark(cur, real_size);
    576577                               
    577                                 next = cur;
     578                                next_fit = cur;
    578579                                return addr;
    579580                        } else {
     
    627628                                                split_mark(next_head, real_size);
    628629                                               
    629                                                 next = next_head;
     630                                                next_fit = next_head;
    630631                                                return aligned;
    631632                                        } else {
     
    653654                                                        split_mark(cur, real_size);
    654655                                                       
    655                                                         next = cur;
     656                                                        next_fit = cur;
    656657                                                        return aligned;
    657658                                                }
     
    691692       
    692693        /* Try the next fit approach */
    693         split = next;
     694        split = next_fit;
    694695       
    695696        if (split != NULL) {
     
    847848                       
    848849                        ptr = ((void *) head) + sizeof(heap_block_head_t);
    849                         next = NULL;
     850                        next_fit = NULL;
    850851                } else
    851852                        reloc = true;
Note: See TracChangeset for help on using the changeset viewer.