[tarantool-patches] Re: [PATCH v1 1/1] lib/bitset: rename bitset structs
- From: Kirill Shcherbatov <kshcherbatov@xxxxxxxxxxxxx>
- To: tarantool-patches@xxxxxxxxxxxxx
- Date: Tue, 3 Jul 2018 16:24:36 +0300
I don't think you should rename any structures or functions defined in
memtx_bitset.c - they don't conflict and they are not related to struct
bitset.
Changes in memtx_bitset.{c, h} with my patch now.
========================================
diff --git a/src/box/memtx_bitset.c b/src/box/memtx_bitset.c
index 9216ed8..75406f9 100644
--- a/src/box/memtx_bitset.c
+++ b/src/box/memtx_bitset.c
@@ -154,7 +154,7 @@ value_to_tuple(size_t value)
struct bitset_index_iterator {
struct iterator base; /* Must be the first member. */
- struct bitset_iterator bitset_it;
+ struct tt_bitset_iterator bitset_it;
#ifndef OLD_GOOD_BITSET
struct memtx_bitset_index *bitset_index;
#endif /* #ifndef OLD_GOOD_BITSET */
@@ -174,7 +174,7 @@ bitset_index_iterator_free(struct iterator *iterator)
assert(iterator->free == bitset_index_iterator_free);
struct bitset_index_iterator *it = bitset_index_iterator(iterator);
- bitset_iterator_destroy(&it->bitset_it);
+ tt_bitset_iterator_destroy(&it->bitset_it);
mempool_free(it->pool, it);
}
@@ -184,7 +184,7 @@ bitset_index_iterator_next(struct iterator *iterator,
struct tuple **ret)
assert(iterator->free == bitset_index_iterator_free);
struct bitset_index_iterator *it = bitset_index_iterator(iterator);
- size_t value = bitset_iterator_next(&it->bitset_it);
+ size_t value = tt_bitset_iterator_next(&it->bitset_it);
if (value == SIZE_MAX) {
*ret = NULL;
return 0;
@@ -202,7 +202,7 @@ static void
memtx_bitset_index_destroy(struct index *base)
{
struct memtx_bitset_index *index = (struct memtx_bitset_index *)base;
- bitset_index_destroy(&index->index);
+ tt_bitset_index_destroy(&index->index);
#ifndef OLD_GOOD_BITSET
mh_bitset_index_delete(index->tuple_to_id);
matras_destroy(index->id_to_tuple);
@@ -215,7 +215,7 @@ static ssize_t
memtx_bitset_index_size(struct index *base)
{
struct memtx_bitset_index *index = (struct memtx_bitset_index *)base;
- return bitset_index_size(&index->index);
+ return tt_bitset_index_size(&index->index);
}
static ssize_t
@@ -223,7 +223,7 @@ memtx_bitset_index_bsize(struct index *base)
{
struct memtx_bitset_index *index = (struct memtx_bitset_index *)base;
size_t result = 0;
- result += bitset_index_bsize(&index->index);
+ result += tt_bitset_index_bsize(&index->index);
#ifndef OLD_GOOD_BITSET
result += matras_extent_count(index->id_to_tuple) * MEMTX_EXTENT_SIZE;
result += mh_bitset_index_memsize(index->tuple_to_id);
@@ -270,11 +270,12 @@ memtx_bitset_index_replace(struct index *base, struct
tuple *old_tuple,
#else /* #ifndef OLD_GOOD_BITSET */
size_t value = tuple_to_value(old_tuple);
#endif /* #ifndef OLD_GOOD_BITSET */
- if (bitset_index_contains_value(&index->index, (size_t)value)) {
+ if (tt_bitset_index_contains_value(&index->index,
+ (size_t) value)) {
*result = old_tuple;
assert(old_tuple != new_tuple);
- bitset_index_remove_value(&index->index, value);
+ tt_bitset_index_remove_value(&index->index, value);
#ifndef OLD_GOOD_BITSET
memtx_bitset_index_unregister_tuple(index, old_tuple);
#endif /* #ifndef OLD_GOOD_BITSET */
@@ -293,7 +294,8 @@ memtx_bitset_index_replace(struct index *base, struct tuple
*old_tuple,
#else /* #ifndef OLD_GOOD_BITSET */
uint32_t value = tuple_to_value(new_tuple);
#endif /* #ifndef OLD_GOOD_BITSET */
- if (bitset_index_insert(&index->index, key, key_len, value) <
0) {
+ if (tt_bitset_index_insert(&index->index, key, key_len,
+ value) < 0) {
#ifndef OLD_GOOD_BITSET
memtx_bitset_index_unregister_tuple(index, new_tuple);
#endif /* #ifndef OLD_GOOD_BITSET */
@@ -327,7 +329,7 @@ memtx_bitset_index_create_iterator(struct index *base, enum
iterator_type type,
it->base.next = bitset_index_iterator_next;
it->base.free = bitset_index_iterator_free;
- bitset_iterator_create(&it->bitset_it, realloc);
+ tt_bitset_iterator_create(&it->bitset_it, realloc);
#ifndef OLD_GOOD_BITSET
it->bitset_index = index;
#endif
@@ -339,29 +341,29 @@ memtx_bitset_index_create_iterator(struct index *base,
enum iterator_type type,
bitset_key = make_key(key, &bitset_key_size);
}
- struct bitset_expr expr;
- bitset_expr_create(&expr, realloc);
+ struct tt_bitset_expr expr;
+ tt_bitset_expr_create(&expr, realloc);
int rc = 0;
switch (type) {
case ITER_ALL:
- rc = bitset_index_expr_all(&expr);
+ rc = tt_bitset_index_expr_all(&expr);
break;
case ITER_EQ:
- rc = bitset_index_expr_equals(&expr, bitset_key,
- bitset_key_size);
+ rc = tt_bitset_index_expr_equals(&expr, bitset_key,
+ bitset_key_size);
break;
case ITER_BITS_ALL_SET:
- rc = bitset_index_expr_all_set(&expr, bitset_key,
- bitset_key_size);
+ rc = tt_bitset_index_expr_all_set(&expr, bitset_key,
+ bitset_key_size);
break;
case ITER_BITS_ALL_NOT_SET:
- rc = bitset_index_expr_all_not_set(&expr, bitset_key,
- bitset_key_size);
+ rc = tt_bitset_index_expr_all_not_set(&expr, bitset_key,
+ bitset_key_size);
break;
case ITER_BITS_ANY_SET:
- rc = bitset_index_expr_any_set(&expr, bitset_key,
- bitset_key_size);
+ rc = tt_bitset_index_expr_any_set(&expr, bitset_key,
+ bitset_key_size);
break;
default:
diag_set(UnsupportedIndexFeature, base->def,
@@ -375,17 +377,17 @@ memtx_bitset_index_create_iterator(struct index *base,
enum iterator_type type,
goto fail;
}
- if (bitset_index_init_iterator(&index->index, &it->bitset_it,
- &expr) != 0) {
+ if (tt_bitset_index_init_iterator(&index->index, &it->bitset_it,
+ &expr) != 0) {
diag_set(OutOfMemory, 0, "memtx_bitset_index",
"iterator state");
goto fail;
}
- bitset_expr_destroy(&expr);
+ tt_bitset_expr_destroy(&expr);
return (struct iterator *)it;
fail:
- bitset_expr_destroy(&expr);
+ tt_bitset_expr_destroy(&expr);
mempool_free(&memtx->bitset_iterator_pool, it);
return NULL;
}
@@ -397,7 +399,7 @@ memtx_bitset_index_count(struct index *base, enum
iterator_type type,
struct memtx_bitset_index *index = (struct memtx_bitset_index *)base;
if (type == ITER_ALL)
- return bitset_index_size(&index->index);
+ return tt_bitset_index_size(&index->index);
assert(part_count == 1); /* checked by key_validate() */
uint32_t bitset_key_size = 0;
@@ -417,7 +419,7 @@ memtx_bitset_index_count(struct index *base, enum
iterator_type type,
* bitset_index_count().
*/
if (bit_iterator_next(&bit_it) == SIZE_MAX)
- return bitset_index_count(&index->index, bit);
+ return tt_bitset_index_count(&index->index, bit);
} else if (type == ITER_BITS_ALL_SET) {
/**
* Optimization: for an empty key return 0.
@@ -431,7 +433,7 @@ memtx_bitset_index_count(struct index *base, enum
iterator_type type,
* bitset_index_count().
*/
if (bit_iterator_next(&bit_it) == SIZE_MAX)
- return bitset_index_count(&index->index, bit);
+ return tt_bitset_index_count(&index->index, bit);
} else if (type == ITER_BITS_ALL_NOT_SET) {
/**
* Optimization: for an empty key return the number of items
@@ -440,14 +442,14 @@ memtx_bitset_index_count(struct index *base, enum
iterator_type type,
bit_iterator_init(&bit_it, bitset_key, bitset_key_size, true);
bit = bit_iterator_next(&bit_it);
if (bit == SIZE_MAX)
- return bitset_index_size(&index->index);
+ return tt_bitset_index_size(&index->index);
/**
* Optimiation: for the single bit key use
* bitset_index_count().
*/
if (bit_iterator_next(&bit_it) == SIZE_MAX)
- return bitset_index_size(&index->index) -
- bitset_index_count(&index->index, bit);
+ return tt_bitset_index_size(&index->index) -
+ tt_bitset_index_count(&index->index, bit);
}
/* Call generic method */
@@ -515,6 +517,6 @@ memtx_bitset_index_new(struct memtx_engine *memtx, struct
index_def *def)
panic("failed to allocate memtx bitset index");
#endif /* #ifndef OLD_GOOD_BITSET */
- bitset_index_create(&index->index, realloc);
+ tt_bitset_index_create(&index->index, realloc);
return index;
}
diff --git a/src/box/memtx_bitset.h b/src/box/memtx_bitset.h
index 0b8f48a..62971dd 100644
--- a/src/box/memtx_bitset.h
+++ b/src/box/memtx_bitset.h
@@ -51,7 +51,7 @@ struct mh_bitset_index_t;
struct memtx_bitset_index {
struct index base;
- struct bitset_index index;
+ struct tt_bitset_index index;
#ifndef OLD_GOOD_BITSET
struct matras *id_to_tuple;
struct mh_bitset_index_t *tuple_to_id;
diff --git a/src/lib/bitset/bitset.c b/src/lib/bitset/bitset.c
index ae2a033..f785adf 100644
--- a/src/lib/bitset/bitset.c
+++ b/src/lib/bitset/bitset.c
@@ -37,73 +37,78 @@
#include <assert.h>
void
-bitset_create(struct bitset *bitset, void *(*realloc)(void *ptr, size_t size))
+tt_bitset_create(struct tt_bitset *bitset,
+ void *(*realloc)(void *ptr, size_t size))
{
memset(bitset, 0, sizeof(*bitset));
bitset->realloc = realloc;
/* Initialize pages tree */
- bitset_pages_new(&bitset->pages);
+ tt_bitset_pages_new(&bitset->pages);
}
-static struct bitset_page *
-bitset_destroy_iter_cb(bitset_pages_t *t, struct bitset_page *page, void *arg)
+static struct tt_bitset_page *
+tt_bitset_destroy_iter_cb(tt_bitset_pages_t *t, struct tt_bitset_page *page,
+ void *arg)
{
(void) t;
- struct bitset *bitset = (struct bitset *) arg;
- bitset_page_destroy(page);
+ struct tt_bitset *bitset = (struct tt_bitset *) arg;
+ tt_bitset_page_destroy(page);
bitset->realloc(page, 0);
return NULL;
}
void
-bitset_destroy(struct bitset *bitset)
+tt_bitset_destroy(struct tt_bitset *bitset)
{
- bitset_pages_iter(&bitset->pages, NULL, bitset_destroy_iter_cb, bitset);
+ tt_bitset_pages_iter(&bitset->pages, NULL, tt_bitset_destroy_iter_cb,
+ bitset);
memset(&bitset->pages, 0, sizeof(bitset->pages));
}
bool
-bitset_test(struct bitset *bitset, size_t pos)
+tt_bitset_test(struct tt_bitset *bitset, size_t pos)
{
- struct bitset_page key;
- key.first_pos = bitset_page_first_pos(pos);
+ struct tt_bitset_page key;
+ key.first_pos = tt_bitset_page_first_pos(pos);
/* Find a page in pages tree */
- struct bitset_page *page = bitset_pages_search(&bitset->pages, &key);
+ struct tt_bitset_page *page =
+ tt_bitset_pages_search(&bitset->pages, &key);
if (page == NULL)
return false;
assert(page->first_pos <= pos && pos < page->first_pos +
BITSET_PAGE_DATA_SIZE * CHAR_BIT);
- return bit_test(bitset_page_data(page), pos - page->first_pos);
+ return bit_test(tt_bitset_page_data(page), pos - page->first_pos);
}
int
-bitset_set(struct bitset *bitset, size_t pos)
+tt_bitset_set(struct tt_bitset *bitset, size_t pos)
{
- struct bitset_page key;
- key.first_pos = bitset_page_first_pos(pos);
+ struct tt_bitset_page key;
+ key.first_pos = tt_bitset_page_first_pos(pos);
/* Find a page in pages tree */
- struct bitset_page *page = bitset_pages_search(&bitset->pages, &key);
+ struct tt_bitset_page *page =
+ tt_bitset_pages_search(&bitset->pages, &key);
if (page == NULL) {
/* Allocate a new page */
- size_t size = bitset_page_alloc_size(bitset->realloc);
+ size_t size = tt_bitset_page_alloc_size(bitset->realloc);
page = bitset->realloc(NULL, size);
if (page == NULL)
return -1;
- bitset_page_create(page);
+ tt_bitset_page_create(page);
page->first_pos = key.first_pos;
/* Insert the page into pages tree */
- bitset_pages_insert(&bitset->pages, page);
+ tt_bitset_pages_insert(&bitset->pages, page);
}
assert(page->first_pos <= pos && pos < page->first_pos +
BITSET_PAGE_DATA_SIZE * CHAR_BIT);
- bool prev = bit_set(bitset_page_data(page), pos - page->first_pos);
+ bool prev = bit_set(tt_bitset_page_data(page), pos - page->first_pos);
if (prev) {
/* Value has not changed */
return 1;
@@ -116,19 +121,20 @@ bitset_set(struct bitset *bitset, size_t pos)
}
int
-bitset_clear(struct bitset *bitset, size_t pos)
+tt_bitset_clear(struct tt_bitset *bitset, size_t pos)
{
- struct bitset_page key;
- key.first_pos = bitset_page_first_pos(pos);
+ struct tt_bitset_page key;
+ key.first_pos = tt_bitset_page_first_pos(pos);
/* Find a page in the pages tree */
- struct bitset_page *page = bitset_pages_search(&bitset->pages, &key);
+ struct tt_bitset_page *page =
+ tt_bitset_pages_search(&bitset->pages, &key);
if (page == NULL)
return 0;
assert(page->first_pos <= pos && pos < page->first_pos +
BITSET_PAGE_DATA_SIZE * CHAR_BIT);
- bool prev = bit_clear(bitset_page_data(page), pos - page->first_pos);
+ bool prev = bit_clear(tt_bitset_page_data(page), pos - page->first_pos);
if (!prev) {
return 0;
}
@@ -140,9 +146,9 @@ bitset_clear(struct bitset *bitset, size_t pos)
if (page->cardinality == 0) {
/* Remove the page from the pages tree */
- bitset_pages_remove(&bitset->pages, page);
+ tt_bitset_pages_remove(&bitset->pages, page);
/* Free the page */
- bitset_page_destroy(page);
+ tt_bitset_page_destroy(page);
bitset->realloc(page, 0);
}
@@ -150,33 +156,33 @@ bitset_clear(struct bitset *bitset, size_t pos)
}
extern inline size_t
-bitset_cardinality(const struct bitset *bitset);
+tt_bitset_cardinality(const struct tt_bitset *bitset);
void
-bitset_info(struct bitset *bitset, struct bitset_info *info)
+tt_bitset_info(struct tt_bitset *bitset, struct tt_bitset_info *info)
{
memset(info, 0, sizeof(*info));
info->page_data_size = BITSET_PAGE_DATA_SIZE;
- info->page_total_size = bitset_page_alloc_size(bitset->realloc);
+ info->page_total_size = tt_bitset_page_alloc_size(bitset->realloc);
info->page_data_alignment = BITSET_PAGE_DATA_ALIGNMENT;
size_t cardinality_check = 0;
- struct bitset_page *page = bitset_pages_first(&bitset->pages);
+ struct tt_bitset_page *page = tt_bitset_pages_first(&bitset->pages);
while (page != NULL) {
info->pages++;
cardinality_check += page->cardinality;
- page = bitset_pages_next(&bitset->pages, page);
+ page = tt_bitset_pages_next(&bitset->pages, page);
}
- assert(bitset_cardinality(bitset) == cardinality_check);
+ assert(tt_bitset_cardinality(bitset) == cardinality_check);
}
#if defined(DEBUG)
void
-bitset_dump(struct bitset *bitset, int verbose, FILE *stream)
+tt_bitset_dump(struct tt_bitset *bitset, int verbose, FILE *stream)
{
- struct bitset_info info;
- bitset_info(bitset, &info);
+ struct tt_bitset_info info;
+ tt_bitset_info(bitset, &info);
size_t PAGE_BIT = (info.page_data_size * CHAR_BIT);
@@ -225,8 +231,8 @@ bitset_dump(struct bitset *bitset, int verbose, FILE
*stream)
fprintf(stream, " " "pages = {\n");
- for (struct bitset_page *page = bitset_pages_first(&bitset->pages);
- page != NULL; page = bitset_pages_next(&bitset->pages, page)) {
+ for (struct tt_bitset_page *page =
tt_bitset_pages_first(&bitset->pages);
+ page != NULL; page = tt_bitset_pages_next(&bitset->pages, page)) {
size_t page_last_pos = page->first_pos
+ BITSET_PAGE_DATA_SIZE * CHAR_BIT;
Other related posts:
