upstream/bind9
1
0
Fork 0
mirror of https://github.com/isc-projects/bind9.git synced 2026-03-15 15:12:56 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions
bind9/tests/isc/ht_test.c
Ondřej Surý 8c31a939c9
Implement incremental hash table resizing in isc_ht 
Previously, an incremental hash table resizing was implemented for the
dns_rbt_t hash table implementation.  Using that as a base, also
implement the incremental hash table resizing also for isc_ht API
hashtables:

 1. During the resize, allocate the new hash table, but keep the old
    table unchanged.
 2. In each lookup, delete, or iterator operation, check both tables.
 3. Perform insertion operations only in the new table.
 4. At each insertion also move <r> elements from the old table to
    the new table.
 5. When all elements are removed from the old table, deallocate it.

To ensure that the old table is completely copied over before the new
table itself needs to be enlarged, it is necessary to increase the
size of the table by a factor of at least (<r> + 1)/<r> during resizing.

In our implementation <r> is equal to 1.

The downside of this approach is that the old table and the new table
could stay in memory for longer when there are no new insertions into
the hash table for prolonged periods of time as the incremental
rehashing happens only during the insertions.

(cherry picked from commit e42cb1f198)
2023-01-11 17:15:33 +01:00

322 lines
8.4 KiB
C
Raw Blame History

/*
* Copyright (C) Internet Systems Consortium, Inc. ("ISC")
*
* SPDX-License-Identifier: MPL-2.0
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, you can obtain one at https://mozilla.org/MPL/2.0/.
*
* See the COPYRIGHT file distributed with this work for additional
* information regarding copyright ownership.
*/
#include <inttypes.h>
#include <sched.h> /* IWYU pragma: keep */
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define UNIT_TESTING
#include <cmocka.h>
#include <isc/hash.h>
#include <isc/ht.h>
#include <isc/mem.h>
#include <isc/print.h>
#include <isc/string.h>
#include <isc/util.h>
#include <tests/isc.h>
/* INCLUDE LAST */
#define mctx __mctx
#include "ht.c"
#undef mctx
static void
test_ht_full(int bits, uintptr_t count) {
isc_ht_t *ht = NULL;
isc_result_t result;
uintptr_t i;
isc_ht_init(&ht, mctx, bits, ISC_HT_CASE_SENSITIVE);
assert_non_null(ht);
for (i = 1; i < count; i++) {
/*
* Note: snprintf() is followed with strlcat()
* to ensure we are always filling the 16 byte key.
*/
unsigned char key[16];
snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);
strlcat((char *)key, " key of a raw hashtable!!", sizeof(key));
result = isc_ht_add(ht, key, 16, (void *)i);
assert_int_equal(result, ISC_R_SUCCESS);
}
for (i = 1; i < count; i++) {
unsigned char key[16];
void *f = NULL;
snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);
strlcat((char *)key, " key of a raw hashtable!!", sizeof(key));
result = isc_ht_find(ht, key, 16, &f);
assert_int_equal(result, ISC_R_SUCCESS);
assert_ptr_equal((void *)i, (uintptr_t)f);
}
for (i = 1; i < count; i++) {
unsigned char key[16];
snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);
strlcat((char *)key, " key of a raw hashtable!!", sizeof(key));
result = isc_ht_add(ht, key, 16, (void *)i);
assert_int_equal(result, ISC_R_EXISTS);
}
for (i = 1; i < count; i++) {
char key[64];
/*
* Note: the key size is now strlen(key) which is bigger
* then the keys added above.
*/
snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);
strlcat((char *)key, " key of a raw hashtable!!", sizeof(key));
result = isc_ht_add(ht, (const unsigned char *)key, strlen(key),
(void *)i);
assert_int_equal(result, ISC_R_SUCCESS);
}
for (i = 1; i < count; i++) {
unsigned char key[16];
void *f = NULL;
/*
* Note: case of KEY is now in capitals,
*/
snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);
strlcat((char *)key, " KEY of a raw hashtable!!", sizeof(key));
result = isc_ht_find(ht, key, 16, &f);
assert_int_equal(result, ISC_R_NOTFOUND);
assert_null(f);
}
for (i = 1; i < count; i++) {
char key[64];
void *f = NULL;
snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);
strlcat((char *)key, " key of a raw hashtable!!", sizeof(key));
result = isc_ht_find(ht, (const unsigned char *)key,
strlen(key), &f);
assert_int_equal(result, ISC_R_SUCCESS);
assert_ptr_equal(f, (void *)i);
}
for (i = 1; i < count; i++) {
unsigned char key[16];
void *f = NULL;
snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);
strlcat((char *)key, " key of a raw hashtable!!", sizeof(key));
result = isc_ht_delete(ht, key, 16);
assert_int_equal(result, ISC_R_SUCCESS);
result = isc_ht_find(ht, key, 16, &f);
assert_int_equal(result, ISC_R_NOTFOUND);
assert_null(f);
}
for (i = 1; i < count; i++) {
unsigned char key[16];
/*
* Note: upper case KEY.
*/
snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);
strlcat((char *)key, " KEY of a raw hashtable!!", sizeof(key));
result = isc_ht_add(ht, key, 16, (void *)i);
assert_int_equal(result, ISC_R_SUCCESS);
}
for (i = 1; i < count; i++) {
char key[64];
void *f = NULL;
snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);
strlcat((char *)key, " key of a raw hashtable!!", sizeof(key));
result = isc_ht_delete(ht, (const unsigned char *)key,
strlen(key));
assert_int_equal(result, ISC_R_SUCCESS);
result = isc_ht_find(ht, (const unsigned char *)key,
strlen(key), &f);
assert_int_equal(result, ISC_R_NOTFOUND);
assert_null(f);
}
for (i = 1; i < count; i++) {
unsigned char key[16];
void *f = NULL;
/*
* Note: case of KEY is now in capitals,
*/
snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);
strlcat((char *)key, " KEY of a raw hashtable!!", sizeof(key));
result = isc_ht_find(ht, key, 16, &f);
assert_int_equal(result, ISC_R_SUCCESS);
assert_ptr_equal((void *)i, (uintptr_t)f);
}
for (i = 1; i < count; i++) {
unsigned char key[16];
void *f = NULL;
snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);
strlcat((char *)key, " key of a raw hashtable!!", sizeof(key));
result = isc_ht_find(ht, key, 16, &f);
assert_int_equal(result, ISC_R_NOTFOUND);
assert_null(f);
}
isc_ht_destroy(&ht);
assert_null(ht);
}
static void
test_ht_iterator(void) {
isc_ht_t *ht = NULL;
isc_result_t result;
isc_ht_iter_t *iter = NULL;
uintptr_t i;
uintptr_t count = 10000;
uint32_t walked;
unsigned char key[16];
size_t tksize;
isc_ht_init(&ht, mctx, 16, ISC_HT_CASE_SENSITIVE);
assert_non_null(ht);
for (i = 1; i <= count; i++) {
/*
* Note that the string we're snprintfing is always > 16 bytes
* so we are always filling the key.
*/
snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);
strlcat((char *)key, "key of a raw hashtable!!", sizeof(key));
result = isc_ht_add(ht, key, 16, (void *)i);
assert_int_equal(result, ISC_R_SUCCESS);
}
walked = 0;
isc_ht_iter_create(ht, &iter);
for (result = isc_ht_iter_first(iter); result == ISC_R_SUCCESS;
result = isc_ht_iter_next(iter))
{
unsigned char *tkey = NULL;
void *v = NULL;
isc_ht_iter_current(iter, &v);
isc_ht_iter_currentkey(iter, &tkey, &tksize);
assert_int_equal(tksize, 16);
i = (uintptr_t)v;
snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);
strlcat((char *)key, "key of a raw hashtable!!", sizeof(key));
assert_memory_equal(key, tkey, 16);
walked++;
}
assert_int_equal(walked, count);
assert_int_equal(result, ISC_R_NOMORE);
/* erase odd */
walked = 0;
result = isc_ht_iter_first(iter);
while (result == ISC_R_SUCCESS) {
unsigned char *tkey = NULL;
void *v = NULL;
isc_ht_iter_current(iter, &v);
isc_ht_iter_currentkey(iter, &tkey, &tksize);
assert_int_equal(tksize, 16);
i = (uintptr_t)v;
snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);
strlcat((char *)key, "key of a raw hashtable!!", sizeof(key));
assert_memory_equal(key, tkey, 16);
if ((uintptr_t)v % 2 == 0) {
result = isc_ht_iter_delcurrent_next(iter);
} else {
result = isc_ht_iter_next(iter);
}
walked++;
}
assert_int_equal(result, ISC_R_NOMORE);
assert_int_equal(walked, count);
/* erase even */
walked = 0;
result = isc_ht_iter_first(iter);
while (result == ISC_R_SUCCESS) {
unsigned char *tkey = NULL;
void *v = NULL;
isc_ht_iter_current(iter, &v);
isc_ht_iter_currentkey(iter, &tkey, &tksize);
assert_int_equal(tksize, 16);
i = (uintptr_t)v;
snprintf((char *)key, sizeof(key), "%u", (unsigned int)i);
strlcat((char *)key, "key of a raw hashtable!!", sizeof(key));
assert_memory_equal(key, tkey, 16);
if ((uintptr_t)v % 2 == 1) {
result = isc_ht_iter_delcurrent_next(iter);
} else {
result = isc_ht_iter_next(iter);
}
walked++;
}
assert_int_equal(result, ISC_R_NOMORE);
assert_int_equal(walked, count / 2);
walked = 0;
for (result = isc_ht_iter_first(iter); result == ISC_R_SUCCESS;
result = isc_ht_iter_next(iter))
{
walked++;
}
assert_int_equal(result, ISC_R_NOMORE);
assert_int_equal(walked, 0);
isc_ht_iter_destroy(&iter);
assert_null(iter);
isc_ht_destroy(&ht);
assert_null(ht);
}
/* 20 bit, 200K elements test */
ISC_RUN_TEST_IMPL(isc_ht_20) {
UNUSED(state);
test_ht_full(20, 200000);
}
/* 8 bit, 20000 elements crowded test */
ISC_RUN_TEST_IMPL(isc_ht_8) {
UNUSED(state);
test_ht_full(8, 20000);
}
ISC_RUN_TEST_IMPL(isc_ht_1) {
UNUSED(state);
test_ht_full(1, 100);
}
/* test hashtable iterator */
ISC_RUN_TEST_IMPL(isc_ht_iterator) {
UNUSED(state);
test_ht_iterator();
}
ISC_TEST_LIST_START
ISC_TEST_ENTRY(isc_ht_20)
ISC_TEST_ENTRY(isc_ht_8)
ISC_TEST_ENTRY(isc_ht_1)
ISC_TEST_ENTRY(isc_ht_iterator)
ISC_TEST_LIST_END
ISC_TEST_MAIN
Reference in a new issue View git blame Copy permalink