Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Workflow.Runtime/Lock.cs

@@ -0,0 +1,362 @@
+// ****************************************************************************
+// Copyright (C)  Microsoft Corporation.  All rights reserved.
+//
+// CONTENTS
+//     Value-add wrapper on top of standard CLR monitor
+// 
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Globalization;
+using System.Xml;
+using System.Reflection;
+using System.Threading;
+using System.Diagnostics;
+using System.Transactions;
+
+using System.Workflow.Runtime.Hosting;
+
+namespace System.Workflow.Runtime
+{
+    internal static class LockFactory
+    {
+        internal static InstanceLock CreateWorkflowExecutorLock(Guid id)
+        {
+            return new InstanceLock(id, "Workflow Executor Lock: " + id.ToString(), 50, LockPriorityOperator.GreaterThanOrReentrant);
+        }
+
+        internal static InstanceLock CreateWorkflowSchedulerLock(Guid id)
+        {
+            return new InstanceLock(id, "Workflow Scheduler Lock: " + id.ToString(), 40, LockPriorityOperator.GreaterThan);
+        }
+
+        internal static InstanceLock CreateWorkflowMessageDeliveryLock(Guid id)
+        {
+            return new InstanceLock(id, "Workflow Message Delivery Lock: " + id.ToString(), 35, LockPriorityOperator.GreaterThanOrReentrant);
+        }
+    }
+
+    internal enum LockPriorityOperator
+    {
+        GreaterThan,
+        GreaterThanOrReentrant,
+    }
+
+    internal sealed class InstanceLock 
+    {
+        #region Static Data/Methods
+
+        [ThreadStaticAttribute()]
+        private static List<InstanceLock> t_heldLocks = null;
+
+        [Conditional("DEBUG")]
+        internal static void AssertNoLocksHeld()
+        {
+#if DEBUG
+            System.Diagnostics.Debug.Assert(HeldLocks.Count == 0, "No locks should be held.");
+#endif
+        }
+
+        [Conditional("DEBUG")]
+        internal static void AssertIsLocked(InstanceLock theLock)
+        {
+#if DEBUG
+            System.Diagnostics.Debug.Assert(HeldLocks.Contains(theLock), "Lock should be held.");
+#endif
+        }
+
+        private static List<InstanceLock> HeldLocks
+        {
+            get
+            {
+                List<InstanceLock> tLocks = InstanceLock.t_heldLocks;
+                if (tLocks == null)
+                {
+                    InstanceLock.t_heldLocks = new List<InstanceLock>();
+                    tLocks = InstanceLock.t_heldLocks;
+                }
+                return tLocks;
+            }
+        }
+
+        #endregion Static Data/Methods
+
+        private Guid m_instanceId;
+        private String m_name;
+        private int m_priority;
+        private LockPriorityOperator m_operator;
+
+        internal int Priority
+        {
+            get
+            {
+                return this.m_priority;
+            }
+        }
+
+        internal LockPriorityOperator Operator
+        {
+            get
+            {
+                return this.m_operator;
+            }
+        }
+
+        internal InstanceLock(Guid id, String name, int priority, LockPriorityOperator lockOperator)
+        {
+            this.m_instanceId = id;
+            this.m_name = name;
+            this.m_priority = priority;
+            this.m_operator = lockOperator;
+        }
+
+        internal Guid InstanceId
+        {
+            get
+            {
+                return this.m_instanceId;
+            }
+        }
+
+        internal InstanceLockGuard Enter()
+        {
+            return new InstanceLockGuard(this);
+        }
+
+        internal bool TryEnter()
+        {
+            InstanceLockGuard.EnforceGuard(this);
+
+            bool lockHeld = false;
+            bool success = false;
+            try
+            {
+                Monitor.TryEnter(this, ref lockHeld);
+
+                if (lockHeld)
+                {
+                    HeldLocks.Add(this);
+                    success = true;
+                }
+            }
+            finally
+            {
+                if (lockHeld && !success)
+                {
+                    Monitor.Exit(this);
+                }
+            }
+            return success;
+        }
+
+        internal void Exit()
+        {
+            try
+            {
+                HeldLocks.Remove(this);
+            }
+            finally
+            {
+                Monitor.Exit(this);
+            }
+        }
+
+        internal struct InstanceLockGuard : IDisposable
+        {
+            readonly InstanceLock m_lock;
+
+            internal static void EnforceGuard(InstanceLock theLock)
+            {
+                foreach (InstanceLock heldLock in HeldLocks)
+                {
+                    switch (theLock.Operator)
+                    {
+                        case LockPriorityOperator.GreaterThan:
+                            if (heldLock.InstanceId == theLock.InstanceId && heldLock.Priority <= theLock.Priority)
+                                throw new InvalidOperationException(ExecutionStringManager.InstanceOperationNotValidinWorkflowThread);
+                            break;
+
+                        case LockPriorityOperator.GreaterThanOrReentrant:
+                            // the checks here assume that locks have unique priorities
+                            if (heldLock.InstanceId == theLock.InstanceId && heldLock.Priority < theLock.Priority)
+                                throw new InvalidOperationException(ExecutionStringManager.InstanceOperationNotValidinWorkflowThread);
+                            break;
+
+                        default:
+                            System.Diagnostics.Debug.Assert(false, "Unrecognized lock operator");
+                            break;
+                    }
+                }
+            }
+
+            internal InstanceLockGuard(InstanceLock theLock)
+            {
+                this.m_lock = theLock;
+
+                // Note: the following operations are logically atomic, but since the
+                // list we are using is thread local there is no need to take a lock.
+
+                EnforceGuard(theLock);
+
+                try
+                {
+                }
+                finally
+                {
+                    bool success = false;
+#pragma warning disable 0618
+//@
+                    Monitor.Enter(this.m_lock);
+#pragma warning restore 0618
+                    try
+                    {
+                        HeldLocks.Add(this.m_lock);
+                        success = true;
+                    }
+                    finally
+                    {
+                        if (!success)
+                        {
+                            Monitor.Exit(this.m_lock);
+                        }
+                    }
+                }
+            }
+
+            internal void Pulse()
+            {
+                Monitor.Pulse(this.m_lock);
+            }
+
+            internal void Wait()
+            {
+                Monitor.Wait(this.m_lock);
+            }
+
+            public void Dispose()
+            {
+                // Note: the following operations are logically atomic, but since the
+                // list we are using is thread local there is no need to take a lock.
+                try
+                {
+                    HeldLocks.Remove(this.m_lock);
+                }
+                finally
+                {
+                    Monitor.Exit(this.m_lock);
+                }
+            }
+        }
+    }
+
+    internal sealed class SchedulerLockGuard : IDisposable
+    {
+        private InstanceLock.InstanceLockGuard lg;
+        private WorkflowExecutor workflowExec;
+
+        internal SchedulerLockGuard(InstanceLock il, WorkflowExecutor w)
+        {
+            lg = il.Enter();
+            workflowExec = w;
+        }
+
+        private static void FireEvents(List<SchedulerLockGuardInfo> eventList, WorkflowExecutor workflowExec)
+        {
+            if (!workflowExec.IsInstanceValid && (workflowExec.WorkflowStatus == WorkflowStatus.Completed || workflowExec.WorkflowStatus == WorkflowStatus.Terminated))
+            {
+                // The workflow is dead, let the instance have a hard ref to the corpse for support of the query apis.
+                workflowExec.WorkflowInstance.DeadWorkflow = workflowExec;
+            }
+            for (int i = 0; i < eventList.Count; i++)
+            {
+                SchedulerLockGuardInfo eseg = eventList[i];
+                // eseg.EventInfo is non-null only if the event type is Suspended or Terminated
+                // If the event type is Suspended, then call FireWorkflowSuspended after casting
+                //   the event argument to a String.
+                // If the event type is Terminated, then call FireWorkflowTerminated after casting
+                //   the event argument to either a String or an Exception.
+                switch (eseg.EventType)
+                {
+                    case WorkflowEventInternal.Suspended:
+                        workflowExec.FireWorkflowSuspended((String)eseg.EventInfo);
+                        break;
+                    case WorkflowEventInternal.Terminated:
+                        if ((eseg.EventInfo as System.Exception) != null)
+                        {
+                            workflowExec.FireWorkflowTerminated((Exception)eseg.EventInfo);
+                        }
+                        else
+                        {
+                            workflowExec.FireWorkflowTerminated((String)eseg.EventInfo);
+                        }
+                        break;
+                    default:
+                        workflowExec.FireWorkflowExecutionEvent(eseg.Sender, eseg.EventType);
+                        break;
+                }
+            }
+        }
+
+        internal static void Exit(InstanceLock il, WorkflowExecutor w)
+        {
+            List<SchedulerLockGuardInfo> eventList = new List<SchedulerLockGuardInfo>(w.EventsToFireList);
+            w.EventsToFireList.Clear();
+            il.Exit();
+            FireEvents(eventList, w);
+        }
+
+        public void Dispose()
+        {
+            List<SchedulerLockGuardInfo> eventList = new List<SchedulerLockGuardInfo>(workflowExec.EventsToFireList);
+            workflowExec.EventsToFireList.Clear();
+            lg.Dispose();
+            FireEvents(eventList, workflowExec);
+        }
+    }
+
+    internal sealed class SchedulerLockGuardInfo
+    {
+        private Object sender;
+        private WorkflowEventInternal eventType;
+        private object eventInfo;
+
+        internal SchedulerLockGuardInfo(Object _sender, WorkflowEventInternal _eventType)
+        {
+            sender = _sender;
+            eventType = _eventType;
+            eventInfo = null;
+        }
+
+        internal SchedulerLockGuardInfo(Object _sender, WorkflowEventInternal _eventType, object _eventInfo)
+            : this(_sender, _eventType)
+        {
+            eventInfo = _eventInfo;
+        }
+
+        internal Object Sender
+        {
+            get
+            {
+                return sender;
+            }
+        }
+
+        internal WorkflowEventInternal EventType
+        {
+            get
+            {
+                return eventType;
+            }
+        }
+
+        internal Object EventInfo
+        {
+            get
+            {
+                return eventInfo;
+            }
+        }
+    }
+}