diff --git a/blockingconcurrentqueue.h b/blockingconcurrentqueue.h index 205a4db7..d3f09f68 100644 --- a/blockingconcurrentqueue.h +++ b/blockingconcurrentqueue.h @@ -56,18 +56,18 @@ class BlockingConcurrentQueue // includes making the memory effects of construction visible, possibly with a // memory barrier). explicit BlockingConcurrentQueue(size_t capacity = 6 * BLOCK_SIZE) - : inner(capacity), sema(create(0, (int)Traits::MAX_SEMA_SPINS), &BlockingConcurrentQueue::template destroy) + : inner(capacity), sema(create(0, static_cast(Traits::MAX_SEMA_SPINS)), &BlockingConcurrentQueue::template destroy) { - assert(reinterpret_cast((BlockingConcurrentQueue*)1) == &((BlockingConcurrentQueue*)1)->inner && "BlockingConcurrentQueue must have ConcurrentQueue as its first member"); + assert(reinterpret_cast(reinterpret_cast(1)) == &(reinterpret_cast(1))->inner && "BlockingConcurrentQueue must have ConcurrentQueue as its first member"); if (!sema) { MOODYCAMEL_THROW(std::bad_alloc()); } } BlockingConcurrentQueue(size_t minCapacity, size_t maxExplicitProducers, size_t maxImplicitProducers) - : inner(minCapacity, maxExplicitProducers, maxImplicitProducers), sema(create(0, (int)Traits::MAX_SEMA_SPINS), &BlockingConcurrentQueue::template destroy) + : inner(minCapacity, maxExplicitProducers, maxImplicitProducers), sema(create(0, static_cast(Traits::MAX_SEMA_SPINS)), &BlockingConcurrentQueue::template destroy) { - assert(reinterpret_cast((BlockingConcurrentQueue*)1) == &((BlockingConcurrentQueue*)1)->inner && "BlockingConcurrentQueue must have ConcurrentQueue as its first member"); + assert(reinterpret_cast(reinterpret_cast(1)) == &(reinterpret_cast(1))->inner && "BlockingConcurrentQueue must have ConcurrentQueue as its first member"); if (!sema) { MOODYCAMEL_THROW(std::bad_alloc()); } @@ -179,12 +179,13 @@ class BlockingConcurrentQueue inline bool enqueue_bulk(It itemFirst, size_t count) { if ((details::likely)(inner.enqueue_bulk(std::forward(itemFirst), count))) { - sema->signal((LightweightSemaphore::ssize_t)(ssize_t)count); + assert(static_cast(count) >= 0); + sema->signal(static_cast(static_cast(count))); return true; } return false; } - + // Enqueues several items using an explicit producer token. // Allocates memory if required. Only fails if memory allocation fails // (or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed). @@ -195,7 +196,8 @@ class BlockingConcurrentQueue inline bool enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count) { if ((details::likely)(inner.enqueue_bulk(token, std::forward(itemFirst), count))) { - sema->signal((LightweightSemaphore::ssize_t)(ssize_t)count); + assert(static_cast(count) >= 0); + sema->signal(static_cast(static_cast(count))); return true; } return false; @@ -264,12 +266,13 @@ class BlockingConcurrentQueue inline bool try_enqueue_bulk(It itemFirst, size_t count) { if (inner.try_enqueue_bulk(std::forward(itemFirst), count)) { - sema->signal((LightweightSemaphore::ssize_t)(ssize_t)count); + assert(static_cast(count) >= 0); + sema->signal(static_cast(static_cast(count))); return true; } return false; } - + // Enqueues several items using an explicit producer token. // Does not allocate memory. Fails if not enough room to enqueue. // Note: Use std::make_move_iterator if the elements should be moved @@ -279,7 +282,8 @@ class BlockingConcurrentQueue inline bool try_enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count) { if (inner.try_enqueue_bulk(token, std::forward(itemFirst), count)) { - sema->signal((LightweightSemaphore::ssize_t)(ssize_t)count); + assert(static_cast(count) >= 0); + sema->signal(static_cast(static_cast(count))); return true; } return false; @@ -327,13 +331,14 @@ class BlockingConcurrentQueue inline size_t try_dequeue_bulk(It itemFirst, size_t max) { size_t count = 0; - max = (size_t)sema->tryWaitMany((LightweightSemaphore::ssize_t)(ssize_t)max); + assert(static_cast(max) >= 0); + max = static_cast(sema->tryWaitMany(static_cast(static_cast(max)))); while (count != max) { count += inner.template try_dequeue_bulk(itemFirst, max - count); } return count; } - + // Attempts to dequeue several elements from the queue using an explicit consumer token. // Returns the number of items actually dequeued. // Returns 0 if all producer streams appeared empty at the time they @@ -343,7 +348,8 @@ class BlockingConcurrentQueue inline size_t try_dequeue_bulk(consumer_token_t& token, It itemFirst, size_t max) { size_t count = 0; - max = (size_t)sema->tryWaitMany((LightweightSemaphore::ssize_t)(ssize_t)max); + assert(static_cast(max) >= 0); + max = static_cast(sema->tryWaitMany(static_cast(static_cast(max)))); while (count != max) { count += inner.template try_dequeue_bulk(token, itemFirst, max - count); } @@ -447,13 +453,14 @@ class BlockingConcurrentQueue inline size_t wait_dequeue_bulk(It itemFirst, size_t max) { size_t count = 0; - max = (size_t)sema->waitMany((LightweightSemaphore::ssize_t)(ssize_t)max); + assert(static_cast(max) >= 0); + max = static_cast(sema->waitMany(static_cast(static_cast(max)))); while (count != max) { count += inner.template try_dequeue_bulk(itemFirst, max - count); } return count; } - + // Attempts to dequeue several elements from the queue. // Returns the number of items actually dequeued, which can // be 0 if the timeout expires while waiting for elements, @@ -465,7 +472,8 @@ class BlockingConcurrentQueue inline size_t wait_dequeue_bulk_timed(It itemFirst, size_t max, std::int64_t timeout_usecs) { size_t count = 0; - max = (size_t)sema->waitMany((LightweightSemaphore::ssize_t)(ssize_t)max, timeout_usecs); + assert(static_cast(max) >= 0); + max = static_cast(sema->waitMany(static_cast(static_cast(max)), timeout_usecs)); while (count != max) { count += inner.template try_dequeue_bulk(itemFirst, max - count); } @@ -492,7 +500,8 @@ class BlockingConcurrentQueue inline size_t wait_dequeue_bulk(consumer_token_t& token, It itemFirst, size_t max) { size_t count = 0; - max = (size_t)sema->waitMany((LightweightSemaphore::ssize_t)(ssize_t)max); + assert(static_cast(max) >= 0); + max = static_cast(sema->waitMany(static_cast(static_cast(max)))); while (count != max) { count += inner.template try_dequeue_bulk(token, itemFirst, max - count); } @@ -510,7 +519,8 @@ class BlockingConcurrentQueue inline size_t wait_dequeue_bulk_timed(consumer_token_t& token, It itemFirst, size_t max, std::int64_t timeout_usecs) { size_t count = 0; - max = (size_t)sema->waitMany((LightweightSemaphore::ssize_t)(ssize_t)max, timeout_usecs); + assert(static_cast(max) >= 0); + max = static_cast(sema->waitMany(static_cast(static_cast(max)), timeout_usecs)); while (count != max) { count += inner.template try_dequeue_bulk(token, itemFirst, max - count); } @@ -537,7 +547,7 @@ class BlockingConcurrentQueue // Thread-safe. inline size_t size_approx() const { - return (size_t)sema->availableApprox(); + return static_cast(sema->availableApprox()); } diff --git a/concurrentqueue.h b/concurrentqueue.h index 9d00070f..d65f73c4 100644 --- a/concurrentqueue.h +++ b/concurrentqueue.h @@ -469,8 +469,15 @@ namespace details static inline size_t hash_thread_id(thread_id_t id) { static_assert(sizeof(thread_id_t) <= 8, "Expected a platform where thread IDs are at most 64-bit values"); +#if defined(__GNUC__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wuseless-cast" +#endif return static_cast(hash_32_or_64::thread_id_hash_t)>::hash( thread_id_converter::prehash(id))); +#if defined(__GNUC__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif } template diff --git a/lightweightsemaphore.h b/lightweightsemaphore.h index 3ae8100d..c103068f 100644 --- a/lightweightsemaphore.h +++ b/lightweightsemaphore.h @@ -234,8 +234,8 @@ class Semaphore #else clock_gettime(CLOCK_REALTIME, &ts); #endif - ts.tv_sec += (time_t)(usecs / usecs_in_1_sec); - ts.tv_nsec += (long)(usecs % usecs_in_1_sec) * 1000; + ts.tv_sec += static_cast(usecs / usecs_in_1_sec); + ts.tv_nsec += static_cast(usecs % usecs_in_1_sec) * 1000; // sem_timedwait bombs if you have more than 1e9 in tv_nsec // so we have to clean things up before passing it in if (ts.tv_nsec >= nsecs_in_1_sec) { @@ -306,7 +306,7 @@ class LightweightSemaphore if (m_sema.wait()) return true; } - if (timeout_usecs > 0 && m_sema.timed_wait((std::uint64_t)timeout_usecs)) + if (timeout_usecs > 0 && m_sema.timed_wait(static_cast(timeout_usecs))) return true; // At this point, we've timed out waiting for the semaphore, but the // count is still decremented indicating we may still be waiting on @@ -342,7 +342,7 @@ class LightweightSemaphore oldCount = m_count.fetch_sub(1, std::memory_order_acquire); if (oldCount <= 0) { - if ((timeout_usecs == 0) || (timeout_usecs < 0 && !m_sema.wait()) || (timeout_usecs > 0 && !m_sema.timed_wait((std::uint64_t)timeout_usecs))) + if ((timeout_usecs == 0) || (timeout_usecs < 0 && !m_sema.wait()) || (timeout_usecs > 0 && !m_sema.timed_wait(static_cast(timeout_usecs)))) { while (true) { @@ -425,7 +425,7 @@ class LightweightSemaphore ssize_t toRelease = -oldCount < count ? -oldCount : count; if (toRelease > 0) { - m_sema.signal((int)toRelease); + m_sema.signal(static_cast(toRelease)); } }