这篇blog介绍dict的实现。
dict.c
1 #include "fmacros.h" 2 3 #include <stdio.h> 4 #include <stdlib.h> 5 #include <string.h> 6 #include <stdarg.h> 7 #include <assert.h> 8 #include <limits.h> 9 #include <sys/time.h> 10 #include <ctype.h> 11 12 #include "dict.h" 13 #include "zmalloc.h" 14 15 /* Using dictEnableResize() / dictDisableResize() we make possible to 16 * enable/disable resizing of the hash table as needed. This is very important 17 * for Redis, as we use copy-on-write and don't want to move too much memory 18 * around when there is a child performing saving operations. 19 * 20 * Note that even when dict_can_resize is set to 0, not all resizes are 21 * prevented: an hash table is still allowed to grow if the ratio between 22 * the number of elements and the buckets > dict_force_resize_ratio. */
注释已经说的很清楚了。redis有些后台进程会做一些工作，比如rdb save、aof rewrite之类的，所以如果在后台进程运行过程中，将允许对hash table进行resize操作的话，会造成大量的内存拷贝（默认是copy-on-write，只在内存有变化时才拷贝）。注释中说，也没有完全避免，如果存的entry过多，比如存的entry是slot数的五倍，则也会强制进行resize
23 static int dict_can_resize = 1; 24 static unsigned int dict_force_resize_ratio = 5; 25 26 /* -------------------------- private prototypes ---------------------------- */ 27 28 static int _dictExpandIfNeeded(dict *ht); //如果需要的话，将hash表进行扩展 29 static unsigned long _dictNextPower(unsigned long size); 30 static int _dictKeyIndex(dict *ht, const void *key); 31 static int _dictInit(dict *ht, dictType *type, void *privDataPtr); 32 //这4个函数的具体含义，到后边实现以及用到的时候再讨论
33 /* -------------------------- hash functions -------------------------------- */ 34 35 /* Thomas Wang's 32 bit Mix Function */ 36 unsigned int dictIntHashFunction(unsigned int key) 37 { 38 key += ~(key << 15); 39 key ^= (key >> 10); 40 key += (key << 3); 41 key ^= (key >> 6); 42 key += ~(key << 11); 43 key ^= (key >> 16); 44 return key; 45 } 46 47 /* Identity hash function for integer keys */ 48 unsigned int dictIdentityHashFunction(unsigned int key) 49 { 50 return key; 51 } 52 53 /* Generic hash function (a popular one from Bernstein). 54 * I tested a few and this was the best. */ 55 unsigned int dictGenHashFunction(const unsigned char *buf, int len) { 56 unsigned int hash = 5381; 57 58 while (len--) 59 hash = ((hash << 5) + hash) + (*buf++); /* hash * 33 + c */ 60 return hash; 61 } 62 63 /* And a case insensitive version */ 64 unsigned int dictGenCaseHashFunction(const unsigned char *buf, int len) { 65 unsigned int hash = 5381; 66 67 while (len--) 68 hash = ((hash << 5) + hash) + (tolower(*buf++)); /* hash * 33 + c */ 69 return hash; 70 } 71 //给出针对整数和字符串的hash函数，因为redis中做dict key的只有这两种类型
72 /* ----------------------------- API implementation ------------------------- */ 73 74 /* Reset an hashtable already initialized with ht_init(). 75 * NOTE: This function should only called by ht_destroy(). */ //Note: and _dictInit 76 static void _dictReset(dictht *ht) 77 { 78 ht->table = NULL; 79 ht->size = 0; 80 ht->sizemask = 0; 81 ht->used = 0; 82 } 83 84 /* Create a new hash table */ 85 dict *dictCreate(dictType *type, 86 void *privDataPtr) 87 { 88 dict *d = zmalloc(sizeof(*d)); 89 90 _dictInit(d,type,privDataPtr); 91 return d; 92 } 93 //解释下参数中的privDataPtr，它是dict struct的一个成员，然后分别在dictType的keyDup函数、valDup函数、keyCompare函数、keyDestructor函数、valDestructor函数中作为第一个参数使用。dict的对外API通过dictCreate函数对其进行初始化。我在看dict.h时也很疑惑这个接口设计。这里揭底，在redis当前版本对dictCreate的所有调用中（networking.c一次、object.c两次、redis.c七次、t_hash.c一次、t_set.c一次、t_zset.c一次），此参数均被赋为了NULL，可能是历史原因或是考虑后续兼容性？求大牛指点。anyway，现在可以无视之了。
94 /* Initialize the hash table */ 95 int _dictInit(dict *d, dictType *type, 96 void *privDataPtr) 97 { 98 _dictReset(&d->ht[0]); 99 _dictReset(&d->ht[1]); 100 d->type = type; 101 d->privdata = privDataPtr; 102 d->rehashidx = -1; 103 d->iterators = 0; 104 return DICT_OK; 105 } 106 107 /* Resize the table to the minimal size that contains all the elements, 108 * but with the invariant of a USER/BUCKETS ratio near to <= 1 */ 109 int dictResize(dict *d) 110 { 111 int minimal; 112 113 if (!dict_can_resize || dictIsRehashing(d)) return DICT_ERR; 114 minimal = d->ht[0].used; 115 if (minimal < DICT_HT_INITIAL_SIZE) 116 minimal = DICT_HT_INITIAL_SIZE; 117 return dictExpand(d, minimal); 118 } 119 120 /* Expand or create the hashtable */ 121 int dictExpand(dict *d, unsigned long size) 122 { 123 dictht n; /* the new hashtable */ 124 unsigned long realsize = _dictNextPower(size); //dict的size是2的倍数，所以这里记录了真是的记录长度，需要比size长 125 126 /* the size is invalid if it is smaller than the number of 127 * elements already inside the hashtable */ 128 if (dictIsRehashing(d) || d->ht[0].used > size) 129 return DICT_ERR; 130 131 /* Allocate the new hashtable and initialize all pointers to NULL */ 132 n.size = realsize; 133 n.sizemask = realsize-1; 134 n.table = zcalloc(realsize*sizeof(dictEntry*)); 135 n.used = 0; 136 137 /* Is this the first initialization? If so it's not really a rehashing 138 * we just set the first hash table so that it can accept keys. */ 139 if (d->ht[0].table == NULL) { 140 d->ht[0] = n; 141 return DICT_OK; 142 } 143 144 /* Prepare a second hash table for incremental rehashing */ 145 d->ht[1] = n; 146 d->rehashidx = 0; //只有在第二次调用dictExpand时，才是rehash的前奏 147 return DICT_OK; 148 } 149 150 /* Performs N steps of incremental rehashing. Returns 1 if there are still 151 * keys to move from the old to the new hash table, otherwise 0 is returned. 152 * Note that a rehashing step consists in moving a bucket (that may have more 153 * thank one key as we use chaining) from the old to the new hash table. */ 154 int dictRehash(dict *d, int n) { 155 if (!dictIsRehashing(d)) return 0; 156 157 while(n--) { 158 dictEntry *de, *nextde; 159 160 /* Check if we already rehashed the whole table... */ 161 if (d->ht[0].used == 0) { 162 zfree(d->ht[0].table); 163 d->ht[0] = d->ht[1]; 164 _dictReset(&d->ht[1]); 165 d->rehashidx = -1; 166 return 0; 167 } 168 169 /* Note that rehashidx can't overflow as we are sure there are more 170 * elements because ht[0].used != 0 */ 171 while(d->ht[0].table[d->rehashidx] == NULL) d->rehashidx++; 172 de = d->ht[0].table[d->rehashidx]; 173 /* Move all the keys in this bucket from the old to the new hash HT */ 174 while(de) { 175 unsigned int h; 176 177 nextde = de->next; 178 /* Get the index in the new hash table */ 179 h = dictHashKey(d, de->key) & d->ht[1].sizemask; 180 de->next = d->ht[1].table[h]; 181 d->ht[1].table[h] = de; 182 d->ht[0].used--; 183 d->ht[1].used++; 184 de = nextde; 185 } 186 d->ht[0].table[d->rehashidx] = NULL; 187 d->rehashidx++; 188 } 189 return 1; 190 } 191 192 long long timeInMilliseconds(void) { 193 struct timeval tv; 194 195 gettimeofday(&tv,NULL); 196 return (((long long)tv.tv_sec)*1000)+(tv.tv_usec/1000); 197 } //时间单位是ms 198 199 /* Rehash for an amount of time between ms milliseconds and ms+1 milliseconds */ 200 int dictRehashMilliseconds(dict *d, int ms) { 201 long long start = timeInMilliseconds(); 202 int rehashes = 0; 203 204 while(dictRehash(d,100)) { 205 rehashes += 100; 206 if (timeInMilliseconds()-start > ms) break; 207 } 208 return rehashes; 209 } //返回值是rehash数目，为100的整数倍，传进参数的ms只是个下限，并不严格限制 210 211 /* This function performs just a step of rehashing, and only if there are 212 * no safe iterators bound to our hash table. When we have iterators in the 213 * middle of a rehashing we can't mess with the two hash tables otherwise 214 * some element can be missed or duplicated. 215 * 216 * This function is called by common lookup or update operations in the 217 * dictionary so that the hash table automatically migrates from H1 to H2 218 * while it is actively used. */ 219 static void _dictRehashStep(dict *d) { 220 if (d->iterators == 0) dictRehash(d,1); 221 } //在dict上存在遍历用的iterator时，不会尽心rehash操作，否则遍历将会丢数据或出现重复。这个函数是在lookup和update时调用，使得rehash的过程伴随着针对dict操作的过程慢慢完成 222 223 /* Add an element to the target hash table */ 224 int dictAdd(dict *d, void *key, void *val) 225 { 226 int index; 227 dictEntry *entry; 228 dictht *ht; 229 230 if (dictIsRehashing(d)) _dictRehashStep(d); 231 232 /* Get the index of the new element, or -1 if 233 * the element already exists. */ 234 if ((index = _dictKeyIndex(d, key)) == -1) 235 return DICT_ERR; 236 237 /* Allocates the memory and stores key */ 238 ht = dictIsRehashing(d) ? &d->ht[1] : &d->ht[0]; //如果dict正在进行rehash，则将新来的数据存在d->ht[1]上，因为d->ht[0]是“旧表”,不再接受新的数据 239 entry = zmalloc(sizeof(*entry)); 240 entry->next = ht->table[index]; 241 ht->table[index] = entry; 242 ht->used++; 243 244 /* Set the hash entry fields. */ 245 dictSetHashKey(d, entry, key); 246 dictSetHashVal(d, entry, val); 247 return DICT_OK; 248 } 249 250 /* Add an element, discarding the old if the key already exists. 251 * Return 1 if the key was added from scratch, 0 if there was already an 252 * element with such key and dictReplace() just performed a value update 253 * operation. */ 254 int dictReplace(dict *d, void *key, void *val) 255 { 256 dictEntry *entry, auxentry; 257 258 /* Try to add the element. If the key 259 * does not exists dictAdd will suceed. */ 260 if (dictAdd(d, key, val) == DICT_OK) 261 return 1; 262 /* It already exists, get the entry */ 263 entry = dictFind(d, key); 264 /* Free the old value and set the new one */ 265 /* Set the new value and free the old one. Note that it is important 266 * to do that in this order, as the value may just be exactly the same 267 * as the previous one. In this context, think to reference counting, 268 * you want to increment (set), and then decrement (free), and not the 269 * reverse. */ 270 auxentry = *entry; 271 dictSetHashVal(d, entry, val); 272 dictFreeEntryVal(d, &auxentry); 273 return 0; 274 } 275 276 /* Search and remove an element */ 277 static int dictGenericDelete(dict *d, const void *key, int nofree) 278 { 279 unsigned int h, idx; 280 dictEntry *he, *prevHe; 281 int table; 282 283 if (d->ht[0].size == 0) return DICT_ERR; /* d->ht[0].table is NULL */ 284 if (dictIsRehashing(d)) _dictRehashStep(d); 285 h = dictHashKey(d, key); 286 287 for (table = 0; table <= 1; table++) { 288 idx = h & d->ht[table].sizemask; 289 he = d->ht[table].table[idx]; 290 prevHe = NULL; 291 while(he) { 292 if (dictCompareHashKeys(d, key, he->key)) { 293 /* Unlink the element from the list */ 294 if (prevHe) 295 prevHe->next = he->next; 296 else 297 d->ht[table].table[idx] = he->next; 298 if (!nofree) { 299 dictFreeEntryKey(d, he); 300 dictFreeEntryVal(d, he); 301 } 302 zfree(he); 303 d->ht[table].used--; 304 return DICT_OK; 305 } 306 prevHe = he; 307 he = he->next; 308 } 309 if (!dictIsRehashing(d)) break; //如果在查找的时刻，dict没有正在进行rehash操作，则此时dict->ht[1]未使用，所以只在dict->ht[0]进行查找操作就可以了 310 } 311 return DICT_ERR; /* not found */ 312 } 313 314 int dictDelete(dict *ht, const void *key) { 315 return dictGenericDelete(ht,key,0); 316 } 317 318 int dictDeleteNoFree(dict *ht, const void *key) { 319 return dictGenericDelete(ht,key,1); 320 } //。。。redis的src目录下没有任何一处调用这个不料理自己后事的delete函数 321 322 /* Destroy an entire dictionary */ 323 int _dictClear(dict *d, dictht *ht) //clear的粒度是hash table而不是dict 324 { 325 unsigned long i; 326 327 /* Free all the elements */ 328 for (i = 0; i < ht->size && ht->used > 0; i++) { 329 dictEntry *he, *nextHe; 330 331 if ((he = ht->table[i]) == NULL) continue; 332 while(he) { 333 nextHe = he->next; 334 dictFreeEntryKey(d, he); 335 dictFreeEntryVal(d, he); 336 zfree(he); 337 ht->used--; 338 he = nextHe; 339 } 340 } 341 /* Free the table and the allocated cache structure */ 342 zfree(ht->table); 343 /* Re-initialize the table */ 344 _dictReset(ht); 345 return DICT_OK; /* never fails */ 346 } 347 348 /* Clear & Release the hash table */ 349 void dictRelease(dict *d) 350 { 351 _dictClear(d,&d->ht[0]); 352 _dictClear(d,&d->ht[1]); 353 zfree(d); 354 } //release的粒度是dict，_dictClear只是一个内部接口 355 356 dictEntry *dictFind(dict *d, const void *key) 357 { 358 dictEntry *he; 359 unsigned int h, idx, table; 360 361 if (d->ht[0].size == 0) return NULL; /* We don't have a table at all */ 362 if (dictIsRehashing(d)) _dictRehashStep(d); 363 h = dictHashKey(d, key); 364 for (table = 0; table <= 1; table++) { 365 idx = h & d->ht[table].sizemask; 366 he = d->ht[table].table[idx]; 367 while(he) { 368 if (dictCompareHashKeys(d, key, he->key)) //为何要传dict参数，因为需要知道具体用什么compare函数作比较操作 369 return he; 370 he = he->next; 371 } 372 if (!dictIsRehashing(d)) return NULL; //没找到，返回NULL，函数就结束了 373 } 374 return NULL; 375 } 376 377 void *dictFetchValue(dict *d, const void *key) { 378 dictEntry *he; 379 380 he = dictFind(d,key); 381 return he ? dictGetEntryVal(he) : NULL; 382 } 383 384 dictIterator *dictGetIterator(dict *d) 385 { 386 dictIterator *iter = zmalloc(sizeof(*iter)); 387 388 iter->d = d; 389 iter->table = 0; 390 iter->index = -1; 391 iter->safe = 0; 392 iter->entry = NULL; 393 iter->nextEntry = NULL; 394 return iter; 395 } //在调用GetIterator函数时，并没有将这个iter在对应的dict上进行注册 396 397 dictIterator *dictGetSafeIterator(dict *d) { 398 dictIterator *i = dictGetIterator(d); 399 400 i->safe = 1; 401 return i; 402 } 403 404 dictEntry *dictNext(dictIterator *iter) 405 { 406 while (1) { 407 if (iter->entry == NULL) { 408 dictht *ht = &iter->d->ht[iter->table]; 409 if (iter->safe && iter->index == -1 && iter->table == 0) 410 iter->d->iterators++; //在对应的dict上进行注册 411 iter->index++; 412 if (iter->index >= (signed) ht->size) { //在对第一个ht遍历完成后，转到第二张表 413 if (dictIsRehashing(iter->d) && iter->table == 0) { 414 iter->table++; 415 iter->index = 0; 416 ht = &iter->d->ht[1]; 417 } else { 418 break; 419 } 420 } 421 iter->entry = ht->table[iter->index]; 422 } else { 423 iter->entry = iter->nextEntry; 424 } 425 if (iter->entry) { 426 /* We need to save the 'next' here, the iterator user 427 * may delete the entry we are returning. */ 428 iter->nextEntry = iter->entry->next; 429 return iter->entry; 430 } 431 } 432 return NULL; 433 } 434 435 void dictReleaseIterator(dictIterator *iter) 436 { 437 if (iter->safe && !(iter->index == -1 && iter->table == 0)) 438 iter->d->iterators--; 439 zfree(iter); 440 } 441 442 /* Return a random entry from the hash table. Useful to 443 * implement randomized algorithms */ 444 dictEntry *dictGetRandomKey(dict *d) 445 { 446 dictEntry *he, *orighe; 447 unsigned int h; 448 int listlen, listele; 449 450 if (dictSize(d) == 0) return NULL; 451 if (dictIsRehashing(d)) _dictRehashStep(d); 452 if (dictIsRehashing(d)) { 453 do { 454 h = random() % (d->ht[0].size+d->ht[1].size); 455 he = (h >= d->ht[0].size) ? d->ht[1].table[h - d->ht[0].size] : 456 d->ht[0].table[h]; 457 } while(he == NULL); 458 } else { 459 do { 460 h = random() & d->ht[0].sizemask; 461 he = d->ht[0].table[h]; 462 } while(he == NULL); 463 } 464 465 /* Now we found a non empty bucket, but it is a linked 466 * list and we need to get a random element from the list. 467 * The only sane way to do so is counting the elements and 468 * select a random index. */ 469 listlen = 0; 470 orighe = he; 471 while(he) { 472 he = he->next; 473 listlen++; 474 } 475 listele = random() % listlen; 476 he = orighe; 477 while(listele--) he = he->next; 478 return he; 479 } //这个函数效率很低啊。 480 481 /* ------------------------- private functions ------------------------------ */ 482 483 /* Expand the hash table if needed */ 484 static int _dictExpandIfNeeded(dict *d) 485 { 486 /* Incremental rehashing already in progress. Return. */ 487 if (dictIsRehashing(d)) return DICT_OK; 488 489 /* If the hash table is empty expand it to the intial size. */ 490 if (d->ht[0].size == 0) return dictExpand(d, DICT_HT_INITIAL_SIZE); 491 492 /* If we reached the 1:1 ratio, and we are allowed to resize the hash 493 * table (global setting) or we should avoid it but the ratio between 494 * elements/buckets is over the "safe" threshold, we resize doubling 495 * the number of buckets. */ 496 if (d->ht[0].used >= d->ht[0].size && 497 (dict_can_resize || 498 d->ht[0].used/d->ht[0].size > dict_force_resize_ratio)) 499 { 500 return dictExpand(d, ((d->ht[0].size > d->ht[0].used) ? 501 d->ht[0].size : d->ht[0].used)*2); 502 } 503 return DICT_OK; 504 } 505 506 /* Our hash table capability is a power of two */ 507 static unsigned long _dictNextPower(unsigned long size) 508 { 509 unsigned long i = DICT_HT_INITIAL_SIZE; 510 511 if (size >= LONG_MAX) return LONG_MAX; 512 while(1) { 513 if (i >= size) 514 return i; 515 i *= 2; 516 } 517 } 518 519 /* Returns the index of a free slot that can be populated with 520 * an hash entry for the given 'key'. 521 * If the key already exists, -1 is returned. 522 * 523 * Note that if we are in the process of rehashing the hash table, the 524 * index is always returned in the context of the second (new) hash table. */ 525 static int _dictKeyIndex(dict *d, const void *key) 526 { 527 unsigned int h, idx, table; 528 dictEntry *he; 529 530 /* Expand the hashtable if needed */ 531 if (_dictExpandIfNeeded(d) == DICT_ERR) 532 return -1; 533 /* Compute the key hash value */ 534 h = dictHashKey(d, key); 535 for (table = 0; table <= 1; table++) { 536 idx = h & d->ht[table].sizemask; 537 /* Search if this slot does not already contain the given key */ 538 he = d->ht[table].table[idx]; 539 while(he) { 540 if (dictCompareHashKeys(d, key, he->key)) 541 return -1; 542 he = he->next; 543 } 544 if (!dictIsRehashing(d)) break; 545 } 546 return idx; 547 } 548 549 void dictEmpty(dict *d) { 550 _dictClear(d,&d->ht[0]); 551 _dictClear(d,&d->ht[1]); 552 d->rehashidx = -1; 553 d->iterators = 0; 554 } 555 556 #define DICT_STATS_VECTLEN 50 557 static void _dictPrintStatsHt(dictht *ht) { 558 unsigned long i, slots = 0, chainlen, maxchainlen = 0; 559 unsigned long totchainlen = 0; 560 unsigned long clvector[DICT_STATS_VECTLEN]; //这个clvector是统计hash table中长度为其下标的槽位的个数 561 562 if (ht->used == 0) { 563 printf("No stats available for empty dictionaries\n"); 564 return; 565 } 566 567 for (i = 0; i < DICT_STATS_VECTLEN; i++) clvector[i] = 0; 568 for (i = 0; i < ht->size; i++) { 569 dictEntry *he; 570 571 if (ht->table[i] == NULL) { 572 clvector[0]++; 573 continue; 574 } 575 slots++; 576 /* For each hash entry on this slot... */ 577 chainlen = 0; 578 he = ht->table[i]; 579 while(he) { 580 chainlen++; 581 he = he->next; 582 } 583 clvector[(chainlen < DICT_STATS_VECTLEN) ? chainlen : (DICT_STATS_VECTLEN-1)]++; 584 if (chainlen > maxchainlen) maxchainlen = chainlen; 585 totchainlen += chainlen; 586 } 587 printf("Hash table stats:\n"); 588 printf(" table size: %ld\n", ht->size); 589 printf(" number of elements: %ld\n", ht->used); 590 printf(" different slots: %ld\n", slots); //非空槽位数 591 printf(" max chain length: %ld\n", maxchainlen); 592 printf(" avg chain length (counted): %.02f\n", (float)totchainlen/slots); 593 printf(" avg chain length (computed): %.02f\n", (float)ht->used/slots); 594 printf(" Chain length distribution:\n"); 595 for (i = 0; i < DICT_STATS_VECTLEN-1; i++) { 596 if (clvector[i] == 0) continue; 597 printf(" %s%ld: %ld (%.02f%%)\n",(i == DICT_STATS_VECTLEN-1)?">= ":"", i, clvector[i], ((float)clvector[i]/ht->size)*100); 598 } 599 } 600 601 void dictPrintStats(dict *d) { 602 _dictPrintStatsHt(&d->ht[0]); 603 if (dictIsRehashing(d)) { 604 printf("-- Rehashing into ht[1]:\n"); 605 _dictPrintStatsHt(&d->ht[1]); 606 } 607 } 608 609 void dictEnableResize(void) { 610 dict_can_resize = 1; 611 } 612 613 void dictDisableResize(void) { 614 dict_can_resize = 0; 615 }