Address review feedback from cameron314

- Reword traits doc comment per maintainer's suggestion (no formula, no issue ref)
- Shorten try_enqueue note and add it consistently to all implicit try-enqueue methods
- Rename "Fix" to "Workaround" in test comments (behavior is by design)

Author: PavelGuzenfeld

concurrentqueue.h

@@ -355,12 +355,12 @@ struct ConcurrentQueueDefaultTraits
 
 	// How many full blocks can be expected for a single implicit producer? This should
 	// reflect that number's maximum for optimal performance. Must be a power of 2.
-	// Note: This controls the maximum number of elements that can be enqueued by a
-	// single implicit producer when using try_enqueue (which does not allocate).
-	// The limit is BLOCK_SIZE * IMPLICIT_INITIAL_INDEX_SIZE elements; beyond that,
-	// the block index needs to grow, which requires allocation, causing try_enqueue
-	// to fail. Increase this value (or use enqueue(), which can allocate) if you need
-	// more capacity per implicit producer. See also issue #418.
+	// Note: This impacts the maximum number of elements that can be enqueued by a
+	// single implicit producer when using try_enqueue/try_enqeue_bulk exclusively (which
+	// cannot allocate), since it limits the number of blocks that the producer can hold to
+	// store elements. When pre-allocating blocks for use with try-enqueueing, configure
+	// this initial size to the desired maximum number of blocks per implicit producer.
+	// Alternately, use the regular enqueue methods, which can grow the index as needed.
 	static const size_t IMPLICIT_INITIAL_INDEX_SIZE = 32;
 
 	// The initial size of the hash table mapping thread IDs to implicit producers.
@@ -1069,11 +1069,9 @@ class ConcurrentQueue
 	// Does not allocate memory. Fails if not enough room to enqueue (or implicit
 	// production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE
 	// is 0).
-	// Note: For implicit producers (no token), the maximum number of elements that
-	// can be held is BLOCK_SIZE * IMPLICIT_INITIAL_INDEX_SIZE before the block
-	// index must grow (which requires allocation and causes try_enqueue to fail).
-	// Pre-allocating blocks via the constructor does not increase the index size.
-	// Increase IMPLICIT_INITIAL_INDEX_SIZE in your traits, or use enqueue() instead.
+	// Note: If using only try_enqueue/try_enqueue_bulk with pre-allocated blocks, configure
+	// Traits::IMPLICIT_INITIAL_INDEX_SIZE appropriately to ensure the index has sufficient
+	// capacity for the number of blocks each producer may need.
 	// Thread-safe.
 	inline bool try_enqueue(T const& item)
 	{
@@ -1085,6 +1083,9 @@ class ConcurrentQueue
 	// Does not allocate memory (except for one-time implicit producer).
 	// Fails if not enough room to enqueue (or implicit production is
 	// disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0).
+	// Note: If using only try_enqueue/try_enqueue_bulk with pre-allocated blocks, configure
+	// Traits::IMPLICIT_INITIAL_INDEX_SIZE appropriately to ensure the index has sufficient
+	// capacity for the number of blocks each producer may need.
 	// Thread-safe.
 	inline bool try_enqueue(T&& item)
 	{
@@ -1112,6 +1113,9 @@ class ConcurrentQueue
 	// Does not allocate memory (except for one-time implicit producer).
 	// Fails if not enough room to enqueue (or implicit production is
 	// disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0).
+	// Note: If using only try_enqueue/try_enqueue_bulk with pre-allocated blocks, configure
+	// Traits::IMPLICIT_INITIAL_INDEX_SIZE appropriately to ensure the index has sufficient
+	// capacity for the number of blocks each producer may need.
 	// Note: Use std::make_move_iterator if the elements should be moved
 	// instead of copied.
 	// Thread-safe.

tests/unittests/unittests.cpp

@@ -5070,7 +5070,7 @@ class ConcurrentQueueTests : public TestClass<ConcurrentQueueTests>
 		}
 
 		{
-			// Fix #1: enqueue() (which can allocate) works past the limit
+			// Workaround #1: enqueue() (which can allocate) can grow the index
 			const int limit = (int)(SmallImplicitIndexTraits::BLOCK_SIZE * SmallImplicitIndexTraits::IMPLICIT_INITIAL_INDEX_SIZE);
 			ConcurrentQueue<int, SmallImplicitIndexTraits> q(limit + 64);
 
@@ -5087,7 +5087,7 @@ class ConcurrentQueueTests : public TestClass<ConcurrentQueueTests>
 		}
 
 		{
-			// Fix #2: larger IMPLICIT_INITIAL_INDEX_SIZE allows more try_enqueue calls
+			// Workaround #2: larger IMPLICIT_INITIAL_INDEX_SIZE allows more try_enqueue calls
 			const int small_limit = (int)(SmallImplicitIndexTraits::BLOCK_SIZE * SmallImplicitIndexTraits::IMPLICIT_INITIAL_INDEX_SIZE);		// 16
 			const int large_limit = (int)(LargerImplicitIndexTraits::BLOCK_SIZE * LargerImplicitIndexTraits::IMPLICIT_INITIAL_INDEX_SIZE);	// 64
 			ConcurrentQueue<int, LargerImplicitIndexTraits> q(large_limit + 64);