implab/ImplabNet Commit - r71:1714fd8678ef

code cleanup

cin -

r71:1714fd8678ef default

parent child

Context file:

r71:1714fd8678ef

Collapse all files

Implab/Parallels/MTQueue.cs +6 -6

                                  // this is the last element,
                                  // then try to update the tail
                                  if (first != Interlocked.CompareExchange(ref m_last, null, first)) {
-                                     // this is a race condition
+                                     // this is the race condition
                                      if (m_last == null)
                                          // the queue is empty
                                          return false;
-                                     // tail has been changed, than we need to restart
+                                     // tail has been changed, we need to restart
                                      continue;
                                  }
                                  // tail succesfully updated and first.next will never be changed
-                                 // other readers will fail due to inconsistency m_last != m_fist, but m_first.next == null
-                                 // but the writer may update the m_first since the m_last is null
+                                 // other readers will fail due to inconsistency m_last != m_fist && m_first.next == null
+                                 // however the parallel writer may update the m_first since the m_last is null
-                                 // so we need to fix inconsistency by setting m_first to null, but if it already has been
-                                 // updated by a writer then we should just give up
+                                 // so we need to fix inconsistency by setting m_first to null or if it has been
+                                 // updated by the writer already then we should just to give up
                                  Interlocked.CompareExchange(ref m_first, null, first);
                                  break;

Implab/Promise.cs +20 -20

                          }
                      }
-                     const int UnresolvedSate = 0;
-                     const int TransitionalState = 1;
-                     const int SucceededState = 2;
-                     const int RejectedState = 3;
-                     const int CancelledState = 4;
+                     const int UNRESOLVED_SATE = 0;
+                     const int TRANSITIONAL_STATE = 1;
+                     const int SUCCEEDED_STATE = 2;
+                     const int REJECTED_STATE = 3;
+                     const int CANCELLED_STATE = 4;
                      readonly bool m_cancellable;
                      }
                      bool BeginTransit() {
-                         return UnresolvedSate == Interlocked.CompareExchange(ref m_state, TransitionalState, UnresolvedSate);
+                         return UNRESOLVED_SATE == Interlocked.CompareExchange(ref m_state, TRANSITIONAL_STATE, UNRESOLVED_SATE);
                      }
                      void CompleteTransit(int state) {
-                         if (TransitionalState != Interlocked.CompareExchange(ref m_state, state, TransitionalState))
+                         if (TRANSITIONAL_STATE != Interlocked.CompareExchange(ref m_state, state, TRANSITIONAL_STATE))
                              throw new InvalidOperationException("Can't complete transition when the object isn't in the transitional state");
                      }
                      void WaitTransition() {
-                         while (m_state == TransitionalState) {
+                         while (m_state == TRANSITIONAL_STATE) {
                              /* noop */
                          }
                      }
                      public bool IsCancelled {
                          get {
-                             return m_state == CancelledState;
+                             return m_state == CANCELLED_STATE;
                          }
                      }
                      public void Resolve(T result) {
                          if (BeginTransit()) {
                              m_result = result;
-                             CompleteTransit(SucceededState);
+                             CompleteTransit(SUCCEEDED_STATE);
                              OnStateChanged();
                          } else {
                              WaitTransition();
-                             if (m_state != CancelledState)
+                             if (m_state != CANCELLED_STATE)
                                  throw new InvalidOperationException("The promise is already resolved");
                          }
                      }
                      public void Reject(Exception error) {
                          if (BeginTransit()) {
                              m_error = error;
-                             CompleteTransit(RejectedState);
+                             CompleteTransit(REJECTED_STATE);
                              OnStateChanged();
                          } else {
                              WaitTransition();
-                             if (m_state == SucceededState)
+                             if (m_state == SUCCEEDED_STATE)
                                  throw new InvalidOperationException("The promise is already resolved");
                          }
                      }
                      /// <returns><c>true</c> Операция была отменена, обработчики не будут вызваны.<c>false</c> отмена не возможна, поскольку обещание уже выполнено и обработчики отработали.</returns>
                      public bool Cancel() {
                          if (BeginTransit()) {
-                             CompleteTransit(CancelledState);
+                             CompleteTransit(CANCELLED_STATE);
                              OnStateChanged();
                              return true;
                          } else {
                              throw new TimeoutException();
                          switch (m_state) {
-                             case SucceededState:
+                             case SUCCEEDED_STATE:
                                  return m_result;
-                             case CancelledState:
+                             case CANCELLED_STATE:
                                  throw new OperationCanceledException();
-                             case RejectedState:
+                             case REJECTED_STATE:
                                  throw new TargetInvocationException(m_error);
                              default:
                                  throw new ApplicationException(String.Format("Invalid promise state {0}", m_state));
                      protected virtual void InvokeHandler(HandlerDescriptor handler) {
                          switch (m_state) {
-                             case SucceededState:
+                             case SUCCEEDED_STATE:
                                  handler.Resolve(m_result);
                                  break;
-                             case RejectedState:
+                             case REJECTED_STATE:
                                  handler.Reject(m_error);
                                  break;
-                             case CancelledState:
+                             case CANCELLED_STATE:
                                  handler.Cancel();
                                  break;
                              default:

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages