static struct radix_tree_node * alloc_radix_tree_node(struct radix_tree *tree, struct radix_tree_node *parent) { struct radix_tree_node *node; size_t size; size = sizeof(struct radix_tree_node *) * slot_count(tree); node = zalloc(sizeof(struct radix_tree_node) + size); if (!node) return NULL; node->parent = parent; return node; }
static void free_radix_tree_node(struct radix_tree *tree, struct radix_tree_node *node, int level) { if (level < level_count(tree) - 1) { int i; for (i = 0; i < slot_count(tree); i++) { if (node->slots[i] == NULL) continue; free_radix_tree_node(tree, node->slots[i], level + 1); } } free(node); }
static void * radix_tree_last(struct radix_tree *tree, struct radix_tree_node *node, int level) { while (level < level_count(tree)) { int i; for (i = slot_count(tree) - 1; i >= 0; i--) if (node->slots[i] != NULL) break; if (i < 0) return NULL; node = node->slots[i]; level++; } return node; }
void quotient_filter<Key, Hash, Bits>::regenerate(size_type count) { const auto min_slot_count = static_cast<size_type>(std::ceil(size() / max_load_factor())); const auto new_slot_count = std::max(min_slot_count, count); if (!new_slot_count) { filter = quotient_filter_fp(); assert(max_allowed_size() == 0); return; } const size_type q_bits = calc_required_q(new_slot_count); const size_type r_bits = hash_bits - q_bits; if (q_bits == filter.quotient_bits() && r_bits == filter.remainder_bits()) { // Note that remainder_bits() is not always fp - quotient_bits(). If filter // was default constructed both of them are zero. return; // No regeneration is necessary. } if (r_bits == 0) throw std::length_error("The number of bits of elements (hash values) " "contained in the filter is not enough to hold the " "required slot count."); quotient_filter_fp temp(q_bits, r_bits); assert(temp.capacity() != filter.capacity() && "Regeneration should not have been required"); for (const auto hash_value : filter) temp.insert(hash_value); assert(temp.size() == filter.size()); // Everything is ok. filter = std::move(temp); assert(count <= slot_count()); // Meets the requirements. }
// Returns the current max allowed size according to the number of allocated // slots and the maximum load factor. size_type max_allowed_size() const noexcept { const float ans = max_load_factor() * slot_count(); return std::min(static_cast<size_type>(ans), slot_count()); }
// Hash policy float load_factor() const noexcept { return empty() ? 0.0f : float(size()) / float(slot_count()); }