From fea6eae9a6a0d857c645aa4beaf99de389190507 Mon Sep 17 00:00:00 2001 From: LoRd_MuldeR Date: Mon, 21 Nov 2022 15:02:07 +0100 Subject: [PATCH] Some improvements. --- hashset/src/main.c | 10 ++++- libhashset/include/hash_set.h | 2 +- libhashset/src/hash_set.c | 73 ++++++++++++++++++++++++++++------- 3 files changed, 68 insertions(+), 17 deletions(-) diff --git a/hashset/src/main.c b/hashset/src/main.c index 0ce5bcc..295ed46 100644 --- a/hashset/src/main.c +++ b/hashset/src/main.c @@ -47,7 +47,15 @@ int main() const clock_t now = clock(); if ((now < last_update) || (now >= last_update + CLOCKS_PER_SEC)) { - printf("%zu\n", hash_set_size(hash_set)); + size_t capacity, valid, deleted, limit; + if (!hash_set_info(hash_set, &capacity, &valid, &deleted, &limit)) + { + printf("%010zu, %010zu, %010zu, %010zu\n", capacity, valid, deleted, limit); + } + else + { + printf("%zu\n", hash_set_size(hash_set)); + } last_update = now; } } diff --git a/libhashset/include/hash_set.h b/libhashset/include/hash_set.h index a391462..df92e68 100644 --- a/libhashset/include/hash_set.h +++ b/libhashset/include/hash_set.h @@ -14,7 +14,6 @@ extern "C" { #endif #define HASHSET_OPT_FAILFAST UINT16_C(0x1) -#define HASHSET_ITERATOR_INIT ((size_t)0U) struct _hash_set; typedef struct _hash_set hash_set_t; @@ -29,6 +28,7 @@ errno_t hash_set_contains(const hash_set_t *const instance, const uint64_t value errno_t hash_set_iterate(const hash_set_t *const instance, size_t *const offset, uint64_t *const value); size_t hash_set_size(hash_set_t *const instance); +errno_t hash_set_info(hash_set_t *const instance, size_t *const capacity, size_t *const valid, size_t *const deleted, size_t *const limit); #ifdef __cplusplus } diff --git a/libhashset/src/hash_set.c b/libhashset/src/hash_set.c index 0722eb0..c9d71d1 100644 --- a/libhashset/src/hash_set.c +++ b/libhashset/src/hash_set.c @@ -34,7 +34,7 @@ struct _hash_set { double load_factor; uint16_t options; - size_t count, deleted, limit; + size_t valid, deleted, limit; struct _hash_set_data data; }; @@ -52,21 +52,36 @@ struct _hash_set /* Math */ /* ------------------------------------------------- */ -static FORCE_INLINE size_t round_sz(double d) -{ - return (d >= 0.0) ? ((d > ((double)SIZE_MAX)) ? SIZE_MAX : ((size_t)(d + 0.5))) : 0U; -} - static FORCE_INLINE size_t div_ceil(const size_t value, const size_t divisor) { return (value / divisor) + ((value % divisor != 0U) ? 1U : 0U); } +static FORCE_INLINE size_t round_sz(double d) +{ + return (d >= 0.0) ? ((d + 0.5 >= ((double)SIZE_MAX)) ? SIZE_MAX : ((size_t)(d + 0.5))) : 0U; +} + static FORCE_INLINE size_t safe_mult2(const size_t value) { return (value < (SIZE_MAX >> 1)) ? (value << 1) : SIZE_MAX; } +static FORCE_INLINE size_t safe_add(const size_t a, const size_t b) +{ + return ((SIZE_MAX - a) > b) ? (a + b) : SIZE_MAX; +} + +static FORCE_INLINE size_t safe_incr(const size_t value) +{ + return (value < SIZE_MAX) ? (value + 1U) : SIZE_MAX; +} + +static FORCE_INLINE size_t safe_decr(const size_t value) +{ + return (value > 0U) ? (value - 1U) : 0U; +} + static FORCE_INLINE size_t next_pow2(const size_t minimum) { size_t result = sizeof(uint64_t); @@ -308,11 +323,11 @@ errno_t hash_set_insert(hash_set_t *const instance, const uint64_t value) return EEXIST; } - while ((instance->count >= instance->limit) || (instance->count >= instance->data.capacity)) + while ((safe_add(instance->valid, instance->deleted) >= instance->limit) || (instance->valid >= instance->data.capacity)) { if (instance->data.capacity == SIZE_MAX) { - if ((instance->options & HASHSET_OPT_FAILFAST) || (instance->count >= instance->data.capacity)) + if ((instance->options & HASHSET_OPT_FAILFAST) || (instance->valid >= instance->data.capacity)) { return ENOMEM; /*malloc has failed!*/ } @@ -324,7 +339,7 @@ errno_t hash_set_insert(hash_set_t *const instance, const uint64_t value) { if (error == ENOMEM) { - if ((instance->options & HASHSET_OPT_FAILFAST) || (instance->count >= instance->data.capacity)) + if ((instance->options & HASHSET_OPT_FAILFAST) || (instance->valid >= instance->data.capacity)) { return ENOMEM; /*malloc has failed!*/ } @@ -347,10 +362,10 @@ errno_t hash_set_insert(hash_set_t *const instance, const uint64_t value) if (!store_value(&instance->data, index, value)) { - --instance->deleted; + instance->deleted = safe_decr(instance->deleted); } - ++instance->count; + instance->valid = safe_incr(instance->valid); return 0; } @@ -379,11 +394,12 @@ errno_t hash_set_remove(hash_set_t *const instance, const uint64_t value) } set_flag(instance->data.deleted, index); - --instance->count; + instance->deleted = safe_incr(instance->deleted); + instance->valid = safe_decr(instance->valid); - if (++instance->deleted > (instance->data.capacity >> 1)) + if (instance->deleted > (instance->data.capacity >> 1)) { - const errno_t error = rebuild_set(instance, next_pow2(round_sz(instance->count / instance->load_factor))); + const errno_t error = rebuild_set(instance, next_pow2(round_sz(instance->valid / instance->load_factor))); if (error && ((error != ENOMEM) || (instance->options & HASHSET_OPT_FAILFAST))) { return error; @@ -421,5 +437,32 @@ errno_t hash_set_iterate(const hash_set_t *const instance, size_t *const offset, size_t hash_set_size(hash_set_t *const instance) { - return instance ? instance->count : 0U; + return instance ? instance->valid : 0U; +} + +errno_t hash_set_info(hash_set_t *const instance, size_t *const capacity, size_t *const valid, size_t *const deleted, size_t *const limit) +{ + if ((!instance) || (!instance->data.values)) + { + return EINVAL; + } + + if (capacity) + { + *capacity = instance->data.capacity; + } + if (valid) + { + *valid = instance->valid; + } + if (deleted) + { + *deleted = instance->deleted; + } + if (limit) + { + *limit = instance->limit; + } + + return 0; }