<div id="readability-page-1" class="page"><div>
		
MAX_NUMBER_OF_SLAB_CLASSES = 63 + 1로 정의됨
<pre title="">#!c
static slabclass_t slabclass[MAX_NUMBER_OF_SLAB_CLASSES];
</pre>
slabclass_t 구조체는 다음과 같다. slabclass 에서 list_size 는 
slab_list 의 capacity 이다. 그리고 slabs는 현재 몇개의 slab이 
할당되었는지는 나타낸다.(현재의 length)
<pre title="">#!c
typedef struct {
unsigned int size; /* sizes of items */
unsigned int perslab; /* how many items per slab */

void *slots; /* list of item ptrs */
unsigned int sl_curr; /* total free items in list */

unsigned int slabs; /* how many slabs were allocated for this class */

void **slab_list; /* array of slab pointers */
unsigned int list_size; /* size of prev array */

size_t requested; /* The number of requested bytes */
} slabclass_t;
</pre>
memcache 는 시작시에 factor 값에 의해서 사이즈 Range 별로 slabclass id를 가지도록 
설정한다. slabs_preallocate 을 이용해서 미리 메모리를 할당해둘 수 도 있다. 
이걸 이용하지 않으면 chunk 가 필요할 때 chunk를 할당한다. 기본 chunk size는 1MB이다.
<pre title="">#!c
#define CHUNK_ALIGN_BYTES 8
</pre>
CHUNK_ALIGN_BYTES = 8
<pre title="">#!c
void slabs_init(const size_t limit, const double factor, const bool prealloc) {
int i = POWER_SMALLEST - 1;
//default chunk_size = 48
//sizeof(item) = 48
//factor = 1.25
//item_size_max = 1024 * 1024
//POWER_SMALLEST = 1

unsigned int size = sizeof(item) + settings.chunk_size;

mem_limit = limit;

if (prealloc) {
/* Allocate everything in a big chunk with malloc */
mem_base = malloc(mem_limit);
if (mem_base != NULL) {
mem_current = mem_base;
mem_avail = mem_limit;
} else {
fprintf(stderr, "Warning: Failed to allocate requested memory in"
" one large chunk.\nWill allocate in smaller chunks\n");
}
}

memset(slabclass, 0, sizeof(slabclass));

while (++i &lt; MAX_NUMBER_OF_SLAB_CLASSES-1 &amp;&amp; size &lt;= settings.item_size_max / factor) {
/* Make sure items are always n-byte aligned */
if (size % CHUNK_ALIGN_BYTES)
size += CHUNK_ALIGN_BYTES - (size % CHUNK_ALIGN_BYTES);

slabclass[i].size = size;
slabclass[i].perslab = settings.item_size_max / slabclass[i].size;
size *= factor;
if (settings.verbose &gt; 1) {
fprintf(stderr, "slab class %3d: chunk size %9u perslab %7u\n",
i, slabclass[i].size, slabclass[i].perslab);
}
}

power_largest = i;
slabclass[power_largest].size = settings.item_size_max;
slabclass[power_largest].perslab = 1;
if (settings.verbose &gt; 1) {
fprintf(stderr, "slab class %3d: chunk size %9u perslab %7u\n",
i, slabclass[i].size, slabclass[i].perslab);
}

/* for the test suite: faking of how much we've already malloc'd */
{
char *t_initial_malloc = getenv("T_MEMD_INITIAL_MALLOC");
if (t_initial_malloc) {
mem_malloced = (size_t)atol(t_initial_malloc);
}

}

if (prealloc) {
slabs_preallocate(power_largest);
}
}
</pre>
slab size 초기화는 다음과 같이 이루어진다. 이 의미는 size가 96까지를 다루는 slabclass 
는 그 안에 10922개의 아이템을 저장할 수 있다는 의미이다.
<pre title="">size: 96 perslab: 10922
size: 120 perslab: 8738
size: 152 perslab: 6898
size: 192 perslab: 5461
size: 240 perslab: 4369
size: 304 perslab: 3449
size: 384 perslab: 2730
size: 480 perslab: 2184
size: 600 perslab: 1747
size: 752 perslab: 1394
size: 944 perslab: 1110
size: 1184 perslab: 885
size: 1480 perslab: 708
size: 1856 perslab: 564
size: 2320 perslab: 451
size: 2904 perslab: 361
size: 3632 perslab: 288
size: 4544 perslab: 230
size: 5680 perslab: 184
size: 7104 perslab: 147
size: 8880 perslab: 118
size: 11104 perslab: 94
size: 13880 perslab: 75
size: 17352 perslab: 60
size: 21696 perslab: 48
size: 27120 perslab: 38
size: 33904 perslab: 30
size: 42384 perslab: 24
size: 52984 perslab: 19
size: 66232 perslab: 15
size: 82792 perslab: 12
size: 103496 perslab: 10
size: 129376 perslab: 8
size: 161720 perslab: 6
size: 202152 perslab: 5
size: 252696 perslab: 4
size: 315872 perslab: 3
size: 394840 perslab: 2
size: 493552 perslab: 2
size: 616944 perslab: 1
size: 771184 perslab: 1
</pre>
이렇게 만들어진 slabclass 는 slabs_clsid 를 통해서 접근 할 수 있다. 인덱스를 
하나씩 증가하면 적절한 크기의 slabclass를 선택한다.
<pre title="">#!c
unsigned int slabs_clsid(const size_t size) {
int res = POWER_SMALLEST;

if (size == 0)
return 0;
while (size &gt; slabclass[res].size)
if (res++ == power_largest) /* won't fit in the biggest slab */
return 0;
return res;
}
</pre>
slabclass는 item 과도 관계가 있다. 실제 slab_alloc 은 item_alloc 이 호출될때 
호출되게 된다.
<pre title="">#!c
typedef unsigned int rel_time_t;

typedef struct _stritem {
/* Protected by LRU locks */
struct _stritem *next;
struct _stritem *prev;
/* Rest are protected by an item lock */
struct _stritem *h_next; /* hash chain next */
rel_time_t time; /* least recent access */
rel_time_t exptime; /* expire time */
int nbytes; /* size of data */
unsigned short refcount;
uint8_t nsuffix; /* length of flags-and-length string */
uint8_t it_flags; /* ITEM_* above */
uint8_t slabs_clsid;/* which slab class we're in */
uint8_t nkey; /* key length, w/terminating null and padding */
/* this odd type prevents type-punning issues when we do
* the little shuffle to save space when not using CAS. */
union {
uint64_t cas;
char end;
} data[];
/* if it_flags &amp; ITEM_CAS we have 8 bytes CAS */
/* then null-terminated key */
/* then " flags length\r\n" (no terminating null) */
/* then data with terminating \r\n (no terminating null; it's binary!) */
} item;
</pre>
최초 item 할당시에 당연히 slab 도 없기 때문에, do_slabs_newslab()를 호출하게 된다. 
SLAB_GLOBAL_PAGE_POOL 는 Reassignment를 위한 것이므로 최초에는 slabclass만 존재하고 
내부에 할당된 slab은 없음. get_page_from_global_pool() 에서도 데이터가 없으므로 실제 
메모리 할당은 memory_allocate 에 의해서 이루어진다.
<pre title="">#!c
static int do_slabs_newslab(const unsigned int id) {
slabclass_t *p = &amp;slabclass[id];
slabclass_t *g = &amp;slabclass[SLAB_GLOBAL_PAGE_POOL];
int len = settings.slab_reassign ? settings.item_size_max
: p-&gt;size * p-&gt;perslab;
char *ptr;

if ((mem_limit &amp;&amp; mem_malloced + len &gt; mem_limit &amp;&amp; p-&gt;slabs &gt; 0
&amp;&amp; g-&gt;slabs == 0)) {
mem_limit_reached = true;
MEMCACHED_SLABS_SLABCLASS_ALLOCATE_FAILED(id);
return 0;
}

if ((grow_slab_list(id) == 0) ||
(((ptr = get_page_from_global_pool()) == NULL) &amp;&amp;
((ptr = memory_allocate((size_t)len)) == 0))) {

MEMCACHED_SLABS_SLABCLASS_ALLOCATE_FAILED(id);
return 0;
}

memset(ptr, 0, (size_t)len);
split_slab_page_into_freelist(ptr, id);

p-&gt;slab_list[p-&gt;slabs++] = ptr;
MEMCACHED_SLABS_SLABCLASS_ALLOCATE(id);

return 1;
}
</pre>
할당된 메모리 ptr은 split_slab_page_into_freelist 에 의해서 초기화 된다.
<pre title="">#!c
static void split_slab_page_into_freelist(char *ptr, const unsigned int id) {
slabclass_t *p = &amp;slabclass[id];
int x;
for (x = 0; x &lt; p-&gt;perslab; x++) {
do_slabs_free(ptr, 0, id);
ptr += p-&gt;size;
}
}
</pre>
p-&gt;size는 slabclass item의 크기이므로 그 값만큼 증가하면서 do_slabs_free 를 호출해서 
item을 저장할 수 있는 형태로 정보를 저장한다. ptr 이 p-&gt;size 만큼 계속 증가하는데 주목하자.
<pre title="">#!c
static void do_slabs_free(void *ptr, const size_t size, unsigned int id) {
slabclass_t *p;
item *it;

assert(id &gt;= POWER_SMALLEST &amp;&amp; id &lt;= power_largest);
if (id &lt; POWER_SMALLEST || id &gt; power_largest)
return;

MEMCACHED_SLABS_FREE(size, id, ptr);
p = &amp;slabclass[id];

it = (item *)ptr;
it-&gt;it_flags = ITEM_SLABBED;
it-&gt;slabs_clsid = 0;
it-&gt;prev = 0;
it-&gt;next = p-&gt;slots;
if (it-&gt;next) it-&gt;next-&gt;prev = it;
p-&gt;slots = it;

p-&gt;sl_curr++;
p-&gt;requested -= size;
return;
}
</pre>
p는 slabclass, it는 해당 ptr의 메모리 영역이다. p-&gt;slots는 기존에 할당된 item list를 
가리키는 포인터이다. 즉 it-&gt;next 로 현재의 it-&gt;next 에 기존의 item list를 저장하고, 
기존의 item list의 prev는 새롭게 추가될 it가 된다. 그리고 다시 p-&gt;slots은 it를 가리키게 
되므로, linked list로 slabclass에 할당되는 모든 item들이 double linked list 형식으로 
저장되게 된다.(실제로 메모리 할당은 item_max_size 형태로 할당되지만… 논리적으로 이어진다.)
				</div></div>

Charsyam's Blog

slab
MAX_NUMBER_OF_SLAB_CLASSES = 63 + 1로 정의됨
slabclass_t 구조체는 다음과 같다. slabclass 에서 list_size 는
memcache 는 시작시에 factor 값에 의해서 사이즈 Range 별로 slabclass id를 가지도록
CHUNK_ALIGN_BYTES = 8
slab size 초기화는 다음과 같이 이루어진다. 이 의미는 size가 96까지를 다루는 slabclass
이렇게 만들어진 slabclass 는 slabs_clsid 를 통해서 접근 할 수 있다. 인덱스를
slabclass는 item 과도 관계가 있다. 실제 slab_alloc 은 item_alloc 이 호출될때
최초 item 할당시에 당연히 slab 도 없기 때문에, do_slabs_newslab()를 호출하게 된다.
할당된 메모리 ptr은 split_slab_page_into_freelist 에 의해서 초기화 된다.
p->size는 slabclass item의 크기이므로 그 값만큼 증가하면서 do_slabs_free 를 호출해서
p는 slabclass, it는 해당 ptr의 메모리 영역이다. p->slots는 기존에 할당된 item list를
가리키는 포인터이다. 즉 it->next 로 현재의 it->next 에 기존의 item list를 저장하고,
기존의 item list의 prev는 새롭게 추가될 it가 된다. 그리고 다시 p->slots은 it를 가리키게
되므로, linked list로 slabclass에 할당되는 모든 item들이 double linked list 형식으로
저장되게 된다.(실제로 메모리 할당은 item_max_size 형태로 할당되지만… 논리적으로 이어진다.)

[입 개발] memcached slab 구조

댓글