admin/mlib
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix -Wsign-conversion warnings.

Browse Source
This commit is contained in:
Patrick Pelissier committed 2020-06-13 19:43:38 +02:00
1 parent 17950c5fe5
commit 279b46b4e2
7 files changed
+46 -45
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

m-bitset.h
+1 -1
View File
@@ -417,7 +417,7 @@ bitset_push_at(bitset_t set, size_t key, bool value)
bitset_limb v = set->ptr[offset];
bitset_limb mask = (((bitset_limb)1)<<index)-1;
bitset_limb carry = (v >> (BITSET_LIMB_BIT-1) );
v = (v & mask) | (value << index) | ((v & ~mask) << 1);
v = (v & mask) | ((unsigned int) value << index) | ((v & ~mask) << 1);
set->ptr[offset] = v;
size_t size = (set->size + BITSET_LIMB_BIT - 1) / BITSET_LIMB_BIT;
assert (size >= offset + 1);
m-bptree.h
+23 -23
View File
@@ -561,8 +561,8 @@
} \
) \
/* Move tables to make space for insertion */ \
memmove(&n->key[i+1], &n->key[i], sizeof(key_t)*(num-i)); \
M_IF(isMap)(memmove(&n->kind.value[i+1], &n->kind.value[i], sizeof(value_t)*(num-i));,) \
memmove(&n->key[i+1], &n->key[i], sizeof(key_t)*(unsigned int)(num-i)); \
M_IF(isMap)(memmove(&n->kind.value[i+1], &n->kind.value[i], sizeof(value_t)*(unsigned int)(num-i));,) \
break; \
} \
} \
@@ -584,8 +584,8 @@
for(i = 0; i < num; i++) { \
if (n->kind.node[i] == l) { \
/* Move tables to make space for insertion */ \
memmove(&n->key[i+1], &n->key[i], sizeof(key_t)*(num-i)); \
memmove(&n->kind.node[i+1], &n->kind.node[i], sizeof(node_t)*(num-i+1)); \
memmove(&n->key[i+1], &n->key[i], sizeof(key_t)*(unsigned int)(num-i)); \
memmove(&n->kind.node[i+1], &n->kind.node[i], sizeof(node_t)*(unsigned int)(num-i+1)); \
break; \
} \
} \
@@ -630,8 +630,8 @@
num = N + 1 - nnum; \
node_t nleaf = M_C(name, _new_node)(); \
/* Move half objects to the new node */ \
memmove(&nleaf->key[0], &leaf->key[num], sizeof(key_t)*nnum); \
M_IF(isMap)(memmove(&nleaf->kind.value[0], &leaf->kind.value[num], sizeof(value_t)*nnum);,) \
memmove(&nleaf->key[0], &leaf->key[num], sizeof(key_t)*(unsigned int)nnum); \
M_IF(isMap)(memmove(&nleaf->kind.value[0], &leaf->kind.value[num], sizeof(value_t)*(unsigned int)nnum);,) \
leaf->num = -num; \
nleaf->num = -nnum; \
nleaf->next = leaf->next; \
@@ -672,8 +672,8 @@
node_t nparent = M_C(name, _new_node)(); \
/* Move half items to new node (Like a classic B-TREE) \
and the median key to the grand-parent*/ \
memmove(&nparent->key[0], &parent->key[np+1], sizeof(key_t)*nnp); \
memmove(&nparent->kind.node[0], &parent->kind.node[np+1], sizeof(node_t)*(nnp+1)); \
memmove(&nparent->key[0], &parent->key[np+1], sizeof(key_t)*(unsigned int)nnp); \
memmove(&nparent->kind.node[0], &parent->kind.node[np+1], sizeof(node_t)*(unsigned int)(nnp+1)); \
parent->num = np; \
nparent->num = nnp; \
nparent->next = parent->next; \
@@ -698,8 +698,8 @@
/* found key ==> delete it */ \
M_CALL_CLEAR(key_oplist, n->key[i]); \
M_IF(isMap)(M_CALL_CLEAR(value_oplist, n->kind.value[i]);,) \
memmove(&n->key[i], &n->key[i+1], sizeof(key_t)*(num-1-i)); \
M_IF(isMap)(memmove(&n->kind.value[i], &n->kind.value[i+1], sizeof(value_t)*(num-1-i));,) \
memmove(&n->key[i], &n->key[i+1], sizeof(key_t)*(unsigned int)(num-1-i)); \
M_IF(isMap)(memmove(&n->kind.value[i], &n->kind.value[i+1], sizeof(value_t)*(unsigned int)(num-1-i));,) \
n->num -= -1; /* decrease number as num is < 0 */ \
return i; \
} \
@@ -720,16 +720,16 @@
assert (num_right < N/2); \
\
/* Move one item from the left node to the right node */ \
memmove(&right->key[1], &right->key[0], sizeof(key_t)*num_right); \
memmove(&right->key[1], &right->key[0], sizeof(key_t)*(unsigned int)num_right); \
if (M_C(name, _is_leaf)(left)) { \
M_IF(isMap)(memmove (&right->kind.value[1], &right->kind.value[0], sizeof(value_t)*num_right);,) \
M_IF(isMap)(memmove (&right->kind.value[1], &right->kind.value[0], sizeof(value_t)*(unsigned int)num_right);,) \
memmove (&right->key[0], &left->key[num_left-1], sizeof (key_t)); \
M_IF(isMap)(memmove (&right->kind.value[0], &left->kind.value[num_left-1], sizeof (value_t));,) \
right->num = -num_right - 1; \
left->num = -num_left + 1; \
M_CALL_SET(key_oplist, parent->key[k], left->key[num_left-2]); \
} else { \
memmove(&right->kind.node[1], &right->kind.node[0], sizeof(node_t)*(num_right+1)); \
memmove(&right->kind.node[1], &right->kind.node[0], sizeof(node_t)*(unsigned int)(num_right+1)); \
/* parent[k] is moved to right[0] (clear). parent[k] is therefore clear */ \
memmove(&right->key[0], &parent->key[k], sizeof(key_t)); \
right->kind.node[0] = left->kind.node[num_left]; \
@@ -757,18 +757,18 @@
/* Move one item from the right node to the left node. */ \
if (M_C(name, _is_leaf)(right)) { \
memmove (&left->key[num_left], &right->key[0], sizeof(key_t)); \
memmove (&right->key[0], &right->key[1], sizeof(key_t)*(num_right-1)); \
memmove (&right->key[0], &right->key[1], sizeof(key_t)*(unsigned int)(num_right-1)); \
M_IF(isMap)(memmove (&left->kind.value[num_left], &right->kind.value[0], sizeof (value_t));,) \
M_IF(isMap)(memmove (&right->kind.value[0], &right->kind.value[1], sizeof(value_t)*(num_right-1));,) \
M_IF(isMap)(memmove (&right->kind.value[0], &right->kind.value[1], sizeof(value_t)*(unsigned int)(num_right-1));,) \
right->num = -num_right + 1; \
left->num = -num_left - 1; \
M_CALL_SET(key_oplist, parent->key[k], left->key[num_left]); \
} else { \
memmove (&left->key[num_left], &parent->key[k], sizeof (key_t)); \
memmove (&parent->key[k], &right->key[0], sizeof (key_t)); \
memmove (&right->key[0], &right->key[1], sizeof(key_t)*(num_right-1)); \
memmove (&right->key[0], &right->key[1], sizeof(key_t)*(unsigned int)(num_right-1)); \
left->kind.node[num_left+1] = right->kind.node[0]; \
memmove (&right->kind.node[0], &right->kind.node[1], sizeof(node_t)*num_right); \
memmove (&right->kind.node[0], &right->kind.node[1], sizeof(node_t)*(unsigned int)num_right); \
right->num = num_right - 1; \
left->num = num_left + 1; \
} \
@@ -790,13 +790,13 @@
/* Merge node 'k' and 'k+1' into a single one */ \
if (leaf) { \
assert (num_left + num_right <= N); \
memmove(&left->key[num_left], &right->key[0], sizeof(key_t)*num_right); \
M_IF(isMap)(memmove(&left->kind.value[num_left], &right->kind.value[0], sizeof(value_t)*num_right);,) \
memmove(&left->key[num_left], &right->key[0], sizeof(key_t)*(unsigned int)num_right); \
M_IF(isMap)(memmove(&left->kind.value[num_left], &right->kind.value[0], sizeof(value_t)*(unsigned int)num_right);,) \
left->num = -num_left - num_right; \
} else { \
assert (num_left + num_right <= N -1); \
memmove(&left->key[num_left+1], &right->key[0], sizeof(key_t)*num_right); \
memmove(&left->kind.node[num_left+1], &right->kind.node[0], sizeof(node_t)*(num_right+1)); \
memmove(&left->key[num_left+1], &right->key[0], sizeof(key_t)*(unsigned int)num_right); \
memmove(&left->kind.node[num_left+1], &right->kind.node[0], sizeof(node_t)*(unsigned int)(num_right+1)); \
M_CALL_INIT_SET(key_oplist, left->key[num_left], parent->key[k]); \
left->num = num_left + 1 + num_right; \
} \
@@ -804,8 +804,8 @@
M_CALL_DEL(key_oplist, right); \
/* remove k'th key from the parent */ \
M_CALL_CLEAR(key_oplist, parent->key[k]); \
memmove(&parent->key[k], &parent->key[k+1], sizeof(key_t)*(num_parent - k - 1)); \
memmove(&parent->kind.node[k+1], &parent->kind.node[k+2], sizeof(node_t)*(num_parent - k -1)); \
memmove(&parent->key[k], &parent->key[k+1], sizeof(key_t)*(unsigned int)(num_parent - k - 1)); \
memmove(&parent->kind.node[k+1], &parent->kind.node[k+2], sizeof(node_t)*(unsigned int)(num_parent - k -1)); \
parent->num --; \
} \
\
m-c-mempool.h
+5 -5
View File
@@ -542,7 +542,7 @@
/***********************************************************************/
/* Define the ID of a thread */
typedef int m_gc_tid_t;
typedef unsigned int m_gc_tid_t;
/* Define the age of a node */
/* TODO: Compute if sufficient (worst cast ULONG_MAX is 32 bits) */
@@ -622,7 +622,7 @@ static inline void
m_gc_detach_thread(m_gc_t gc_mem, m_gc_tid_t id)
{
assert(gc_mem != NULL && gc_mem->max_thread > 0);
assert(id >= 0 && id < gc_mem->max_thread);
assert(id < gc_mem->max_thread);
assert(atomic_load(&gc_mem->thread_data[id].ticket) == ULONG_MAX);
genint_push(gc_mem->thread_alloc, id);
@@ -632,7 +632,7 @@ static inline void
m_gc_awake(m_gc_t gc_mem, m_gc_tid_t id)
{
assert(gc_mem != NULL && gc_mem->max_thread > 0);
assert(id >= 0 && id < gc_mem->max_thread);
assert(id < gc_mem->max_thread);
assert(atomic_load(&gc_mem->thread_data[id].ticket) == ULONG_MAX);
m_gc_ticket_t t = atomic_fetch_add(&gc_mem->ticket, 1UL) + 1;
@@ -792,7 +792,7 @@ static inline void *
m_vlapool_new(m_vlapool_t mem, m_gc_tid_t id, size_t size)
{
assert(mem != NULL && mem->gc_mem != NULL);
assert(id >= 0 && id < mem->gc_mem->max_thread);
assert(id < mem->gc_mem->max_thread);
assert( atomic_load(&mem->gc_mem->thread_data[id].ticket) != ULONG_MAX);
// Nothing to do with theses parameters yet
@@ -811,7 +811,7 @@ static inline void
m_vlapool_del(m_vlapool_t mem, void *d, m_gc_tid_t id)
{
assert(mem != NULL && mem->gc_mem != NULL);
assert(id >= 0 && id < mem->gc_mem->max_thread);
assert(id < mem->gc_mem->max_thread);
assert(atomic_load(&mem->gc_mem->thread_data[id].ticket) != ULONG_MAX);
assert(d != NULL);
m-dict.h
+6 -6
View File
@@ -1392,9 +1392,9 @@ typedef enum {
return; \
} \
if (M_UNLIKELY (!M_CALL_OOR_EQUAL(key_oplist, data[p].key, DICTI_OA_EMPTY) ) ) { \
size_t delPos = -1; \
size_t delPos = -1U; \
if (M_CALL_OOR_EQUAL(key_oplist, data[p].key, DICTI_OA_DELETED)) delPos = p; \
size_t s = 1; \
size_t s = 1U; \
do { \
p = (p + DICTI_OA_PROBING(s)) & mask; \
if (M_CALL_EQUAL(key_oplist, data[p].key, key)) { \
@@ -1404,7 +1404,7 @@ typedef enum {
assert (s <= dict->mask); \
if (M_CALL_OOR_EQUAL(key_oplist, data[p].key, DICTI_OA_DELETED) && delPos == (size_t)-1) delPos = p; \
} while (!M_CALL_OOR_EQUAL(key_oplist, data[p].key, DICTI_OA_EMPTY) ); \
if (delPos != (size_t) -1) { \
if (delPos != (size_t) -1U) { \
p = delPos; \
dict->count_delete --; \
} \
@@ -1444,9 +1444,9 @@ typedef enum {
return &data[p].M_IF(isSet)(key, value); \
} \
if (M_UNLIKELY (!M_CALL_OOR_EQUAL(key_oplist, data[p].key, DICTI_OA_EMPTY) ) ) { \
size_t delPos = -1; \
size_t delPos = -1U; \
if (M_CALL_OOR_EQUAL(key_oplist, data[p].key, DICTI_OA_DELETED)) delPos = p; \
size_t s = 1; \
size_t s = 1U; \
do { \
p = (p + DICTI_OA_PROBING(s)) & mask; \
if (M_CALL_EQUAL(key_oplist, data[p].key, key)) { \
@@ -1455,7 +1455,7 @@ typedef enum {
assert (s <= dict->mask); \
if (M_CALL_OOR_EQUAL(key_oplist, data[p].key, DICTI_OA_DELETED) && delPos == (size_t)-1) delPos = p; \
} while (!M_CALL_OOR_EQUAL(key_oplist, data[p].key, DICTI_OA_EMPTY) ); \
if (delPos != (size_t) -1) { \
if (delPos != (size_t) -1U) { \
p = delPos; \
dict->count_delete --; \
} \
m-mutex.h
+4 -4
View File
@@ -133,8 +133,8 @@ static inline void m_thread_yield(void)
static inline bool m_thread_sleep(unsigned long long usec)
{
struct timespec tv;
tv.tv_sec = usec / 1000000ULL;
tv.tv_nsec = (usec % 1000000ULL) * 1000UL;
tv.tv_sec = (long) (usec / 1000000ULL);
tv.tv_nsec = (long) ((usec % 1000000ULL) * 1000UL);
int retval = thrd_sleep(&tv, NULL);
return retval == 0;
}
@@ -422,8 +422,8 @@ static inline bool m_thread_sleep(unsigned long long usec)
struct timeval tv;
/* We don't want to use usleep or nanosleep so that
we remain compatible with strict C99 build */
tv.tv_sec = usec / 1000000ULL;
tv.tv_usec = usec % 1000000ULL;
tv.tv_sec = (long) (usec / 1000000ULL);
tv.tv_usec = (long) (usec % 1000000ULL);
int retval = select(1, NULL, NULL, NULL, &tv);
return retval == 0;
}
m-snapshot.h
+4 -4
View File
@@ -100,13 +100,13 @@
#define SNAPSHOTI_SPSC_FLAG(r, w, f, b) \
((unsigned char)( ( (r) << 4) | ((w) << 2) | ((f)) | ((b) << 6)))
#define SNAPSHOTI_SPSC_R(flags) \
(((flags) >> 4) & 0x03u)
(((unsigned int) (flags) >> 4) & 0x03u)
#define SNAPSHOTI_SPSC_W(flags) \
(((flags) >> 2) & 0x03u)
(((unsigned int) (flags) >> 2) & 0x03u)
#define SNAPSHOTI_SPSC_F(flags) \
(((flags) >> 0) & 0x03u)
(((unsigned int) (flags) >> 0) & 0x03u)
#define SNAPSHOTI_SPSC_B(flags) \
(((flags) >> 6) & 0x01u)
(((unsigned int) (flags) >> 6) & 0x01u)
/* NOTE: Due to atomic_load only accepting non-const pointer,
we can't have any const in the interface. */
m-worker.h
+3 -2
View File
@@ -277,13 +277,14 @@ worker_init(worker_t g, int numWorker, unsigned int extraQueue, void (*resetFunc
numWorker = (1 + (numWorker == -1))*workeri_get_cpu_count()-1;
WORKERI_DEBUG ("Starting queue with: %d\n", numWorker + extraQueue);
// Initialization
size_t numWorker_st = numWorker;
assert(numWorker > 0);
size_t numWorker_st = (size_t) numWorker;
g->worker = M_MEMORY_REALLOC(worker_thread_t, NULL, numWorker_st);
if (g->worker == NULL) {
M_MEMORY_FULL(sizeof (worker_thread_t) * numWorker_st);
return;
}
worker_queue_init(g->queue_g, numWorker + extraQueue);
worker_queue_init(g->queue_g, numWorker_st + extraQueue);
g->numWorker_g = numWorker_st;
g->resetFunc_g = resetFunc;
g->clearFunc_g = clearFunc;