GSF.Core: Updated LogicalThread API to handle prioritization at the thread scheduler so that threads can be reprioritized based on the priority of their tasks.

StephenCWills committed 9 years ago

Commit d6482bb1 parent 3c892cb4 files · +153 −53Browse files

Showing the changes to Source/Libraries/GSF.Core.Shared/Threading/LogicalThread.cs (1 of 4 files). Show all

Unified · Split

Source/Libraries/GSF.Core.Shared/Threading/LogicalThread.cs+65−26

         private LogicalThreadScheduler m_scheduler;
         private ConcurrentQueue<Action>[] m_queues;
         private Dictionary<object, object> m_threadLocalStorage;
-        private int m_isActive;
+        private ICancellationToken m_nextExecutionToken;
+        private int m_activePriority;
         private LogicalThreadStatistics m_statistics;
         /// Creates a new instance of the <see cref="LogicalThread"/> class.
         /// </summary>
         public LogicalThread()
-            : this(1)
+            : this(DefaultScheduler)
-        {
-        }
-        /// <summary>
-        /// Creates a new instance of the <see cref="LogicalThread"/> class.
-        /// </summary>
-        /// <param name="priorityLevels">The number of levels of priority supported by this logical thread.</param>
-        public LogicalThread(int priorityLevels)
-            : this(DefaultScheduler, priorityLevels)
         {
         }
         /// Creates a new instance of the <see cref="LogicalThread"/> class.
         /// </summary>
         /// <param name="scheduler">The <see cref="LogicalThreadScheduler"/> that created this thread.</param>
-        /// <param name="priorityLevels">The number of levels of priority supported by this logical thread.</param>
         /// <exception cref="ArgumentNullException"><paramref name="scheduler"/> is null.</exception>
-        /// <exception cref="ArgumentException"><paramref name="priorityLevels"/> is less than or equal to zero.</exception>
+        internal LogicalThread(LogicalThreadScheduler scheduler)
-        internal LogicalThread(LogicalThreadScheduler scheduler, int priorityLevels)
         {
             if ((object)scheduler == null)
                 throw new ArgumentNullException(nameof(scheduler));
-            if (priorityLevels <= 0)
-                throw new ArgumentException($"A logical thread must have at least one priority level.", nameof(priorityLevels));
             m_scheduler = scheduler;
-            m_queues = new ConcurrentQueue<Action>[priorityLevels];
+            m_queues = new ConcurrentQueue<Action>[PriorityLevels];
             m_threadLocalStorage = new Dictionary<object, object>();
+            m_nextExecutionToken = new CancellationToken();
             m_statistics = new LogicalThreadStatistics();
             for (int i = 0; i < m_queues.Length; i++)
         {
             get
             {
-                return m_queues.Length;
+                return m_scheduler.PriorityLevels;
             }
         }
             }
         }
+        /// <summary>
+        /// Gets or sets the priority at which the
+        /// logical thread is queued by the scheduler.
+        /// </summary>
+        internal int ActivePriority
+        {
+            get
+            {
+                return Interlocked.CompareExchange(ref m_activePriority, 0, 0);
+            }
+            set
+            {
+                Interlocked.Exchange(ref m_activePriority, value);
+            }
+        }
+        /// <summary>
+        /// Gets the priority of the next action to be processed on this logical thread.
+        /// </summary>
+        internal int NextPriority
+        {
+            get
+            {
+                return PriorityLevels - m_queues.TakeWhile(queue => queue.IsEmpty).Count();
+            }
+        }
+        /// <summary>
+        /// Gets or sets the cancellation token for the next time
+        /// the thread's actions will be executed by the scheduler.
+        /// </summary>
+        internal ICancellationToken NextExecutionToken
+        {
+            get
+            {
+                return Interlocked.CompareExchange(ref m_nextExecutionToken, null, null);
+            }
+            set
+            {
+                Interlocked.Exchange(ref m_nextExecutionToken, value);
+            }
+        }
         #endregion
         #region [ Methods ]
                 throw new ArgumentException($"Priority {priority} is outside the range between 1 and {PriorityLevels}.", nameof(priority));
             m_queues[PriorityLevels - priority].Enqueue(action);
-            m_scheduler.SignalItemHandler(this);
+            m_scheduler.SignalItemHandler(this, priority);
         }
         /// <summary>
         }
         /// <summary>
-        /// Activates the thread if it is not already active.
+        /// Attempts to activate the thread at the given priority.
         /// </summary>
-        /// <returns>True if this call to TryActivate caused the thread to be active.</returns>
+        /// <param name="priority">The priority at which to activate the thread.</param>
-        internal bool TryActivate()
+        /// <returns>True if the thread's priority needs to be changed to the given priority; false otherwise.</returns>
+        internal bool TryActivate(int priority)
         {
-            return Interlocked.CompareExchange(ref m_isActive, 1, 0) == 0;
+            // Always get the execution token before the
+            // active priority to mitigate race conditions
+            ICancellationToken nextExecutionToken = NextExecutionToken;
+            int activePriority = ActivePriority;
+            return (activePriority < priority) && nextExecutionToken.Cancel();
         }
         /// <summary>
-        /// Deactivates the thread.
+        /// Completely deactivates the thread, making it available for reactivation at any priority.
         /// </summary>
         internal void Deactivate()
         {
-            Interlocked.Exchange(ref m_isActive, 0);
+            // Always update the active priority before the
+            // execution token to mitigate race conditions
+            ActivePriority = 0;
+            NextExecutionToken = new CancellationToken();
         }
         /// <summary>

GSF.Core: Updated LogicalThread API to handle prioritization at the thread scheduler so that threads can be reprioritized based on the priority of their tasks.

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code