MINZKN의 블로그

/*
 Copyright (C) JAEHYUK CHO
 All rights reserved.
 Code by JaeHyuk Cho <mailto:minzkn@minzkn.com>
*/

/* object index의 단위를 나타내는 변수형입니다.
   object수가 65536이상인 경우 이것은 좀 키워야 겠죠. */
typedef unsigned short int __mzslab_index_t;
#define mzslab_index_t __mzslab_index_t

#pragma pack(push,8)
typedef struct mzslab_ts {
    /* object 의 크기를 나타냅니다. */
    size_t object_size;
    /* object를 모두 합친 크기를 나타냅니다.
       런타임에서 계산할수는 있으나 미리 계산해두는것이 속도가 좋을듯 해서... */
    size_t objects_size;
    /* object 수를 나타냅니다. */
    size_t objects;
    /* 첫 object 의 포인터입니다.
       이 또한 런타임에 계산 가능하지만 미리... */
    unsigned char *entry;
    /* 첫번째 해제된 Object 의 index를 저장합니다.
       만약 이 값이 objects보다 같거나 크게 되면 할당가능한 object가 없게 됩니다. */
    mzslab_index_t f;
}__mzslab_t;
#define mzslab_t __mzslab_t
#pragma pack(pop)

mzslab_t * mzslab_init(void *s_page, size_t s_page_size, size_t s_object_size)
{
    size_t s_index;

    mzslab_t *s_slab;
    mzslab_index_t *s_nft; /* next free table */
    
    /* 넘겨받은 page의 첫 부분을 slab 구조체로 유지합니다. */
    s_slab = (mzslab_t *)s_page;
    
    s_slab->object_size = s_object_size;
    
    s_slab->objects_size = 
        s_page_size - (sizeof(mzslab_t) +
             ((((s_page_size - sizeof(mzslab_t)) / s_slab->object_size)) * sizeof(mzslab_index_t)));
    s_slab->objects = s_slab->objects_size / s_slab->object_size;

    /* 이 시점에서 
      (s_page_size - 
       ((s_slab->objects * 
         sizeof(mzslab_index_t)) + 
           s_slab->objects_size)) 가 0보다 큰값을 같게 되면 
      넘겨받은 page_size가 slab 구조와 정렬이 제대로 이루어지지 않아서
      남은 짜투리 메모리 크기가 됩니다.
     효율적인 구현을 위해서는 0이 되도록 해야 겠죠. */

    /* 여기서 (&s_slab[1]) 는 slab 의 다음 항목을 가르키게 되므로
       NextFreeObjectIndex table(nft) 을 가르키게 됩니다. */
    s_slab->entry = ((unsigned char *)(&s_slab[1])) + (s_slab->objects * sizeof(mzslab_index_t));

    s_slab->f = (mzslab_index_t)0u;
    
    s_nft = (mzslab_index_t *)(&s_slab[1]);
    for(s_index = ((size_t)0u);s_index < s_slab->objects;s_index++) {
        s_nft[s_index] = s_index + ((size_t)1u);
    }

    return(s_slab);
}

void * mzslab_alloc(mzslab_t *s_slab)
{
    mzslab_index_t *s_nft = (mzslab_index_t *)(&s_slab[1]);
    void *s_result;

    if(s_slab->f >= s_slab->objects) {
        /* 이 경우 메모리에 할당가능한 object가 없다고 판단하면 되겠습니다. */
        s_result = (void *)0;
    }
    else { /* 할당가능한 object가 있으므로 이를 반환합니다. */
        s_result = (void *)(&s_slab->entry[s_slab->f * s_slab->object_size]);
        s_slab->f = s_nft[s_slab->f];
    }

    return(s_result);
}

/* 원래 s_slab은 전역 cache테이블로 감추고
   s_ptr만으로 추출할수 있도록 구현하는게 바람직하지만
   현재 예제를 들기 위한 부분이기에 그냥 인자로 넘겨 받도록 하여 소개합니다. */
void * mzslab_free(mzslab_t *s_slab, void *s_ptr)
{
    mzslab_index_t *s_nft = (mzslab_index_t *)(&s_slab[1]);
    size_t s_index;

    s_index = (size_t)(((unsigned char *)s_ptr) - s_slab->entry) / s_slab->object_size;

    s_nft[s_index] = s_slab->f;
    s_slab->f = s_index;

    return((void *)0);
}