Memcached源码分析之slabs.c

红太狼 2021-12-22 15:09 246阅读 0赞

1.  \#include"memcached.h"
2.  \#include<sys/stat.h>
3.  \#include<sys/socket.h>
4.  \#include<sys/signal.h>
5.  \#include<sys/resource.h>
6.  \#include<fcntl.h>
7.  \#include<netinet/in.h>
8.  \#include<errno.h>
9.  \#include<stdlib.h>
10. \#include<stdio.h>
11. \#include<string.h>
12. \#include<assert.h>
13. \#include<pthread.h>
14. 
15. typedefstruct\{ 
16. unsignedint size;/\* sizes of items \*///item或者说chunk的大小
17. unsignedint perslab;/\* how many items per slab \*///每个slab有多少个item，slab又称“页”
18. 
19. /\*\*
20. 当前slabclass的空闲item链表，也是可用item链表，当前slabclass一切可以用的内存空间都在此，
21. 这里是内存分配的入口，分配内存的时候都是在这个链表上挤一个出去。
22. 
23. ps：memcached的新版本才开始把slots作为“所有空闲的item链接”的用途，以前的版本slots链表保存的是“回收的item”的意思，
24. 而旧版本新分配的slab，是用end\_page\_ptr指针及end\_page\_free来控制，此版本已不用。
25. \*/
26. void\*slots;/\* list of item ptrs \*/
27. unsignedint sl\_curr;/\* total free items in list \*///当前slabclass还剩多少空闲的item，即上面的slots数
28. 
29. unsignedint slabs;/\* how many slabs were allocated for this class \*///这个slabclass分配了多少个slab了
30. 
31. /\*\*
32. slab\_list是这个slabclass下的slabs列表，逻辑上是一个数组，每个元素是一个slab指针。
33. list\_size是slab\_list的元素个数。
34. 注意这个list\_size和上面的slabs的不同：
35. 由于slab\_list是一个空间大小固定的数组，是数组！而list\_size是这个数组元素的个数，代表slab\_list的空间大小。
36. slabs代表已经分配出去的slabs数，list\_size则代表可以有多少个slabs数
37. 所以当slabs等于list\_size的时候代表这个slab\_list已经满了，得增大空间。
38. 
39. \*/
40. void\*\*slab\_list;/\* array of slab pointers \*/
41. unsignedint list\_size;/\* size of prev array \*/
42. 
43. unsignedint killing;/\* index+1 of dying slab, or zero if none \*/
44. size\_t requested;/\* The number of requested bytes \*/
45. \}slabclass\_t;
46. 
47. staticslabclass\_t slabclass\[MAX\_NUMBER\_OF\_SLAB\_CLASSES\];
48. staticsize\_t mem\_limit =0;//内存上限
49. staticsize\_t mem\_malloced =0;//已分配的内存
50. staticint power\_largest;
51. 
52. staticvoid\*mem\_base = NULL;//预分配的内存空间
53. staticvoid\*mem\_current = NULL;
54. staticsize\_t mem\_avail =0;
55. 
56. staticpthread\_mutex\_t slabs\_lock = PTHREAD\_MUTEX\_INITIALIZER;
57. staticpthread\_mutex\_t slabs\_rebalance\_lock = PTHREAD\_MUTEX\_INITIALIZER;
58. 
59. staticint do\_slabs\_newslab(constunsignedint id);
60. staticvoid\*memory\_allocate(size\_t size);
61. staticvoid do\_slabs\_free(void\*ptr,constsize\_t size,unsignedint id);
62. 
63. staticvoid slabs\_preallocate (constunsignedint maxslabs);
64. 
65. //根据item大小找到合适的slabclass
66. unsignedint slabs\_clsid(constsize\_t size)\{ 
67. int res = POWER\_SMALLEST;
68. 
69. if(size ==0)
70. return0;
71. while(size > slabclass\[res\].size)
72. if(res\++== power\_largest)/\* won't fit in the biggest slab \*/
73. return0;
74. return res;
75. \}
76. 
77. /\*\*
78. 初始化slabs，这里会对一些内存管理进行初始化
79. \*/
80. void slabs\_init(constsize\_t limit,constdouble factor,constbool prealloc)\{ 
81. int i = POWER\_SMALLEST \-1;
82. unsignedint size =sizeof(item)\+ settings.chunk\_size;
83. 
84. mem\_limit = limit;//这个limit就是启动时候用户设置的-m xx中的xx，最大的内存上限
85. 
86. if(prealloc)\{ 
87. /\*\*
88. 如果用户开启了预分配，则先把上限的内存先分配出来，放到mem\_base全局变量中。
89. 所以这个时候服务就拥有了一大坨内存，以后要分配的内存都是从这一坨里面割下来。
90. \*/
91. mem\_base = malloc(mem\_limit);
92. if(mem\_base != NULL)\{ 
93. mem\_current = mem\_base;
94. mem\_avail = mem\_limit;
95. \}else\{ 
96. fprintf(stderr,"Warning: Failed to allocate requested memory in"
97. " one large chunk.\\nWill allocate in smaller chunks\\n");
98. \}
99. \}
100. 
101. //下面是初始化各个slabclass对象
102. memset(slabclass,0,sizeof(slabclass));
103. 
104. while(++i < POWER\_LARGEST && size <= settings.item\_size\_max / factor)\{ 
105. /\* Make sure items are always n-byte aligned \*/
106. if(size % CHUNK\_ALIGN\_BYTES)
107. size \+= CHUNK\_ALIGN\_BYTES \-(size % CHUNK\_ALIGN\_BYTES);
108. 
109. slabclass\[i\].size = size;
110. slabclass\[i\].perslab = settings.item\_size\_max / slabclass\[i\].size;
111. size \*= factor;
112. if(settings.verbose >1)\{ 
113. fprintf(stderr,"slab class %3d: chunk size %9u perslab %7u\\n",
114. i, slabclass\[i\].size, slabclass\[i\].perslab);
115. \}
116. \}
117. 
118. power\_largest = i;
119. slabclass\[power\_largest\].size = settings.item\_size\_max;
120. slabclass\[power\_largest\].perslab =1;
121. if(settings.verbose >1)\{ 
122. fprintf(stderr,"slab class %3d: chunk size %9u perslab %7u\\n",
123. i, slabclass\[i\].size, slabclass\[i\].perslab);
124. \}
125. 
126. \{ 
127. char\*t\_initial\_malloc = getenv("T\_MEMD\_INITIAL\_MALLOC");
128. if(t\_initial\_malloc)\{ 
129. mem\_malloced =(size\_t)atol(t\_initial\_malloc);
130. \}
131. 
132. \}
133. 
134. if(prealloc)\{ 
135. slabs\_preallocate(power\_largest);
136. \}
137. \}
138. 
139. /\*\*
140. 内存预分配，如果用户开启了预分配，则会调用此方法，先从mem\_base为分每个slabclass割一个slab大小下来。
141. \*/
142. staticvoid slabs\_preallocate (constunsignedint maxslabs)\{ 
143. int i;
144. unsignedint prealloc =0;
145. 
146. for(i = POWER\_SMALLEST; i <= POWER\_LARGEST; i\++)\{ 
147. if(++prealloc > maxslabs)
148. return;
149. if(do\_slabs\_newslab(i)==0)\{ 
150. fprintf(stderr,"Error while preallocating slab memory!\\n"
151. "If using -L or other prealloc options, max memory must be "
152. "at least %d megabytes.\\n", power\_largest);
153. exit(1);
154. \}
155. \}
156. 
157. \}
158. 
159. staticint grow\_slab\_list (constunsignedint id)\{ 
160. slabclass\_t\*p =&slabclass\[id\];
161. /\*\*
162. p->slab\_list是一个空间大小固定的数组，是数组！而list\_size是这个数组分配的空间。
163. p->slabs代表已经分配出去的slabs数
164. 而p->list\_size代表可以用多少个slabs数
165. 所以当slabs等于list\_size的时候代表这个slab\_list已经满了，得增大空间。
166. \*/
167. if(p\->slabs == p\->list\_size)\{ 
168. size\_t new\_size =(p\->list\_size !=0)? p\->list\_size \*2:16;
169. void\*new\_list = realloc(p\->slab\_list, new\_size \*sizeof(void\*));//
170. if(new\_list ==0)return0;
171. p\->list\_size = new\_size;
172. p\->slab\_list = new\_list;
173. \}
174. return1;
175. \}
176. 
177. /\*\*
178. 把整个slab打散成一个个（也叫chunk）放到相应的slots链表中
179. \*/
180. staticvoid split\_slab\_page\_into\_freelist(char\*ptr,constunsignedint id)\{ 
181. slabclass\_t\*p =&slabclass\[id\];
182. int x;
183. for(x =0; x < p\->perslab; x\++)\{ 
184. do\_slabs\_free(ptr,0, id);//这个函数主要作用是让当前item空间可用，即加到slots链表中。
185. ptr \+= p\->size;
186. \}
187. \}
188. 
189. /\*\*
190. 为slabclass\[id\]分配新的slab，仅当当前的slabclass中slots没有空闲的空间才调用
191. 此函数分配新的slab
192. \*/
193. staticint do\_slabs\_newslab(constunsignedint id)\{ 
194. slabclass\_t\*p =&slabclass\[id\];
195. int len = settings.slab\_reassign ? settings.item\_size\_max
196. : p\->size \* p\->perslab;//先判断是否开启了自定义slab大小，如果没有就按默认的，即约1M
197. char\*ptr;
198. 
199. /\*\*
200. 下面if的逻辑是：
201. 如果内存超出了限制，分配失败进入if，返回0
202. 否则调用grow\_slab\_list检查是否要增大slab\_list的大小
203. 如果在grow\_slab\_list返回失败，则不继续分配空间，进入if，返回0
204. 否则分配空间memory\_allocate，如果分配失败，同样进入if，返回0；
205. \*/
206. if((mem\_limit && mem\_malloced \+ len > mem\_limit && p\->slabs >0)||
207. (grow\_slab\_list(id)==0)||
208. ((ptr = memory\_allocate((size\_t)len))==0))\{ 
209. 
210. MEMCACHED\_SLABS\_SLABCLASS\_ALLOCATE\_FAILED(id);
211. return0;
212. \}
213. 
214. memset(ptr,0,(size\_t)len);//清干净内存空间
215. split\_slab\_page\_into\_freelist(ptr, id);//把新申请的slab放到slots中去
216. 
217. p\->slab\_list\[p\->slabs\++\]= ptr;//把新的slab加到slab\_list数组中
218. mem\_malloced \+= len;//记下已分配的空间大小
219. MEMCACHED\_SLABS\_SLABCLASS\_ALLOCATE(id);
220. 
221. return1;
222. \}
223. 
224. /\*\*
225. 根据item大小和slabsclass分配空间
226. \*/
227. staticvoid\*do\_slabs\_alloc(constsize\_t size,unsignedint id)\{ 
228. slabclass\_t\*p;
229. void\*ret = NULL;
230. item \*it = NULL;
231. 
232. if(id < POWER\_SMALLEST || id > power\_largest)\{ //默认最大是200，最小是1
233. MEMCACHED\_SLABS\_ALLOCATE\_FAILED(size,0);
234. return NULL;
235. \}
236. 
237. p =&slabclass\[id\];//slabclass是一个全局变量，是各个slabclass对象数组，在这取得当前id对应的slabclass
238. assert(p\->sl\_curr ==0||((item \*)p\->slots)->slabs\_clsid ==0);
239. 
240. /\* fail unless we have space at the end of a recently allocated page,
241. we have something on our freelist, or we could allocate a new page \*/
242. /\*\*
243. 下面这个if的逻辑相当于：
244. 如果p->sl\_curr==0，即slots链表中没有空闲的空间，则do\_slabs\_newslab分配新slab
245. 如果p->sl\_curr==0，且do\_slabs\_newslab分配新slab失败，则进入if，ret = NULL，否则进入下面的elseif
246. \*/
247. if(!(p\->sl\_curr !=0|| do\_slabs\_newslab(id)!=0))\{ 
248. /\* We don't have more memory available \*/
249. ret = NULL;
250. \}elseif(p\->sl\_curr !=0)\{ //如果进入此分支是因为slots链表中还有空闲的空间
251. /\* return off our freelist \*/
252. //把空闲的item分配出去
253. it =(item \*)p\->slots;
254. p\->slots = it\->next;
255. if(it\->next) it\->next\->prev =0;
256. p\->sl\_curr\--;
257. ret =(void\*)it;
258. \}
259. 
260. if(ret)\{ 
261. p\->requested \+= size;//分配成功，记下已分配的字节数
262. MEMCACHED\_SLABS\_ALLOCATE(size, id, p\->size, ret);
263. \}else\{ 
264. MEMCACHED\_SLABS\_ALLOCATE\_FAILED(size, id);
265. \}
266. 
267. return ret;
268. \}
269. 
270. /\*\*
271. 这个函数的命名虽然叫do\_slabs\_free，听上去好像是释放空间，其实质是把空间变成可用。
272. 怎样的空间才算可用？就是加到当前slabclass的slots链表中而已。
273. 所以新申请的slab也会调用这个函数，让整个slab变为可用。
274. 
275. ps: 以前的memcached版本slots链表保存的是回收的item空间，而
276. 现在保存的是所有可用的item空间。
277. \*/
278. staticvoid do\_slabs\_free(void\*ptr,constsize\_t size,unsignedint id)\{ 
279. slabclass\_t\*p;
280. item \*it;
281. 
282. assert(((item \*)ptr)->slabs\_clsid ==0);
283. assert(id >= POWER\_SMALLEST && id <= power\_largest);
284. if(id < POWER\_SMALLEST || id > power\_largest)
285. return;
286. 
287. MEMCACHED\_SLABS\_FREE(size, id, ptr);
288. p =&slabclass\[id\];
289. 
290. it =(item \*)ptr;
291. it\->it\_flags |= ITEM\_SLABBED;//把item标记为slabbed状态
292. it\->prev =0;
293. it\->next= p\->slots;//插入到slots链表中
294. if(it\->next) it\->next\->prev = it;
295. p\->slots = it;
296. 
297. p\->sl\_curr\++;//空闲item数加1
298. p\->requested \-= size;
299. return;
300. \}
301. 
302. staticint nz\_strcmp(int nzlength,constchar\*nz,constchar\*z)\{ 
303. int zlength=strlen(z);
304. return(zlength == nzlength)&&(strncmp(nz, z, zlength)==0)?0:\-1;
305. \}
306. 
307. bool get\_stats(constchar\*stat\_type,int nkey, ADD\_STAT add\_stats,void\*c)\{ 
308. bool ret =true;
309. 
310. if(add\_stats != NULL)\{ 
311. if(!stat\_type)\{ 
312. /\* prepare general statistics for the engine \*/
313. STATS\_LOCK();
314. APPEND\_STAT("bytes","%llu",(unsignedlonglong)stats.curr\_bytes);
315. APPEND\_STAT("curr\_items","%u", stats.curr\_items);
316. APPEND\_STAT("total\_items","%u", stats.total\_items);
317. STATS\_UNLOCK();
318. item\_stats\_totals(add\_stats, c);
319. \}elseif(nz\_strcmp(nkey, stat\_type,"items")==0)\{ 
320. item\_stats(add\_stats, c);
321. \}elseif(nz\_strcmp(nkey, stat\_type,"slabs")==0)\{ 
322. slabs\_stats(add\_stats, c);
323. \}elseif(nz\_strcmp(nkey, stat\_type,"sizes")==0)\{ 
324. item\_stats\_sizes(add\_stats, c);
325. \}else\{ 
326. ret =false;
327. \}
328. \}else\{ 
329. ret =false;
330. \}
331. 
332. return ret;
333. \}
334. 
335. staticvoid do\_slabs\_stats(ADD\_STAT add\_stats,void\*c)\{ 
336. int i, total;
337. /\* Get the per-thread stats which contain some interesting aggregates \*/
338. struct thread\_stats thread\_stats;
339. threadlocal\_stats\_aggregate(&thread\_stats);
340. 
341. total =0;
342. for(i = POWER\_SMALLEST; i <= power\_largest; i\++)\{ 
343. slabclass\_t\*p =&slabclass\[i\];
344. if(p\->slabs !=0)\{ 
345. uint32\_t perslab, slabs;
346. slabs = p\->slabs;
347. perslab = p\->perslab;
348. 
349. char key\_str\[STAT\_KEY\_LEN\];
350. char val\_str\[STAT\_VAL\_LEN\];
351. int klen =0, vlen =0;
352. 
353. APPEND\_NUM\_STAT(i,"chunk\_size","%u", p\->size);
354. APPEND\_NUM\_STAT(i,"chunks\_per\_page","%u", perslab);
355. APPEND\_NUM\_STAT(i,"total\_pages","%u", slabs);
356. APPEND\_NUM\_STAT(i,"total\_chunks","%u", slabs \* perslab);
357. APPEND\_NUM\_STAT(i,"used\_chunks","%u",
358. slabs\*perslab \- p\->sl\_curr);
359. APPEND\_NUM\_STAT(i,"free\_chunks","%u", p\->sl\_curr);
360. /\* Stat is dead, but displaying zero instead of removing it. \*/
361. APPEND\_NUM\_STAT(i,"free\_chunks\_end","%u",0);
362. APPEND\_NUM\_STAT(i,"mem\_requested","%llu",
363. (unsignedlonglong)p\->requested);
364. APPEND\_NUM\_STAT(i,"get\_hits","%llu",
365. (unsignedlonglong)thread\_stats.slab\_stats\[i\].get\_hits);
366. APPEND\_NUM\_STAT(i,"cmd\_set","%llu",
367. (unsignedlonglong)thread\_stats.slab\_stats\[i\].set\_cmds);
368. APPEND\_NUM\_STAT(i,"delete\_hits","%llu",
369. (unsignedlonglong)thread\_stats.slab\_stats\[i\].delete\_hits);
370. APPEND\_NUM\_STAT(i,"incr\_hits","%llu",
371. (unsignedlonglong)thread\_stats.slab\_stats\[i\].incr\_hits);
372. APPEND\_NUM\_STAT(i,"decr\_hits","%llu",
373. (unsignedlonglong)thread\_stats.slab\_stats\[i\].decr\_hits);
374. APPEND\_NUM\_STAT(i,"cas\_hits","%llu",
375. (unsignedlonglong)thread\_stats.slab\_stats\[i\].cas\_hits);
376. APPEND\_NUM\_STAT(i,"cas\_badval","%llu",
377. (unsignedlonglong)thread\_stats.slab\_stats\[i\].cas\_badval);
378. APPEND\_NUM\_STAT(i,"touch\_hits","%llu",
379. (unsignedlonglong)thread\_stats.slab\_stats\[i\].touch\_hits);
380. total\++;
381. \}
382. \}
383. 
384. APPEND\_STAT("active\_slabs","%d", total);
385. APPEND\_STAT("total\_malloced","%llu",(unsignedlonglong)mem\_malloced);
386. add\_stats(NULL,0, NULL,0, c);
387. \}
388. 
389. /\*\*
390. 分配内存空间
391. \*/
392. staticvoid\*memory\_allocate(size\_t size)\{ 
393. void\*ret;
394. 
395. /\*\*
396. 有两种分配策略
397. 1）如果是开启了内存预分配策略，则只需要从预分配好的内存块那里割一块出来。即进入下面的else分支
398. 2）如果没有开启预分配，则malloc分配内存
399. 
400. 关于预分配详见 slabs\_init
401. \*/
402. if(mem\_base == NULL)\{ 
403. /\* We are not using a preallocated large memory chunk \*/
404. ret = malloc(size);
405. \}else\{ 
406. ret = mem\_current;
407. 
408. if(size > mem\_avail)\{ 
409. return NULL;
410. \}
411. 
412. /\* mem\_current pointer \_must\_ be aligned!!! \*/
413. if(size % CHUNK\_ALIGN\_BYTES)\{ 
414. size \+= CHUNK\_ALIGN\_BYTES \-(size % CHUNK\_ALIGN\_BYTES);
415. \}
416. 
417. mem\_current =((char\*)mem\_current)\+ size;
418. if(size < mem\_avail)\{ 
419. mem\_avail \-= size;
420. \}else\{ 
421. mem\_avail =0;
422. \}
423. \}
424. 
425. return ret;
426. \}
427. 
428. void\*slabs\_alloc(size\_t size,unsignedint id)\{ 
429. void\*ret;
430. 
431. pthread\_mutex\_lock(&slabs\_lock);
432. ret = do\_slabs\_alloc(size, id);
433. pthread\_mutex\_unlock(&slabs\_lock);
434. return ret;
435. \}
436. 
437. void slabs\_free(void\*ptr,size\_t size,unsignedint id)\{ 
438. pthread\_mutex\_lock(&slabs\_lock);
439. do\_slabs\_free(ptr, size, id);
440. pthread\_mutex\_unlock(&slabs\_lock);
441. \}
442. 
443. void slabs\_stats(ADD\_STAT add\_stats,void\*c)\{ 
444. pthread\_mutex\_lock(&slabs\_lock);
445. do\_slabs\_stats(add\_stats, c);
446. pthread\_mutex\_unlock(&slabs\_lock);
447. \}
448. 
449. void slabs\_adjust\_mem\_requested(unsignedint id,size\_t old,size\_t ntotal)
450. \{ 
451. pthread\_mutex\_lock(&slabs\_lock);
452. slabclass\_t\*p;
453. if(id < POWER\_SMALLEST || id > power\_largest)\{ 
454. fprintf(stderr,"Internal error! Invalid slab class\\n");
455. abort();
456. \}
457. 
458. p =&slabclass\[id\];
459. p\->requested = p\->requested \- old \+ ntotal;
460. pthread\_mutex\_unlock(&slabs\_lock);
461. \}
462. 
463. staticpthread\_cond\_t maintenance\_cond = PTHREAD\_COND\_INITIALIZER;
464. staticpthread\_cond\_t slab\_rebalance\_cond = PTHREAD\_COND\_INITIALIZER;
465. staticvolatileint do\_run\_slab\_thread =1;
466. staticvolatileint do\_run\_slab\_rebalance\_thread =1;
467. 
468. \#define DEFAULT\_SLAB\_BULK\_CHECK 1
469. int slab\_bulk\_check = DEFAULT\_SLAB\_BULK\_CHECK;
470. 
471. staticint slab\_rebalance\_start(void)\{ 
472. slabclass\_t\*s\_cls;
473. int no\_go =0;
474. 
475. pthread\_mutex\_lock(&cache\_lock);
476. pthread\_mutex\_lock(&slabs\_lock);
477. 
478. if(slab\_rebal.s\_clsid < POWER\_SMALLEST ||
479. slab\_rebal.s\_clsid > power\_largest ||
480. slab\_rebal.d\_clsid < POWER\_SMALLEST ||
481. slab\_rebal.d\_clsid > power\_largest ||
482. slab\_rebal.s\_clsid == slab\_rebal.d\_clsid)
483. no\_go =\-2;
484. 
485. s\_cls =&slabclass\[slab\_rebal.s\_clsid\];
486. 
487. if(!grow\_slab\_list(slab\_rebal.d\_clsid))\{ 
488. no\_go =\-1;
489. \}
490. 
491. if(s\_cls\->slabs <2)
492. no\_go =\-3;
493. 
494. if(no\_go !=0)\{ 
495. pthread\_mutex\_unlock(&slabs\_lock);
496. pthread\_mutex\_unlock(&cache\_lock);
497. return no\_go;/\* Should use a wrapper function... \*/
498. \}
499. 
500. s\_cls\->killing =1;
501. 
502. slab\_rebal.slab\_start = s\_cls\->slab\_list\[s\_cls\->killing \-1\];
503. slab\_rebal.slab\_end =(char\*)slab\_rebal.slab\_start \+
504. (s\_cls\->size \* s\_cls\->perslab);
505. slab\_rebal.slab\_pos = slab\_rebal.slab\_start;
506. slab\_rebal.done=0;
507. 
508. /\* Also tells do\_item\_get to search for items in this slab \*/
509. slab\_rebalance\_signal =2;
510. 
511. if(settings.verbose >1)\{ 
512. fprintf(stderr,"Started a slab rebalance\\n");
513. \}
514. 
515. pthread\_mutex\_unlock(&slabs\_lock);
516. pthread\_mutex\_unlock(&cache\_lock);
517. 
518. STATS\_LOCK();
519. stats.slab\_reassign\_running =true;
520. STATS\_UNLOCK();
521. 
522. return0;
523. \}
524. 
525. enum move\_status \{ 
526. MOVE\_PASS=0, MOVE\_DONE, MOVE\_BUSY, MOVE\_LOCKED
527. \};
528. 
529. staticint slab\_rebalance\_move(void)\{ 
530. slabclass\_t\*s\_cls;
531. int x;
532. int was\_busy =0;
533. int refcount =0;
534. enum move\_status status = MOVE\_PASS;
535. 
536. pthread\_mutex\_lock(&cache\_lock);
537. pthread\_mutex\_lock(&slabs\_lock);
538. 
539. s\_cls =&slabclass\[slab\_rebal.s\_clsid\];
540. 
541. for(x =0; x < slab\_bulk\_check; x\++)\{ 
542. item \*it = slab\_rebal.slab\_pos;
543. status = MOVE\_PASS;
544. if(it\->slabs\_clsid !=255)\{ 
545. void\*hold\_lock = NULL;
546. uint32\_t hv = hash(ITEM\_key(it), it\->nkey);
547. if((hold\_lock = item\_trylock(hv))== NULL)\{ 
548. status = MOVE\_LOCKED;
549. \}else\{ 
550. refcount = refcount\_incr(&it\->refcount);
551. if(refcount ==1)\{ /\* item is unlinked, unused \*/
552. if(it\->it\_flags & ITEM\_SLABBED)\{ 
553. /\* remove from slab freelist \*/
554. if(s\_cls\->slots == it)\{ 
555. s\_cls\->slots = it\->next;
556. \}
557. if(it\->next) it\->next\->prev = it\->prev;
558. if(it\->prev) it\->prev\->next= it\->next;
559. s\_cls\->sl\_curr\--;
560. status = MOVE\_DONE;
561. \}else\{ 
562. status = MOVE\_BUSY;
563. \}
564. \}elseif(refcount ==2)\{ /\* item is linked but not busy \*/
565. if((it\->it\_flags & ITEM\_LINKED)!=0)\{ 
566. do\_item\_unlink\_nolock(it, hv);
567. status = MOVE\_DONE;
568. \}else\{ 
569. /\* refcount == 1 + !ITEM\_LINKED means the item is being
570. \* uploaded to, or was just unlinked but hasn't been freed
571. \* yet. Let it bleed off on its own and try again later \*/
572. status = MOVE\_BUSY;
573. \}
574. \}else\{ 
575. if(settings.verbose >2)\{ 
576. fprintf(stderr,"Slab reassign hit a busy item: refcount: %d (%d -> %d)\\n",
577. it\->refcount, slab\_rebal.s\_clsid, slab\_rebal.d\_clsid);
578. \}
579. status = MOVE\_BUSY;
580. \}
581. item\_trylock\_unlock(hold\_lock);
582. \}
583. \}
584. 
585. switch(status)\{ 
586. case MOVE\_DONE:
587. it\->refcount =0;
588. it\->it\_flags =0;
589. it\->slabs\_clsid =255;
590. break;
591. case MOVE\_BUSY:
592. refcount\_decr(&it\->refcount);
593. case MOVE\_LOCKED:
594. slab\_rebal.busy\_items\++;
595. was\_busy\++;
596. break;
597. case MOVE\_PASS:
598. break;
599. \}
600. 
601. slab\_rebal.slab\_pos =(char\*)slab\_rebal.slab\_pos \+ s\_cls\->size;
602. if(slab\_rebal.slab\_pos >= slab\_rebal.slab\_end)
603. break;
604. \}
605. 
606. if(slab\_rebal.slab\_pos >= slab\_rebal.slab\_end)\{ 
607. /\* Some items were busy, start again from the top \*/
608. if(slab\_rebal.busy\_items)\{ 
609. slab\_rebal.slab\_pos = slab\_rebal.slab\_start;
610. slab\_rebal.busy\_items =0;
611. \}else\{ 
612. slab\_rebal.done\++;
613. \}
614. \}
615. 
616. pthread\_mutex\_unlock(&slabs\_lock);
617. pthread\_mutex\_unlock(&cache\_lock);
618. 
619. return was\_busy;
620. \}
621. 
622. staticvoid slab\_rebalance\_finish(void)\{ 
623. slabclass\_t\*s\_cls;
624. slabclass\_t\*d\_cls;
625. 
626. pthread\_mutex\_lock(&cache\_lock);
627. pthread\_mutex\_lock(&slabs\_lock);
628. 
629. s\_cls =&slabclass\[slab\_rebal.s\_clsid\];
630. d\_cls =&slabclass\[slab\_rebal.d\_clsid\];
631. 
632. /\* At this point the stolen slab is completely clear \*/
633. s\_cls\->slab\_list\[s\_cls\->killing \-1\]=
634. s\_cls\->slab\_list\[s\_cls\->slabs \-1\];
635. s\_cls\->slabs\--;
636. s\_cls\->killing =0;
637. 
638. memset(slab\_rebal.slab\_start,0,(size\_t)settings.item\_size\_max);
639. 
640. d\_cls\->slab\_list\[d\_cls\->slabs\++\]= slab\_rebal.slab\_start;
641. split\_slab\_page\_into\_freelist(slab\_rebal.slab\_start,
642. slab\_rebal.d\_clsid);
643. 
644. slab\_rebal.done=0;
645. slab\_rebal.s\_clsid =0;
646. slab\_rebal.d\_clsid =0;
647. slab\_rebal.slab\_start = NULL;
648. slab\_rebal.slab\_end = NULL;
649. slab\_rebal.slab\_pos = NULL;
650. 
651. slab\_rebalance\_signal =0;
652. 
653. pthread\_mutex\_unlock(&slabs\_lock);
654. pthread\_mutex\_unlock(&cache\_lock);
655. 
656. STATS\_LOCK();
657. stats.slab\_reassign\_running =false;
658. stats.slabs\_moved\++;
659. STATS\_UNLOCK();
660. 
661. if(settings.verbose >1)\{ 
662. fprintf(stderr,"finished a slab move\\n");
663. \}
664. \}
665. 
666. /\*
667. slab自动重分配时，执行此函数做出重分配方案决定
668. \*/
669. staticint slab\_automove\_decision(int\*src,int\*dst)\{ 
670. staticuint64\_t evicted\_old\[POWER\_LARGEST\];
671. staticunsignedint slab\_zeroes\[POWER\_LARGEST\];
672. staticunsignedint slab\_winner =0;
673. staticunsignedint slab\_wins =0;
674. uint64\_t evicted\_new\[POWER\_LARGEST\];
675. uint64\_t evicted\_diff =0;
676. uint64\_t evicted\_max =0;
677. unsignedint highest\_slab =0;
678. unsignedint total\_pages\[POWER\_LARGEST\];
679. int i;
680. int source =0;
681. int dest =0;
682. staticrel\_time\_t next\_run;
683. 
684. /\* Run less frequently than the slabmove tester. \*/
685. if(current\_time >= next\_run)\{ 
686. next\_run = current\_time \+10;
687. \}else\{ 
688. return0;
689. \}
690. 
691. item\_stats\_evictions(evicted\_new);
692. pthread\_mutex\_lock(&cache\_lock);
693. for(i = POWER\_SMALLEST; i < power\_largest; i\++)\{ 
694. total\_pages\[i\]= slabclass\[i\].slabs;
695. \}
696. pthread\_mutex\_unlock(&cache\_lock);
697. 
698. /\* Find a candidate source; something with zero evicts 3+ times \*/
699. for(i = POWER\_SMALLEST; i < power\_largest; i\++)\{ 
700. evicted\_diff = evicted\_new\[i\]\- evicted\_old\[i\];
701. if(evicted\_diff ==0&& total\_pages\[i\]>2)\{ 
702. slab\_zeroes\[i\]++;
703. if(source ==0&& slab\_zeroes\[i\]>=3)
704. source = i;
705. \}else\{ 
706. slab\_zeroes\[i\]=0;
707. if(evicted\_diff > evicted\_max)\{ 
708. evicted\_max = evicted\_diff;
709. highest\_slab = i;
710. \}
711. \}
712. evicted\_old\[i\]= evicted\_new\[i\];
713. \}
714. 
715. /\* Pick a valid destination \*/
716. if(slab\_winner !=0&& slab\_winner == highest\_slab)\{ 
717. slab\_wins\++;
718. if(slab\_wins >=3)
719. dest = slab\_winner;
720. \}else\{ 
721. slab\_wins =1;
722. slab\_winner = highest\_slab;
723. \}
724. 
725. if(source && dest)\{ 
726. \*src = source;
727. \*dst = dest;
728. return1;
729. \}
730. return0;
731. \}
732. 
733. /\* Slab rebalancer thread.
734. \* Does not use spinlocks since it is not timing sensitive. Burn less CPU and
735. \* go to sleep if locks are contended
736. 运行slab维护线程，slab维护线程的执行入口
737. \*/
738. staticvoid\*slab\_maintenance\_thread(void\*arg)\{ 
739. int src, dest;
740. 
741. while(do\_run\_slab\_thread)\{ 
742. if(settings.slab\_automove ==1)\{ 
743. if(slab\_automove\_decision(&src,&dest)==1)\{ 
744. /\* Blind to the return codes. It will retry on its own \*/
745. slabs\_reassign(src, dest);//移动slab，重分配
746. \}
747. sleep(1);
748. \}else\{ 
749. /\* Don't wake as often if we're not enabled.
750. \* This is lazier than setting up a condition right now. \*/
751. sleep(5);
752. \}
753. \}
754. return NULL;
755. \}
756. 
757. /\* Slab mover thread.
758. \* Sits waiting for a condition to jump off and shovel some memory about
759. \*/
760. staticvoid\*slab\_rebalance\_thread(void\*arg)\{ 
761. int was\_busy =0;
762. /\* So we first pass into cond\_wait with the mutex held \*/
763. mutex\_lock(&slabs\_rebalance\_lock);
764. 
765. while(do\_run\_slab\_rebalance\_thread)\{ 
766. if(slab\_rebalance\_signal ==1)\{ 
767. if(slab\_rebalance\_start()<0)\{ 
768. /\* Handle errors with more specifity as required. \*/
769. slab\_rebalance\_signal =0;
770. \}
771. 
772. was\_busy =0;
773. \}elseif(slab\_rebalance\_signal && slab\_rebal.slab\_start != NULL)\{ 
774. was\_busy = slab\_rebalance\_move();
775. \}
776. 
777. if(slab\_rebal.done)\{ 
778. slab\_rebalance\_finish();
779. \}elseif(was\_busy)\{ 
780. /\* Stuck waiting for some items to unlock, so slow down a bit
781. \* to give them a chance to free up \*/
782. usleep(50);
783. \}
784. 
785. if(slab\_rebalance\_signal ==0)\{ 
786. /\* always hold this lock while we're running \*/
787. pthread\_cond\_wait(&slab\_rebalance\_cond,&slabs\_rebalance\_lock);
788. \}
789. \}
790. return NULL;
791. \}
792. 
793. staticint slabs\_reassign\_pick\_any(int dst)\{ 
794. staticint cur = POWER\_SMALLEST \-1;
795. int tries = power\_largest \- POWER\_SMALLEST \+1;
796. for(; tries >0; tries\--)\{ 
797. cur\++;
798. if(cur > power\_largest)
799. cur = POWER\_SMALLEST;
800. if(cur == dst)
801. continue;
802. if(slabclass\[cur\].slabs >1)\{ 
803. return cur;
804. \}
805. \}
806. return\-1;
807. \}
808. 
809. staticenum reassign\_result\_type do\_slabs\_reassign(int src,int dst)\{ 
810. if(slab\_rebalance\_signal !=0)
811. return REASSIGN\_RUNNING;
812. 
813. if(src == dst)
814. return REASSIGN\_SRC\_DST\_SAME;
815. 
816. /\* Special indicator to choose ourselves. \*/
817. if(src ==\-1)\{ 
818. src = slabs\_reassign\_pick\_any(dst);
819. /\* TODO: If we end up back at -1, return a new error type \*/
820. \}
821. 
822. if(src < POWER\_SMALLEST || src > power\_largest ||
823. dst < POWER\_SMALLEST || dst > power\_largest)
824. return REASSIGN\_BADCLASS;
825. 
826. if(slabclass\[src\].slabs <2)
827. return REASSIGN\_NOSPARE;
828. 
829. slab\_rebal.s\_clsid = src;
830. slab\_rebal.d\_clsid = dst;
831. 
832. slab\_rebalance\_signal =1;
833. pthread\_cond\_signal(&slab\_rebalance\_cond);
834. 
835. return REASSIGN\_OK;
836. \}
837. 
838. enum reassign\_result\_type slabs\_reassign(int src,int dst)\{ 
839. enum reassign\_result\_type ret;
840. if(pthread\_mutex\_trylock(&slabs\_rebalance\_lock)!=0)\{ 
841. return REASSIGN\_RUNNING;
842. \}
843. ret = do\_slabs\_reassign(src, dst);
844. pthread\_mutex\_unlock(&slabs\_rebalance\_lock);
845. return ret;
846. \}
847. 
848. /\* If we hold this lock, rebalancer can't wake up or move \*/
849. void slabs\_rebalancer\_pause(void)\{ 
850. pthread\_mutex\_lock(&slabs\_rebalance\_lock);
851. \}
852. 
853. void slabs\_rebalancer\_resume(void)\{ 
854. pthread\_mutex\_unlock(&slabs\_rebalance\_lock);
855. \}
856. 
857. staticpthread\_t maintenance\_tid;
858. staticpthread\_t rebalance\_tid;
859. 
860. /\*\*
861. 启动slab维护线程
862. \*/
863. int start\_slab\_maintenance\_thread(void)\{ 
864. int ret;
865. slab\_rebalance\_signal =0;
866. slab\_rebal.slab\_start = NULL;
867. char\*env = getenv("MEMCACHED\_SLAB\_BULK\_CHECK");
868. if(env != NULL)\{ 
869. slab\_bulk\_check = atoi(env);
870. if(slab\_bulk\_check ==0)\{ 
871. slab\_bulk\_check = DEFAULT\_SLAB\_BULK\_CHECK;
872. \}
873. \}
874. 
875. if(pthread\_cond\_init(&slab\_rebalance\_cond, NULL)!=0)\{ 
876. fprintf(stderr,"Can't intiialize rebalance condition\\n");
877. return\-1;
878. \}
879. pthread\_mutex\_init(&slabs\_rebalance\_lock, NULL);
880. 
881. if((ret = pthread\_create(&maintenance\_tid, NULL,
882. slab\_maintenance\_thread, NULL))!=0)\{ 
883. fprintf(stderr,"Can't create slab maint thread: %s\\n", strerror(ret));
884. return\-1;
885. \}
886. if((ret = pthread\_create(&rebalance\_tid, NULL,
887. slab\_rebalance\_thread, NULL))!=0)\{ 
888. fprintf(stderr,"Can't create rebal thread: %s\\n", strerror(ret));
889. return\-1;
890. \}
891. return0;
892. \}
893. 
894. /\*\*
895. 停止slab维护线程，逻辑和停止哈希表维护线程一样。
896. \*/
897. void stop\_slab\_maintenance\_thread(void)\{ 
898. mutex\_lock(&cache\_lock);
899. do\_run\_slab\_thread =0;
900. do\_run\_slab\_rebalance\_thread =0;
901. pthread\_cond\_signal(&maintenance\_cond);
902. pthread\_mutex\_unlock(&cache\_lock);
903. 
904. /\* Wait for the maintenance thread to stop \*/
905. pthread\_join(maintenance\_tid, NULL);
906. pthread\_join(rebalance\_tid, NULL);
907. \}

转载于:https://www.cnblogs.com/guolanzhu/p/5850272.html