FiberScheduler.cs

Go to the documentation of this file.

/*

Author: Aaron Oneal, http://aarononeal.info

Copyright (c) 2012 Spicy Pixel, http://spicypixel.com

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

*/
using System;
using System.Threading;

namespace SpicyPixel.Threading
{
    public abstract class FiberScheduler : IFiberScheduler, IDisposable
    {
        [ThreadStatic]
        private static FiberScheduler currentScheduler;

        CancellationTokenSource cancelSource = new CancellationTokenSource();

        public CancellationToken CancellationToken
        {
            get { return cancelSource.Token; }
        }

        public static FiberScheduler Current 
        {
            get 
            { 
                if(currentScheduler == null)
                {
                    // Make a new scheduler
                    SetCurrentScheduler(new SystemFiberScheduler(), true);
                }

                return currentScheduler;
            }
            
            // Private for now. Better not to let the caller set this and
            // instead let it be set during execution. This way any
            // new fibers inside a running fiber will use the same scheduler,
            // and there is no risk of the caller changing it out from
            // under the framework or wind up with a scheduler they didn't
            // expect. For example, a caller in Unity might think they
            // could set the current scheduler in Awake() and use the
            // same scheduler in Update() even though another MonoBehaviour
            // Awake() set it to something else because they all share
            // the same thread. The current scheduler on a thread will
            // get changed out automatically during Task.Execute()
            // invoked by Update() invoked by Run().
            /*private set
            {
                SetCurrentScheduler(value, false);
            }*/
        }

        static internal void SetCurrentScheduler(FiberScheduler scheduler, bool internalInvoke)
        {
            // Only allow scheduler changes on a thread when a fiber is not executing.
            // Ignore this check if this is an internal invocation such as from
            // Fiber.Execute() which needs to switch schedulers on demand.
            if(!internalInvoke && Fiber.CurrentFiber != null)
                throw new InvalidOperationException("The current scheduler for the thread cannot be changed from inside an executing fiber.");
         
            // Skip work if nothing to change
            if(currentScheduler == scheduler)
                return;

            // Assign the scheduler
            currentScheduler = scheduler;
            
            // Update the synchronization context if it changed
            if(currentScheduler != null && SynchronizationContext.Current != currentScheduler.SynchronizationContext)
                SynchronizationContext.SetSynchronizationContext(currentScheduler.SynchronizationContext);
            else if(currentScheduler == null && SynchronizationContext.Current != null)
                SynchronizationContext.SetSynchronizationContext(null);
        }

        private Thread schedulerThread;
        
        internal SynchronizationContext SynchronizationContext { get; private set; }

        /*
        public bool IsSchedulerThread
        {
            get { return Thread.CurrentThread == schedulerThread; }
        }
        */
        
        public Thread SchedulerThread
        {
            get { return schedulerThread; }
        }
        
        public bool AllowInlining { get; set; }
        
        protected FiberScheduler()
        {
            AllowInlining = true;
            schedulerThread = Thread.CurrentThread;
            SynchronizationContext = new FiberSchedulerSynchronizationContext(this);
        }
                
        // Used by Fiber to invoke the protected methods
        void IFiberScheduler.QueueFiber(Fiber fiber)
        {
            this.QueueFiber(fiber);
        }
        
        // Used by Fiber to invoke the protected methods
        void IFiberScheduler.AbortRequested(Fiber fiber)
        {
            this.AbortRequested(fiber);
        }
        
        public void Run(Fiber fiber)
        {
            Run (fiber, CancellationToken.None, 0f);
        }

        public virtual void Run(Fiber fiber, CancellationToken token, float updatesPerSecond = 0f)
        {
            throw new NotImplementedException();
        }

        public void Run()
        {
            Run (CancellationToken.None);
        }
        
        public virtual void Run(CancellationToken token, float updatesPerSecond = 0f)
        {
            Run (null, token, updatesPerSecond);
        }
                
        protected abstract void QueueFiber(Fiber fiber);
        
        protected abstract void AbortRequested(Fiber fiber);
        
        protected FiberInstruction ExecuteFiber(Fiber fiber)
        {
            return fiber.Execute();
        }
        
        #region IDisposable implementation
        
        ~FiberScheduler()
        {
            Dispose(false);
        }
        
        private bool isDisposed = false;
        
        public void Dispose() 
        {           
            Dispose(true);
            GC.SuppressFinalize(this); 
        }
        
        protected virtual void Dispose(bool disposing) 
        {
            // Do nothing if already called
            if(isDisposed)
                return;
                        
            if(disposing) 
            {
                // Free other state (managed objects).
                cancelSource.Cancel();
            }
            
            // Free your own state (unmanaged objects).
            // Set large fields to null.
            
            // Mark disposed
            isDisposed = true;          
        }
        #endregion
    }
}