Remove draft comments

ybainier · ybainier · commit a5f70a340017 · 2018-01-25T10:11:05.000+01:00
diff --git a/Disruptor/Disruptor.h b/Disruptor/Disruptor.h
@@ -308,20 +308,6 @@ namespace Disruptor
             m_ringBuffer->publishEvent(eventTranslator);
         }
 
-        ///// <summary>
-        ///// Publish an event to the ring buffer.
-        ///// </summary>
-        ///// <param name="eventTranslator">the translator that will load data into the event</param>
-        ///// <param name="arg">A single argument to load into the event</param>
-        //public void PublishEvent<A>(IEventTranslatorOneArg<T, A> eventTranslator, A arg) => _ringBuffer.PublishEvent(eventTranslator, arg);
-
-        ///// <summary>
-        ///// Publish a batch of events to the ring buffer.
-        ///// </summary>
-        ///// <param name="eventTranslator">the translator that will load data into the event</param>
-        ///// <param name="arg">An array single arguments to load into the events. One Per event.</param>
-        //public void PublishEvent<A>(IEventTranslatorOneArg<T, A> eventTranslator, A[] arg) => _ringBuffer.PublishEvents(eventTranslator, arg);
-
         /// <summary>
         /// Starts the event processors and returns the fully configured ring buffer.
         /// 
@@ -407,28 +393,28 @@ namespace Disruptor
             return m_ringBuffer;
         }
 
-        ///// <summary>
-        ///// Get the value of the cursor indicating the published sequence.
-        ///// </summary>
+        /// <summary>
+        /// Get the value of the cursor indicating the published sequence.
+        /// </summary>
         std::int64_t cursor() const
         {
             return m_ringBuffer->cursor();
         }
 
-        ///// <summary>
-        ///// The capacity of the data structure to hold entries.
-        ///// </summary>
+        /// <summary>
+        /// The capacity of the data structure to hold entries.
+        /// </summary>
         std::int64_t bufferSize() const
         {
             return m_ringBuffer->bufferSize();
         }
 
-        ///// <summary>
-        ///// Get the event for a given sequence in the RingBuffer.
-        ///// <see cref="RingBuffer{T}.this"/>
-        ///// </summary>
-        ///// <param name="sequence">sequence for the event</param>
-        ///// <returns>event for the sequence</returns>
+        /// <summary>
+        /// Get the event for a given sequence in the RingBuffer.
+        /// <see cref="RingBuffer{T}.this"/>
+        /// </summary>
+        /// <param name="sequence">sequence for the event</param>
+        /// <returns>event for the sequence</returns>
         T& operator[](std::int64_t sequence) const
         {
             return m_ringBuffer[sequence];
diff --git a/Disruptor/MultiProducerSequencer.h b/Disruptor/MultiProducerSequencer.h
@@ -40,11 +40,7 @@ namespace Disruptor
         /// <returns>true if the buffer has the capacity to allocate the next sequence otherwise false.</returns>
         bool hasAvailableCapacity(std::int32_t requiredCapacity) override
         {
-            //auto gatingSequences = std::atomic_load_explicit(&this->m_gatingSequences, std::memory_order_acquire);
-
-            //return hasAvailableCapacity(Volatile.Read(ref _gatingSequences), requiredCapacity, _cursor.Value);
             return hasAvailableCapacity(this->m_gatingSequences, requiredCapacity, this->m_cursor->value());
-            //return hasAvailableCapacity(*gatingSequences, requiredCapacity, this->m_cursor->value());
         }
 
         /// <summary>
@@ -100,14 +96,12 @@ namespace Disruptor
 
                 if (wrapPoint > cachedGatingSequence || cachedGatingSequence > current)
                 {
-                    //auto gatingSequences = std::atomic_load_explicit(&this->m_gatingSequences, std::memory_order_acquire);
                     std::int64_t gatingSequence = Util::getMinimumSequence(this->m_gatingSequences, current);
-                    //std::int64_t gatingSequence = Util::getMinimumSequence(*gatingSequences, current);
 
                     if (wrapPoint > gatingSequence)
                     {
                         this->m_waitStrategy->signalAllWhenBlocking();
-                        spinWait.spinOnce(); // LockSupport.parkNanos(1L);
+                        spinWait.spinOnce();
                         continue;
                     }
 
@@ -154,10 +148,7 @@ namespace Disruptor
                 current = this->m_cursor->value();
                 next = current + n;
 
-                //auto gatingSequences = std::atomic_load_explicit(&this->m_gatingSequences, std::memory_order_acquire);
-
                 if (!hasAvailableCapacity(this->m_gatingSequences, n, current))
-                //if (!hasAvailableCapacity(*gatingSequences, n, current))
                 {
                     DISRUPTOR_THROW_INSUFFICIENT_CAPACITY_EXCEPTION();
                 }
@@ -172,13 +163,9 @@ namespace Disruptor
         /// </summary>
         std::int64_t getRemainingCapacity() override
         {
-            //auto gatingSequences = std::atomic_load_explicit(&this->m_gatingSequences, std::memory_order_acquire);
-
-            //auto consumed = Util::getMinimumSequence(m_gatingSequences/*Volatile.Read(ref _gatingSequences)*/, m_cursor->value());
             auto consumed = Util::getMinimumSequence(this->m_gatingSequences, this->m_cursorRef.value());
-            //auto consumed = Util::getMinimumSequence(*gatingSequences, this->m_cursor->value());
             auto produced = this->m_cursorRef.value();
-            //auto produced = this->m_cursor->value();
+
             return this->bufferSize() - (produced - consumed);
         }
 
@@ -190,7 +177,6 @@ namespace Disruptor
         {
             setAvailable(sequence);
             this->m_waitStrategyRef.signalAllWhenBlocking();
-            //this->m_waitStrategy->signalAllWhenBlocking();
         }
 
         /// <summary>
@@ -203,7 +189,6 @@ namespace Disruptor
                 setAvailable(l);
             }
             this->m_waitStrategyRef.signalAllWhenBlocking();
-            //this->m_waitStrategy->signalAllWhenBlocking();
         }
 
         /// <summary>
@@ -216,7 +201,6 @@ namespace Disruptor
             auto index = calculateIndex(sequence);
             auto flag = calculateAvailabilityFlag(sequence);
 
-            //    return Volatile.Read(ref buffer[index]) == flag;
             return m_availableBuffer[index] == flag;
         }
 
diff --git a/Disruptor/Sequence.cpp b/Disruptor/Sequence.cpp
@@ -21,7 +21,6 @@ namespace Disruptor
 
     void Sequence::setValue(std::int64_t value)
     {
-        //// no synchronization required, the CLR memory model prevents Store/Store re-ordering
         std::atomic_store_explicit(&m_fieldsValue, value, std::memory_order_release);
     }
 
@@ -33,19 +32,16 @@ namespace Disruptor
     bool Sequence::compareAndSet(std::int64_t expectedSequence, std::int64_t nextSequence)
     {
         return std::atomic_compare_exchange_strong(&m_fieldsValue, &expectedSequence, nextSequence);
-        //return Interlocked.CompareExchange(ref _fields.Value, nextSequence, expectedSequence) == expectedSequence;
     }
 
     std::int64_t Sequence::incrementAndGet()
     {
         return std::atomic_fetch_add(&m_fieldsValue, std::int64_t(1)) + 1;
-        //return Interlocked.Increment(ref _fields.Value);
     }
 
     std::int64_t Sequence::addAndGet(std::int64_t value)
     {
         return std::atomic_fetch_add(&m_fieldsValue, value) + value;
-        //return Interlocked.Add(ref _fields.Value, value);
     }
 
     void Sequence::writeDescriptionTo(std::ostream& stream) const
diff --git a/Disruptor/SingleProducerSequencer.h b/Disruptor/SingleProducerSequencer.h
@@ -49,11 +49,7 @@ namespace Disruptor
 
             if (wrapPoint > cachedGatingSequence || cachedGatingSequence > nextValue)
             {
-                //auto& gatingSequences = this->m_gatingSequences;
-                //auto gatingSequences = std::atomic_load_explicit(&this->m_gatingSequences, std::memory_order_acquire);
-
                 auto minSequence = Util::getMinimumSequence(this->m_gatingSequences, nextValue);
-                //auto minSequence = Util::getMinimumSequence(*gatingSequences, nextValue);
                 m_fields.cachedValue = minSequence;
 
                 if (wrapPoint > minSequence)
@@ -105,17 +101,11 @@ namespace Disruptor
             {
                 std::int64_t minSequence;
 
-                //auto& gatingSequences = this->m_gatingSequences;
-                //auto gatingSequences = std::atomic_load_explicit(&this->m_gatingSequences, std::memory_order_acquire);
-
                 SpinWait spinWait;
                 while (wrapPoint > (minSequence = Util::getMinimumSequence(this->m_gatingSequences, nextValue)))
-                //while (wrapPoint > (minSequence = Util::getMinimumSequence(*gatingSequences, nextValue)))
                 {
                     this->m_waitStrategyRef.signalAllWhenBlocking();
-                    //this->m_waitStrategy->signalAllWhenBlocking();
-
-                    spinWait.spinOnce(); // LockSupport.parkNanos(1L);
+                    spinWait.spinOnce();
                 }
 
                 m_fields.cachedValue = minSequence;
@@ -167,12 +157,9 @@ namespace Disruptor
         {
             auto nextValue = m_fields.nextValue;
 
-            //auto& gatingSequences = this->m_gatingSequences;
-            //auto gatingSequences = std::atomic_load_explicit(&this->m_gatingSequences, std::memory_order_acquire);
-
             auto consumed = Util::getMinimumSequence(this->m_gatingSequences, nextValue);
-            //auto consumed = Util::getMinimumSequence(*gatingSequences, nextValue);
             auto produced = nextValue;
+
             return this->bufferSize() - (produced - consumed);
         }
 
@@ -193,8 +180,6 @@ namespace Disruptor
         {
             this->m_cursorRef.setValue(sequence);
             this->m_waitStrategyRef.signalAllWhenBlocking();
-            //this->m_cursor->setValue(sequence);
-            //this->m_waitStrategy->signalAllWhenBlocking();
         }
 
         /// <summary>
@@ -215,7 +200,6 @@ namespace Disruptor
         bool isAvailable(std::int64_t sequence) override
         {
             return sequence <= this->m_cursorRef.value();
-            //return sequence <= this->m_cursor->value();
         }
 
         /// <summary>
diff --git a/Disruptor/ThreadPerTaskScheduler.cpp b/Disruptor/ThreadPerTaskScheduler.cpp
@@ -2,6 +2,7 @@
 
 #include "ThreadPerTaskScheduler.h"
 
+
 namespace Disruptor
 {
 
@@ -48,4 +49,4 @@ namespace Disruptor
         return result;
     }
 
-}
+} // namespace Disruptor

Original file line number	Diff line number	Diff line change
`@@ -40,11 +40,7 @@ namespace Disruptor`
`40`	`40`	`/// <returns>true if the buffer has the capacity to allocate the next sequence otherwise false.</returns>`
`41`	`41`	`bool hasAvailableCapacity(std::int32_t requiredCapacity) override`
`42`	`42`	`{`
`43`		`- //auto gatingSequences = std::atomic_load_explicit(&this->m_gatingSequences, std::memory_order_acquire);`
`44`		`-`
`45`		`- //return hasAvailableCapacity(Volatile.Read(ref _gatingSequences), requiredCapacity, _cursor.Value);`
`46`	`43`	`return hasAvailableCapacity(this->m_gatingSequences, requiredCapacity, this->m_cursor->value());`
`47`		`- //return hasAvailableCapacity(*gatingSequences, requiredCapacity, this->m_cursor->value());`
`48`	`44`	`}`
`49`	`45`
`50`	`46`	`/// <summary>`
`@@ -100,14 +96,12 @@ namespace Disruptor`
`100`	`96`
`101`	`97`	`if (wrapPoint > cachedGatingSequence \|\| cachedGatingSequence > current)`
`102`	`98`	`{`
`103`		`- //auto gatingSequences = std::atomic_load_explicit(&this->m_gatingSequences, std::memory_order_acquire);`
`104`	`99`	`std::int64_t gatingSequence = Util::getMinimumSequence(this->m_gatingSequences, current);`
`105`		`- //std::int64_t gatingSequence = Util::getMinimumSequence(*gatingSequences, current);`
`106`	`100`
`107`	`101`	`if (wrapPoint > gatingSequence)`
`108`	`102`	`{`
`109`	`103`	`this->m_waitStrategy->signalAllWhenBlocking();`
`110`		`- spinWait.spinOnce(); // LockSupport.parkNanos(1L);`
	`104`	`+ spinWait.spinOnce();`
`111`	`105`	`continue;`
`112`	`106`	`}`
`113`	`107`
`@@ -154,10 +148,7 @@ namespace Disruptor`
`154`	`148`	`current = this->m_cursor->value();`
`155`	`149`	`next = current + n;`
`156`	`150`
`157`		`- //auto gatingSequences = std::atomic_load_explicit(&this->m_gatingSequences, std::memory_order_acquire);`
`158`		`-`
`159`	`151`	`if (!hasAvailableCapacity(this->m_gatingSequences, n, current))`
`160`		`- //if (!hasAvailableCapacity(*gatingSequences, n, current))`
`161`	`152`	`{`
`162`	`153`	`DISRUPTOR_THROW_INSUFFICIENT_CAPACITY_EXCEPTION();`
`163`	`154`	`}`
`@@ -172,13 +163,9 @@ namespace Disruptor`
`172`	`163`	`/// </summary>`
`173`	`164`	`std::int64_t getRemainingCapacity() override`
`174`	`165`	`{`
`175`		`- //auto gatingSequences = std::atomic_load_explicit(&this->m_gatingSequences, std::memory_order_acquire);`
`176`		`-`
`177`		`- //auto consumed = Util::getMinimumSequence(m_gatingSequences/Volatile.Read(ref _gatingSequences)/, m_cursor->value());`
`178`	`166`	`auto consumed = Util::getMinimumSequence(this->m_gatingSequences, this->m_cursorRef.value());`
`179`		`- //auto consumed = Util::getMinimumSequence(*gatingSequences, this->m_cursor->value());`
`180`	`167`	`auto produced = this->m_cursorRef.value();`
`181`		`- //auto produced = this->m_cursor->value();`
	`168`	`+`
`182`	`169`	`return this->bufferSize() - (produced - consumed);`
`183`	`170`	`}`
`184`	`171`
`@@ -190,7 +177,6 @@ namespace Disruptor`
`190`	`177`	`{`
`191`	`178`	`setAvailable(sequence);`
`192`	`179`	`this->m_waitStrategyRef.signalAllWhenBlocking();`
`193`		`- //this->m_waitStrategy->signalAllWhenBlocking();`
`194`	`180`	`}`
`195`	`181`
`196`	`182`	`/// <summary>`
`@@ -203,7 +189,6 @@ namespace Disruptor`
`203`	`189`	`setAvailable(l);`
`204`	`190`	`}`
`205`	`191`	`this->m_waitStrategyRef.signalAllWhenBlocking();`
`206`		`- //this->m_waitStrategy->signalAllWhenBlocking();`
`207`	`192`	`}`
`208`	`193`
`209`	`194`	`/// <summary>`
`@@ -216,7 +201,6 @@ namespace Disruptor`
`216`	`201`	`auto index = calculateIndex(sequence);`
`217`	`202`	`auto flag = calculateAvailabilityFlag(sequence);`
`218`	`203`
`219`		`- // return Volatile.Read(ref buffer[index]) == flag;`
`220`	`204`	`return m_availableBuffer[index] == flag;`
`221`	`205`	`}`
`222`	`206`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,6 @@ namespace Disruptor`
`21`	`21`
`22`	`22`	`void Sequence::setValue(std::int64_t value)`
`23`	`23`	`{`
`24`		`- //// no synchronization required, the CLR memory model prevents Store/Store re-ordering`
`25`	`24`	`std::atomic_store_explicit(&m_fieldsValue, value, std::memory_order_release);`
`26`	`25`	`}`
`27`	`26`
`@@ -33,19 +32,16 @@ namespace Disruptor`
`33`	`32`	`bool Sequence::compareAndSet(std::int64_t expectedSequence, std::int64_t nextSequence)`
`34`	`33`	`{`
`35`	`34`	`return std::atomic_compare_exchange_strong(&m_fieldsValue, &expectedSequence, nextSequence);`
`36`		`- //return Interlocked.CompareExchange(ref _fields.Value, nextSequence, expectedSequence) == expectedSequence;`
`37`	`35`	`}`
`38`	`36`
`39`	`37`	`std::int64_t Sequence::incrementAndGet()`
`40`	`38`	`{`
`41`	`39`	`return std::atomic_fetch_add(&m_fieldsValue, std::int64_t(1)) + 1;`
`42`		`- //return Interlocked.Increment(ref _fields.Value);`
`43`	`40`	`}`
`44`	`41`
`45`	`42`	`std::int64_t Sequence::addAndGet(std::int64_t value)`
`46`	`43`	`{`
`47`	`44`	`return std::atomic_fetch_add(&m_fieldsValue, value) + value;`
`48`		`- //return Interlocked.Add(ref _fields.Value, value);`
`49`	`45`	`}`
`50`	`46`
`51`	`47`	`void Sequence::writeDescriptionTo(std::ostream& stream) const`
Original file line number	Diff line number	Diff line change
`@@ -49,11 +49,7 @@ namespace Disruptor`
`49`	`49`
`50`	`50`	`if (wrapPoint > cachedGatingSequence \|\| cachedGatingSequence > nextValue)`
`51`	`51`	`{`
`52`		`- //auto& gatingSequences = this->m_gatingSequences;`
`53`		`- //auto gatingSequences = std::atomic_load_explicit(&this->m_gatingSequences, std::memory_order_acquire);`
`54`		`-`
`55`	`52`	`auto minSequence = Util::getMinimumSequence(this->m_gatingSequences, nextValue);`
`56`		`- //auto minSequence = Util::getMinimumSequence(*gatingSequences, nextValue);`
`57`	`53`	`m_fields.cachedValue = minSequence;`
`58`	`54`
`59`	`55`	`if (wrapPoint > minSequence)`
`@@ -105,17 +101,11 @@ namespace Disruptor`
`105`	`101`	`{`
`106`	`102`	`std::int64_t minSequence;`
`107`	`103`
`108`		`- //auto& gatingSequences = this->m_gatingSequences;`
`109`		`- //auto gatingSequences = std::atomic_load_explicit(&this->m_gatingSequences, std::memory_order_acquire);`
`110`		`-`
`111`	`104`	`SpinWait spinWait;`
`112`	`105`	`while (wrapPoint > (minSequence = Util::getMinimumSequence(this->m_gatingSequences, nextValue)))`
`113`		`- //while (wrapPoint > (minSequence = Util::getMinimumSequence(*gatingSequences, nextValue)))`
`114`	`106`	`{`
`115`	`107`	`this->m_waitStrategyRef.signalAllWhenBlocking();`
`116`		`- //this->m_waitStrategy->signalAllWhenBlocking();`
`117`		`-`
`118`		`- spinWait.spinOnce(); // LockSupport.parkNanos(1L);`
	`108`	`+ spinWait.spinOnce();`
`119`	`109`	`}`
`120`	`110`
`121`	`111`	`m_fields.cachedValue = minSequence;`
`@@ -167,12 +157,9 @@ namespace Disruptor`
`167`	`157`	`{`
`168`	`158`	`auto nextValue = m_fields.nextValue;`
`169`	`159`
`170`		`- //auto& gatingSequences = this->m_gatingSequences;`
`171`		`- //auto gatingSequences = std::atomic_load_explicit(&this->m_gatingSequences, std::memory_order_acquire);`
`172`		`-`
`173`	`160`	`auto consumed = Util::getMinimumSequence(this->m_gatingSequences, nextValue);`
`174`		`- //auto consumed = Util::getMinimumSequence(*gatingSequences, nextValue);`
`175`	`161`	`auto produced = nextValue;`
	`162`	`+`
`176`	`163`	`return this->bufferSize() - (produced - consumed);`
`177`	`164`	`}`
`178`	`165`
`@@ -193,8 +180,6 @@ namespace Disruptor`
`193`	`180`	`{`
`194`	`181`	`this->m_cursorRef.setValue(sequence);`
`195`	`182`	`this->m_waitStrategyRef.signalAllWhenBlocking();`
`196`		`- //this->m_cursor->setValue(sequence);`
`197`		`- //this->m_waitStrategy->signalAllWhenBlocking();`
`198`	`183`	`}`
`199`	`184`
`200`	`185`	`/// <summary>`
`@@ -215,7 +200,6 @@ namespace Disruptor`
`215`	`200`	`bool isAvailable(std::int64_t sequence) override`
`216`	`201`	`{`
`217`	`202`	`return sequence <= this->m_cursorRef.value();`
`218`		`- //return sequence <= this->m_cursor->value();`
`219`	`203`	`}`
`220`	`204`
`221`	`205`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`
`3`	`3`	`#include "ThreadPerTaskScheduler.h"`
`4`	`4`
	`5`	`+`
`5`	`6`	`namespace Disruptor`
`6`	`7`	`{`
`7`	`8`
`@@ -48,4 +49,4 @@ namespace Disruptor`
`48`	`49`	`return result;`
`49`	`50`	`}`
`50`	`51`
`51`		`-}`
	`52`	`+} // namespace Disruptor`