diff --git a/m-bitset.h b/m-bitset.h index 01097ead..3df06609 100644 --- a/m-bitset.h +++ b/m-bitset.h @@ -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)<> (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); diff --git a/m-bptree.h b/m-bptree.h index 80e45054..3c7c24e9 100644 --- a/m-bptree.h +++ b/m-bptree.h @@ -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 --; \ } \ \ diff --git a/m-c-mempool.h b/m-c-mempool.h index aa4b1614..64578ce0 100644 --- a/m-c-mempool.h +++ b/m-c-mempool.h @@ -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); diff --git a/m-dict.h b/m-dict.h index ee5e88f1..98043538 100644 --- a/m-dict.h +++ b/m-dict.h @@ -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 --; \ } \ diff --git a/m-mutex.h b/m-mutex.h index 2b5d6b64..de51e556 100644 --- a/m-mutex.h +++ b/m-mutex.h @@ -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; } diff --git a/m-snapshot.h b/m-snapshot.h index 56b51562..f73fe19a 100644 --- a/m-snapshot.h +++ b/m-snapshot.h @@ -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. */ diff --git a/m-worker.h b/m-worker.h index 8a648aaf..36476238 100644 --- a/m-worker.h +++ b/m-worker.h @@ -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;