Ondřej Surý
8c31a939c9
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)
192 lines
4.3 KiB
C
192 lines
4.3 KiB
C
/*
|
|
* 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.
|
|
*/
|
|
|
|
/* ! \file */
|
|
|
|
#pragma once
|
|
|
|
#include <inttypes.h>
|
|
#include <string.h>
|
|
|
|
#include <isc/result.h>
|
|
#include <isc/types.h>
|
|
|
|
typedef struct isc_ht isc_ht_t;
|
|
typedef struct isc_ht_iter isc_ht_iter_t;
|
|
|
|
enum { ISC_HT_CASE_SENSITIVE = 0x00, ISC_HT_CASE_INSENSITIVE = 0x01 };
|
|
|
|
/*%
|
|
* Initialize hashtable at *htp, using memory context and size of (1<<bits)
|
|
*
|
|
* If 'options' contains ISC_HT_CASE_INSENSITIVE, then upper- and lower-case
|
|
* letters in key values will generate the same hash values; this can be used
|
|
* when the key for a hash table is a DNS name.
|
|
*
|
|
* Requires:
|
|
*\li 'htp' is not NULL and '*htp' is NULL.
|
|
*\li 'mctx' is a valid memory context.
|
|
*\li 'bits' >=1 and 'bits' <=32
|
|
*
|
|
*/
|
|
void
|
|
isc_ht_init(isc_ht_t **htp, isc_mem_t *mctx, uint8_t bits,
|
|
unsigned int options);
|
|
|
|
/*%
|
|
* Destroy hashtable, freeing everything
|
|
*
|
|
* Requires:
|
|
* \li '*htp' is valid hashtable
|
|
*/
|
|
void
|
|
isc_ht_destroy(isc_ht_t **htp);
|
|
|
|
/*%
|
|
* Add a node to hashtable, pointed by binary key 'key' of size 'keysize';
|
|
* set its value to 'value'
|
|
*
|
|
* Requires:
|
|
*\li 'ht' is a valid hashtable
|
|
*\li write-lock
|
|
*
|
|
* Returns:
|
|
*\li #ISC_R_NOMEMORY -- not enough memory to create pool
|
|
*\li #ISC_R_EXISTS -- node of the same key already exists
|
|
*\li #ISC_R_SUCCESS -- all is well.
|
|
*/
|
|
isc_result_t
|
|
isc_ht_add(isc_ht_t *ht, const unsigned char *key, const uint32_t keysize,
|
|
void *value);
|
|
|
|
/*%
|
|
* Find a node matching 'key'/'keysize' in hashtable 'ht';
|
|
* if found, set '*valuep' to its value. (If 'valuep' is NULL,
|
|
* then simply return SUCCESS or NOTFOUND to indicate whether the
|
|
* key exists in the hashtable.)
|
|
*
|
|
* Requires:
|
|
* \li 'ht' is a valid hashtable
|
|
* \li read-lock
|
|
*
|
|
* Returns:
|
|
* \li #ISC_R_SUCCESS -- success
|
|
* \li #ISC_R_NOTFOUND -- key not found
|
|
*/
|
|
isc_result_t
|
|
isc_ht_find(const isc_ht_t *ht, const unsigned char *key,
|
|
const uint32_t keysize, void **valuep);
|
|
|
|
/*%
|
|
* Delete node from hashtable
|
|
*
|
|
* Requires:
|
|
*\li ht is a valid hashtable
|
|
*\li write-lock
|
|
*
|
|
* Returns:
|
|
*\li #ISC_R_NOTFOUND -- key not found
|
|
*\li #ISC_R_SUCCESS -- all is well
|
|
*/
|
|
isc_result_t
|
|
isc_ht_delete(isc_ht_t *ht, const unsigned char *key, const uint32_t keysize);
|
|
|
|
/*%
|
|
* Create an iterator for the hashtable; point '*itp' to it.
|
|
*
|
|
* Requires:
|
|
*\li 'ht' is a valid hashtable
|
|
*\li 'itp' is non NULL and '*itp' is NULL.
|
|
*/
|
|
void
|
|
isc_ht_iter_create(isc_ht_t *ht, isc_ht_iter_t **itp);
|
|
|
|
/*%
|
|
* Destroy the iterator '*itp', set it to NULL
|
|
*
|
|
* Requires:
|
|
*\li 'itp' is non NULL and '*itp' is non NULL.
|
|
*/
|
|
void
|
|
isc_ht_iter_destroy(isc_ht_iter_t **itp);
|
|
|
|
/*%
|
|
* Set an iterator to the first entry.
|
|
*
|
|
* Requires:
|
|
*\li 'it' is non NULL.
|
|
*
|
|
* Returns:
|
|
* \li #ISC_R_SUCCESS -- success
|
|
* \li #ISC_R_NOMORE -- no data in the hashtable
|
|
*/
|
|
isc_result_t
|
|
isc_ht_iter_first(isc_ht_iter_t *it);
|
|
|
|
/*%
|
|
* Set an iterator to the next entry.
|
|
*
|
|
* Requires:
|
|
*\li 'it' is non NULL.
|
|
*
|
|
* Returns:
|
|
* \li #ISC_R_SUCCESS -- success
|
|
* \li #ISC_R_NOMORE -- end of hashtable reached
|
|
*/
|
|
isc_result_t
|
|
isc_ht_iter_next(isc_ht_iter_t *it);
|
|
|
|
/*%
|
|
* Delete current entry and set an iterator to the next entry.
|
|
*
|
|
* Requires:
|
|
*\li 'it' is non NULL.
|
|
*
|
|
* Returns:
|
|
* \li #ISC_R_SUCCESS -- success
|
|
* \li #ISC_R_NOMORE -- end of hashtable reached
|
|
*/
|
|
isc_result_t
|
|
isc_ht_iter_delcurrent_next(isc_ht_iter_t *it);
|
|
|
|
/*%
|
|
* Set 'value' to the current value under the iterator
|
|
*
|
|
* Requires:
|
|
*\li 'it' is non NULL.
|
|
*\li 'valuep' is non NULL and '*valuep' is NULL.
|
|
*/
|
|
void
|
|
isc_ht_iter_current(isc_ht_iter_t *it, void **valuep);
|
|
|
|
/*%
|
|
* Set 'key' and 'keysize to the current key and keysize for the value
|
|
* under the iterator
|
|
*
|
|
* Requires:
|
|
*\li 'it' is non NULL.
|
|
*\li 'key' is non NULL and '*key' is NULL.
|
|
*\li 'keysize' is non NULL.
|
|
*/
|
|
void
|
|
isc_ht_iter_currentkey(isc_ht_iter_t *it, unsigned char **key, size_t *keysize);
|
|
|
|
/*%
|
|
* Returns the number of items in the hashtable.
|
|
*
|
|
* Requires:
|
|
*\li 'ht' is a valid hashtable
|
|
*/
|
|
size_t
|
|
isc_ht_count(const isc_ht_t *ht);
|