Lines Matching refs:hs
102 typedef long ck_rhs_probe_cb_t(struct ck_rhs *hs,
252 ck_rhs_set_load_factor(struct ck_rhs *hs, unsigned int load_factor)
254 struct ck_rhs_map *map = hs->map;
259 hs->load_factor = load_factor;
260 map->max_entries = (map->capacity * (unsigned long)hs->load_factor) / 100;
262 if (ck_rhs_grow(hs, map->capacity << 1) == false)
264 map = hs->map;
279 ck_rhs_next(struct ck_rhs *hs, struct ck_rhs_iterator *i, void **key)
281 struct ck_rhs_map *map = hs->map;
291 if (hs->mode & CK_RHS_MODE_OBJECT)
304 ck_rhs_stat(struct ck_rhs *hs, struct ck_rhs_stat *st)
306 struct ck_rhs_map *map = hs->map;
314 ck_rhs_count(struct ck_rhs *hs)
317 return hs->map->n_entries;
329 ck_rhs_destroy(struct ck_rhs *hs)
332 ck_rhs_map_destroy(hs->m, hs->map, false);
337 ck_rhs_map_create(struct ck_rhs *hs, unsigned long entries)
346 if (hs->mode & CK_RHS_MODE_READ_MOSTLY)
355 map = hs->m->malloc(size);
358 map->read_mostly = !!(hs->mode & CK_RHS_MODE_READ_MOSTLY);
373 map->max_entries = (map->capacity * (unsigned long)hs->load_factor) / 100;
401 ck_rhs_reset_size(struct ck_rhs *hs, unsigned long capacity)
405 previous = hs->map;
406 map = ck_rhs_map_create(hs, capacity);
410 ck_pr_store_ptr(&hs->map, map);
411 ck_rhs_map_destroy(hs->m, previous, true);
416 ck_rhs_reset(struct ck_rhs *hs)
420 previous = hs->map;
421 return ck_rhs_reset_size(hs, previous->capacity);
494 ck_rhs_grow(struct ck_rhs *hs,
502 map = hs->map;
506 update = ck_rhs_map_create(hs, capacity);
518 if (hs->mode & CK_RHS_MODE_OBJECT)
522 h = hs->hf(previous, hs->seed);
533 ck_rhs_map_destroy(hs->m, update, false);
549 if (hs->mode & CK_RHS_MODE_OBJECT)
554 h = hs->hf(previous, hs->seed);
567 ck_pr_store_ptr(&hs->map, update);
568 ck_rhs_map_destroy(hs->m, map, true);
573 ck_rhs_rebuild(struct ck_rhs *hs)
576 return ck_rhs_grow(hs, hs->map->capacity);
580 ck_rhs_map_probe_rm(struct ck_rhs *hs,
599 if (hs->mode & CK_RHS_MODE_OBJECT) {
654 if (hs->mode & CK_RHS_MODE_OBJECT) {
667 if (hs->compare == NULL) {
672 if (hs->compare(k, key) == true)
692 ck_rhs_map_probe(struct ck_rhs *hs,
711 if (hs->mode & CK_RHS_MODE_OBJECT) {
768 if (hs->mode & CK_RHS_MODE_OBJECT) {
781 if (hs->compare == NULL) {
786 if (hs->compare(k, key) == true)
827 ck_rhs_gc(struct ck_rhs *hs)
830 struct ck_rhs_map *map = hs->map;
842 ck_rhs_add_wanted(struct ck_rhs *hs, long end_offset, long old_slot,
845 struct ck_rhs_map *map = hs->map;
869 ck_rhs_remove_wanted(struct ck_rhs *hs, long offset, long limit)
871 struct ck_rhs_map *map = hs->map;
906 ck_rhs_put_robin_hood(struct ck_rhs *hs,
920 map = hs->map;
927 if (hs->mode & CK_RHS_MODE_OBJECT)
933 slot = map->probe_func(hs, map, &n_probes, &first, h, key, &object,
938 if (ck_rhs_grow(hs, map->capacity << 1) == false) {
970 ck_rhs_add_wanted(hs, slot, orig_slot, h);
978 ck_rhs_add_wanted(hs, orig_slot, prev, h);
989 ck_rhs_do_backward_shift_delete(struct ck_rhs *hs, long slot)
991 struct ck_rhs_map *map = hs->map;
996 h = ck_rhs_remove_wanted(hs, slot, -1);
1024 h = ck_rhs_remove_wanted(hs, offset, slot);
1069 ck_rhs_fas(struct ck_rhs *hs,
1078 struct ck_rhs_map *map = hs->map;
1083 slot = map->probe_func(hs, map, &n_probes, &first, h, key, &object,
1090 insert = ck_rhs_marshal(hs->mode, key, h);
1098 ret = ck_rhs_put_robin_hood(hs, first, desc2);
1108 ck_rhs_add_wanted(hs, first, -1, h);
1109 ck_rhs_do_backward_shift_delete(hs, slot);
1131 ck_rhs_apply(struct ck_rhs *hs,
1145 map = hs->map;
1147 slot = map->probe_func(hs, map, &n_probes, &first, h, key, &object, map->probe_limit, CK_RHS_PROBE_INSERT);
1149 if (ck_rhs_grow(hs, map->capacity << 1) == false)
1168 ck_rhs_do_backward_shift_delete(hs, slot);
1179 insert = ck_rhs_marshal(hs->mode, delta, h);
1191 int ret = ck_rhs_put_robin_hood(hs, first, desc2);
1209 ck_rhs_add_wanted(hs, first, -1, h);
1213 ck_rhs_do_backward_shift_delete(hs, slot);
1223 ck_rhs_add_wanted(hs, slot, -1, h);
1229 ck_rhs_grow(hs, map->capacity << 1);
1235 ck_rhs_set(struct ck_rhs *hs,
1249 map = hs->map;
1251 slot = map->probe_func(hs, map, &n_probes, &first, h, key, &object, map->probe_limit, CK_RHS_PROBE_INSERT);
1253 if (ck_rhs_grow(hs, map->capacity << 1) == false)
1259 insert = ck_rhs_marshal(hs->mode, key, h);
1268 int ret = ck_rhs_put_robin_hood(hs, first, desc2);
1286 ck_rhs_add_wanted(hs, first, -1, h);
1290 ck_rhs_do_backward_shift_delete(hs, slot);
1301 ck_rhs_add_wanted(hs, slot, -1, h);
1307 ck_rhs_grow(hs, map->capacity << 1);
1315 ck_rhs_put_internal(struct ck_rhs *hs,
1327 map = hs->map;
1329 slot = map->probe_func(hs, map, &n_probes, &first, h, key, &object,
1333 if (ck_rhs_grow(hs, map->capacity << 1) == false)
1344 insert = ck_rhs_marshal(hs->mode, key, h);
1348 int ret = ck_rhs_put_robin_hood(hs, first, desc);
1350 return ck_rhs_put_internal(hs, h, key, behavior);
1356 ck_rhs_add_wanted(hs, first, -1, h);
1361 ck_rhs_add_wanted(hs, slot, -1, h);
1366 ck_rhs_grow(hs, map->capacity << 1);
1371 ck_rhs_put(struct ck_rhs *hs,
1376 return ck_rhs_put_internal(hs, h, key, CK_RHS_PROBE_INSERT);
1380 ck_rhs_put_unique(struct ck_rhs *hs,
1385 return ck_rhs_put_internal(hs, h, key, CK_RHS_PROBE_RH);
1389 ck_rhs_get(struct ck_rhs *hs,
1401 map = ck_pr_load_ptr(&hs->map);
1408 map->probe_func(hs, map, &n_probes, &first, h, key, &object, probe, CK_RHS_PROBE_NO_RH);
1418 ck_rhs_remove(struct ck_rhs *hs,
1424 struct ck_rhs_map *map = hs->map;
1427 slot = map->probe_func(hs, map, &n_probes, &first, h, key, &object,
1433 ck_rhs_do_backward_shift_delete(hs, slot);
1438 ck_rhs_move(struct ck_rhs *hs,
1448 hs->mode = source->mode;
1449 hs->seed = source->seed;
1450 hs->map = source->map;
1451 hs->load_factor = source->load_factor;
1452 hs->m = m;
1453 hs->hf = hf;
1454 hs->compare = compare;
1459 ck_rhs_init(struct ck_rhs *hs,
1471 hs->m = m;
1472 hs->mode = mode;
1473 hs->seed = seed;
1474 hs->hf = hf;
1475 hs->compare = compare;
1476 hs->load_factor = CK_RHS_DEFAULT_LOAD_FACTOR;
1478 hs->map = ck_rhs_map_create(hs, n_entries);
1479 return hs->map != NULL;