jun-wiki

static void *find_fit(size_t asize) {
    for (void *bp = free_head; bp != NULL; bp = GET_SUCC(bp)) {
        if (GET_SIZE(HDRP(bp)) >= asize) return bp;
    }
    return NULL;
}

🔽🔽🔽🔽🔽🔽🔽🔽🔽🔽
           전환
🔽🔽🔽🔽🔽🔽🔽🔽🔽🔽

static void *find_fit(size_t asize) {
    void *best = NULL;
    size_t best_size = __SIZE_MAX__;
    for (void *bp = free_head; bp != NULL; bp = GET_SUCC(bp)) {
        size_t csize = GET_SIZE(HDRP(bp));   // 매 반복마다 갱신
        if (csize < asize) continue;

        // 완벽 적합 → 즉시 반환
        if (csize == asize) return bp;

        // 더 작은 후보면 갱신
        if (csize < best_size) {
            best = bp;
            best_size = csize;

        // 남는 조각이 분할 불가면 사실상 perfect fit로 보고 바로 선택
        if (best_size - asize < MIN_BLOCK) return best;
        }
    }
    return best; // 없으면 NULL
}

    // 좌측 확장
    if (!GET_PREV_ALLOC(HDRP(ptr))) {           
        void *prev = PREV_BLKP(ptr);
        if (!GET_ALLOC(HDRP(prev))) {
            size_t psize = GET_SIZE(HDRP(prev));
            if (psize + oldsize >= asize) {
                UNLINK(prev);
                size_t copysize = (size < payload) ? size : payload;
                memmove(prev, ptr, copysize);
                PUT(HDRP(prev), PACK(psize + oldsize, GET_PREV_ALLOC(HDRP(prev)) | FL_ALLOC));
                split_tail(prev, asize);
                return prev;
            }
            /* 우측도 확장 (양쪽 확장) */
            if (!GET_ALLOC(HDRP(next))) {
                size_t nsize = GET_SIZE(HDRP(next));
                if (psize + oldsize + nsize >= asize) {
                    UNLINK(prev);
                    UNLINK(next);
                    size_t combined = psize + oldsize + nsize;
                    size_t copySize = (size < payload) ? size : payload;
                    memmove(prev, ptr, copySize);
                    PUT(HDRP(prev), PACK(combined, GET_PREV_ALLOC(HDRP(prev)) | FL_ALLOC));
                    split_tail(prev, asize);
                    return prev;
                }
            }
        }
    }

trace  valid  util     ops      secs  Kops
 0       yes   99%    5694  0.000138 41351
 1       yes   99%    5848  0.000150 39013
 2       yes   99%    6648  0.000217 30608
 3       yes   99%    5380  0.000119 45363
 4       yes   66%   14400  0.000105137667
 5       yes   96%    4800  0.003092  1553
 6       yes   95%    4800  0.002975  1614
 7       yes   55%   12000  0.009536  1258
 8       yes   51%   24000  0.032589   736
 9       yes   41%   14401  0.000244 58924
10       yes   45%   14401  0.000141102280
Total          77%  112372  0.049304  2279

Perf index = 46 (util) + 40 (thru) = 86/100

#define ALLOC_OVERHEAD WSIZE

static inline size_t req_asize(size_t size) {
    size_t a = ALIGN(size + ALLOC_OVERHEAD);   /* 헤더만 포함 */
    if (a < MIN_BLOCK) a = MIN_BLOCK;          /* 최소 자유블록 크기 보장 */
    return a;
}

void *mm_malloc(size_t size) {
    if (size == 0) return NULL;
//  size_t asize = MAX(MIN_BLOCK, ALIGN(size + OVERHEAD)); 이거에서
    size_t asize = req_asize(size);               //    << 이걸로
    ...
}

void *mm_realloc(void *ptr, size_t size) {
    ...
    size_t oldsize    = GET_SIZE(HDRP(ptr));
//  size_t payload = oldsize - OVERHEAD;       OVERHEAD = 2*WSIZE
    size_t oldpayload = oldsize - WSIZE;       // WSIZE하나로 교체
//  size_t asize = MAX(MIN_BLOCK, ALIGN(size + OVERHEAD));  이거에서
    size_t asize      = req_asize(size);           //    << 이걸로
    ...
}

if (extend_heap((asize + WSIZE - 1) / WSIZE) != NULL)

size_t need = asize - oldsize;
if (extend_heap((need + WSIZE - 1) / WSIZE) != NULL)

extendsize = MAX(asize, CHUNKSIZE);
if ((bp = extend_heap(extendsize/WSIZE)) == NULL)
    return NULL;
place(bp, asize);
return bp;

🔽🔽🔽🔽🔽🔽🔽🔽🔽
         변경
🔽🔽🔽🔽🔽🔽🔽🔽🔽

extendsize = asize;
if ((bp = extend_heap((extendsize + WSIZE - 1)/WSIZE)) == NULL)
    return NULL;
place(bp, asize);
return bp;