admin/C-Macro-Collections
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Some fixes to bitset

Browse Source
This commit is contained in:
Leonardo Vencovsky committed 2020-06-24 16:57:38 -03:00
1 parent ce470f50b5
commit fe056c1b06
5 files changed
+63 -62
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

tests/include/cmc/bitset.h
+1 -8
View File
@@ -8,6 +8,7 @@ struct bitset
{
cmc_bitset_word *buffer;
size_t capacity;
size_t count;
int flag;
struct cmc_alloc_node *alloc;
struct cmc_callbacks *callbacks;
@@ -39,13 +40,5 @@ _Bool bs_clear_all(struct bitset *_bitset_);
_Bool bs_flip_all(struct bitset *_bitset_);
_Bool bs_get(struct bitset *_bitset_, size_t bit_index);
_Bool bs_resize(struct bitset *_bitset_, size_t n_bits);
static inline size_t bs_bit_to_index(size_t idx)
{
static const size_t shift =
((sizeof(cmc_bitset_word) * 8) >> 6) > 0
? 6
: ((sizeof(cmc_bitset_word) * 8) >> 5) > 0 ? 5 : ((sizeof(cmc_bitset_word) * 8) >> 4) > 0 ? 4 : 3;
return idx >> shift;
}
#endif /* CMC_CMC_BITSET_TEST_H */
tests/src/cmc/bitset.c
+13 -13
View File
@@ -13,7 +13,7 @@ struct bitset *bs_new_custom(size_t n_bits, struct cmc_alloc_node *alloc, struct
return ((void *)0);
if (!alloc)
alloc = &cmc_alloc_node_default;
size_t capacity = bs_bit_to_index(n_bits - 1) + 1;
size_t capacity = cmc_bidx_to_widx(n_bits - 1) + 1;
struct bitset *_bitset_ = alloc->malloc(sizeof(struct bitset));
if (!_bitset_)
return ((void *)0);
@@ -42,7 +42,7 @@ struct bitset bs_init_custom(size_t n_bits, struct cmc_alloc_node *alloc,
return _bitset_;
if (!alloc)
alloc = &cmc_alloc_node_default;
size_t capacity = bs_bit_to_index(n_bits - 1) + 1;
size_t capacity = cmc_bidx_to_widx(n_bits - 1) + 1;
_bitset_.buffer = alloc->calloc(capacity, sizeof(cmc_bitset_word));
if (!_bitset_.buffer)
return _bitset_;
@@ -76,7 +76,7 @@ _Bool bs_set(struct bitset *_bitset_, size_t bit_index)
if (!bs_impl_resize(_bitset_, bit_index + 1, 0))
return 0;
const cmc_bitset_word bits = sizeof(cmc_bitset_word) * 8;
size_t i = bs_bit_to_index(bit_index);
size_t i = cmc_bidx_to_widx(bit_index);
_bitset_->buffer[i] |= ((cmc_bitset_word)1) << (bit_index % bits);
_bitset_->flag = CMC_FLAG_OK;
if ((_bitset_)->callbacks && (_bitset_)->callbacks->create)
@@ -93,8 +93,8 @@ _Bool bs_set_range(struct bitset *_bitset_, size_t from, size_t to)
}
if (!bs_impl_resize(_bitset_, to + 1, 0))
return 0;
size_t start_index = bs_bit_to_index(from);
size_t end_index = bs_bit_to_index(to);
size_t start_index = cmc_bidx_to_widx(from);
size_t end_index = cmc_bidx_to_widx(to);
const cmc_bitset_word bits = sizeof(cmc_bitset_word) * 8;
const cmc_bitset_word ones = ~((cmc_bitset_word)0);
cmc_bitset_word shift_start = from % bits;
@@ -123,7 +123,7 @@ _Bool bs_clear(struct bitset *_bitset_, size_t bit_index)
if (!bs_impl_resize(_bitset_, bit_index + 1, 0))
return 0;
const cmc_bitset_word bits = sizeof(cmc_bitset_word) * 8;
size_t i = bs_bit_to_index(bit_index);
size_t i = cmc_bidx_to_widx(bit_index);
_bitset_->buffer[i] &= ~(((cmc_bitset_word)1) << (bit_index % bits));
_bitset_->flag = CMC_FLAG_OK;
if ((_bitset_)->callbacks && (_bitset_)->callbacks->delete)
@@ -140,8 +140,8 @@ _Bool bs_clear_range(struct bitset *_bitset_, size_t from, size_t to)
}
if (!bs_impl_resize(_bitset_, to + 1, 0))
return 0;
size_t start_index = bs_bit_to_index(from);
size_t end_index = bs_bit_to_index(to);
size_t start_index = cmc_bidx_to_widx(from);
size_t end_index = cmc_bidx_to_widx(to);
const cmc_bitset_word bits = sizeof(cmc_bitset_word) * 8;
const cmc_bitset_word ones = ~((cmc_bitset_word)0);
cmc_bitset_word shift_start = from % bits;
@@ -170,7 +170,7 @@ _Bool bs_flip(struct bitset *_bitset_, size_t bit_index)
if (!bs_impl_resize(_bitset_, bit_index + 1, 0))
return 0;
const cmc_bitset_word bits = sizeof(cmc_bitset_word) * 8;
size_t i = bs_bit_to_index(bit_index);
size_t i = cmc_bidx_to_widx(bit_index);
_bitset_->buffer[i] ^= ((cmc_bitset_word)1) << (bit_index % bits);
_bitset_->flag = CMC_FLAG_OK;
if ((_bitset_)->callbacks && (_bitset_)->callbacks->update)
@@ -187,8 +187,8 @@ _Bool bs_flip_range(struct bitset *_bitset_, size_t from, size_t to)
}
if (!bs_impl_resize(_bitset_, to + 1, 0))
return 0;
size_t start_index = bs_bit_to_index(from);
size_t end_index = bs_bit_to_index(to);
size_t start_index = cmc_bidx_to_widx(from);
size_t end_index = cmc_bidx_to_widx(to);
const cmc_bitset_word bits = sizeof(cmc_bitset_word) * 8;
const cmc_bitset_word ones = ~((cmc_bitset_word)0);
cmc_bitset_word shift_start = from % bits;
@@ -259,7 +259,7 @@ _Bool bs_flip_all(struct bitset *_bitset_)
_Bool bs_get(struct bitset *_bitset_, size_t bit_index)
{
const cmc_bitset_word bits = sizeof(cmc_bitset_word) * 8;
cmc_bitset_word w = _bitset_->buffer[bs_bit_to_index(bit_index)];
cmc_bitset_word w = _bitset_->buffer[cmc_bidx_to_widx(bit_index)];
return w & ((cmc_bitset_word)1 << (bit_index % bits));
}
_Bool bs_resize(struct bitset *_bitset_, size_t n_bits)
@@ -273,7 +273,7 @@ _Bool bs_impl_resize(struct bitset *_bitset_, size_t n_bits, _Bool do_resize)
_bitset_->flag = CMC_FLAG_INVALID;
return 0;
}
size_t words = bs_bit_to_index(n_bits - 1) + 1;
size_t words = cmc_bidx_to_widx(n_bits - 1) + 1;
if (!do_resize && words <= _bitset_->capacity)
return 1;
cmc_bitset_word *new_buffer = realloc(_bitset_->buffer, words * sizeof(cmc_bitset_word));
tests/unt/cmc/bitset.h
+15 -15
View File
@@ -20,7 +20,7 @@ CMC_CREATE_UNIT(CMCBitSet, true, {
cmc_assert_not_equals(ptr, NULL, bs);
cmc_assert_not_equals(ptr, NULL, bs->buffer);
cmc_assert_equals(size_t, bs_bit_to_index(63) + 1, bs->capacity);
cmc_assert_equals(size_t, cmc_bidx_to_widx(63) + 1, bs->capacity);
cmc_assert_equals(ptr, cmc_alloc_node_default.malloc, bs->alloc->malloc);
cmc_assert_equals(ptr, cmc_alloc_node_default.calloc, bs->alloc->calloc);
cmc_assert_equals(ptr, cmc_alloc_node_default.realloc, bs->alloc->realloc);
@@ -31,7 +31,7 @@ CMC_CREATE_UNIT(CMCBitSet, true, {
bs = bs_new(129);
cmc_assert_equals(size_t, bs_bit_to_index(128) + 1, bs->capacity);
cmc_assert_equals(size_t, cmc_bidx_to_widx(128) + 1, bs->capacity);
bs_free(bs);
@@ -45,7 +45,7 @@ CMC_CREATE_UNIT(CMCBitSet, true, {
cmc_assert_not_equals(ptr, NULL, bs);
cmc_assert_not_equals(ptr, NULL, bs->buffer);
cmc_assert_equals(size_t, bs_bit_to_index(63) + 1, bs->capacity);
cmc_assert_equals(size_t, cmc_bidx_to_widx(63) + 1, bs->capacity);
cmc_assert_equals(ptr, bs_alloc_node, bs->alloc);
cmc_assert_equals(ptr, callbacks, bs->callbacks);
@@ -53,7 +53,7 @@ CMC_CREATE_UNIT(CMCBitSet, true, {
bs = bs_new_custom(129, NULL, NULL);
cmc_assert_equals(size_t, bs_bit_to_index(128) + 1, bs->capacity);
cmc_assert_equals(size_t, cmc_bidx_to_widx(128) + 1, bs->capacity);
bs_free(bs);
bs = bs_new_custom(0, bs_alloc_node, callbacks);
@@ -65,7 +65,7 @@ CMC_CREATE_UNIT(CMCBitSet, true, {
struct bitset bs = bs_init(64);
cmc_assert_not_equals(ptr, NULL, bs.buffer);
cmc_assert_equals(size_t, bs_bit_to_index(63) + 1, bs.capacity);
cmc_assert_equals(size_t, cmc_bidx_to_widx(63) + 1, bs.capacity);
cmc_assert_equals(ptr, cmc_alloc_node_default.malloc, bs.alloc->malloc);
cmc_assert_equals(ptr, cmc_alloc_node_default.calloc, bs.alloc->calloc);
cmc_assert_equals(ptr, cmc_alloc_node_default.realloc, bs.alloc->realloc);
@@ -76,7 +76,7 @@ CMC_CREATE_UNIT(CMCBitSet, true, {
bs = bs_init(129);
cmc_assert_equals(size_t, bs_bit_to_index(128) + 1, bs.capacity);
cmc_assert_equals(size_t, cmc_bidx_to_widx(128) + 1, bs.capacity);
bs_release(bs);
@@ -89,7 +89,7 @@ CMC_CREATE_UNIT(CMCBitSet, true, {
struct bitset bs = bs_init_custom(64, bs_alloc_node, callbacks);
cmc_assert_not_equals(ptr, NULL, bs.buffer);
cmc_assert_equals(size_t, bs_bit_to_index(63) + 1, bs.capacity);
cmc_assert_equals(size_t, cmc_bidx_to_widx(63) + 1, bs.capacity);
cmc_assert_equals(ptr, bs_alloc_node, bs.alloc);
cmc_assert_equals(ptr, callbacks, bs.callbacks);
@@ -97,7 +97,7 @@ CMC_CREATE_UNIT(CMCBitSet, true, {
bs = bs_init_custom(129, NULL, NULL);
cmc_assert_equals(size_t, bs_bit_to_index(128) + 1, bs.capacity);
cmc_assert_equals(size_t, cmc_bidx_to_widx(128) + 1, bs.capacity);
bs_release(bs);
@@ -149,11 +149,11 @@ CMC_CREATE_UNIT(CMCBitSet, true, {
cmc_assert(bs_set(bs, word_bits * 8 - 1));
cmc_assert_equals(CMC_BITSET_WORD_TYPE, ((cmc_bitset_word)1 << (word_bits - 1)),
bs->buffer[bs_bit_to_index(word_bits * 8 - 1)]);
bs->buffer[cmc_bidx_to_widx(word_bits * 8 - 1)]);
cmc_assert(bs_set(bs, word_bits * 18 - 2));
cmc_assert_equals(CMC_BITSET_WORD_TYPE, ((cmc_bitset_word)1 << (word_bits - 2)),
bs->buffer[bs_bit_to_index(word_bits * 18 - 2)]);
bs->buffer[cmc_bidx_to_widx(word_bits * 18 - 2)]);
bs_free(bs);
});
@@ -182,16 +182,16 @@ CMC_CREATE_UNIT(CMCBitSet, true, {
cmc_assert(bs_set_range(bs, word_bits * 6 - 2, word_bits * 6 - 2));
cmc_assert_equals(CMC_BITSET_WORD_TYPE, ((cmc_bitset_word)1 << (word_bits - 2)),
bs->buffer[bs_bit_to_index(word_bits * 6 - 2)]);
bs->buffer[cmc_bidx_to_widx(word_bits * 6 - 2)]);
// Make sure we have at least word_bits * 40 slots
bs_set(bs, word_bits * 40);
cmc_assert(bs_set_range(bs, word_bits * 20, word_bits * 21 - 1));
cmc_assert_equals(CMC_BITSET_WORD_TYPE, (~(cmc_bitset_word)0), bs->buffer[bs_bit_to_index(word_bits * 20)]);
cmc_assert_equals(CMC_BITSET_WORD_TYPE, (~(cmc_bitset_word)0), bs->buffer[cmc_bidx_to_widx(word_bits * 20)]);
cmc_assert_equals(CMC_BITSET_WORD_TYPE, 0, bs->buffer[bs_bit_to_index(word_bits * 20 - 1)]);
cmc_assert_equals(CMC_BITSET_WORD_TYPE, 0, bs->buffer[bs_bit_to_index(word_bits * 21 + 1)]);
cmc_assert_equals(CMC_BITSET_WORD_TYPE, 0, bs->buffer[cmc_bidx_to_widx(word_bits * 20 - 1)]);
cmc_assert_equals(CMC_BITSET_WORD_TYPE, 0, bs->buffer[cmc_bidx_to_widx(word_bits * 21 + 1)]);
cmc_assert(bs_set_range(bs, 0, word_bits * 100 - 1));
cmc_assert_equals(size_t, 100, bs->capacity);
@@ -238,7 +238,7 @@ CMC_CREATE_UNIT(CMCBitSet, true, {
cmc_assert(bs_set_range(bs, word_bits * 20, word_bits * 21 - 1));
cmc_assert(bs_clear_range(bs, word_bits * 20, word_bits * 21 - 1));
cmc_assert_equals(uint32_t, 0, bs->buffer[bs_bit_to_index(word_bits * 20)]);
cmc_assert_equals(uint32_t, 0, bs->buffer[cmc_bidx_to_widx(word_bits * 20)]);
for (size_t i = 0; i < bs->capacity; i++)
bs->buffer[i] = ~((cmc_bitset_word)0);