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
+                                // other readers will fail due to inconsistency m_last != m_fist && m_first.next == null
-                                // but the writer may update the m_first since the m_last is 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
+                                // so we need to fix inconsistency by setting m_first to null or if it has been
-                                // updated by a writer then we should just give up
+                                // 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 UNRESOLVED_SATE = 0;
-                    const int TransitionalState = 1;
+                    const int TRANSITIONAL_STATE = 1;
-                    const int SucceededState = 2;
+                    const int SUCCEEDED_STATE = 2;
-                    const int RejectedState = 3;
+                    const int REJECTED_STATE = 3;
-                    const int CancelledState = 4;
+                    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