InternalThread.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
using MyCaffe.basecode;
 
namespace MyCaffe.common
{
    public class InternalThread<T> : IDisposable
    {
        Task m_task = null;
        Thread m_thread = null;
        CancelEvent m_evtCancel = new CancelEvent();
        AutoResetEvent m_evtDone = new AutoResetEvent(false);
        ManualResetEvent m_evtRunning = new ManualResetEvent(false);
        ManualResetEvent m_evtAbort = new ManualResetEvent(false);
        bool m_bUseThread = true;
 
        public event EventHandler<ActionStateArgs<T>> DoWork;
        public event EventHandler OnPreStop;
        public event EventHandler OnPreStart;
 
        public InternalThread(bool bUseThreadVsTask = false)
        {
            m_bUseThread = bUseThreadVsTask;
        }
 
        protected virtual void Dispose(bool bDisposing)
        {
            if (m_evtCancel != null)
                m_evtCancel.Set();
 
            StopInternalThread();
 
            if (m_evtCancel != null)
            {
                m_evtCancel.Dispose();
                m_evtCancel = null;
            }
        }
 
        public void Dispose()
        {
            Dispose(true);
        }
 
        public void StartInternalThread(CudaDnn<T> cuda, Log log, int nDeviceID = 0, object arg = null, int nInitialDelay = 0)
        {
            m_evtAbort.Reset();
            m_evtCancel.Reset();
 
            if (OnPreStart != null)
                OnPreStart(this, new EventArgs());
 
            if (m_bUseThread)
            {
                if (m_thread == null)
                {
                    m_thread = new Thread(new ParameterizedThreadStart(InternalThreadEntry));
                    m_thread.Start(new ActionStateArgs<T>(cuda, log, m_evtCancel, nDeviceID, arg, nInitialDelay));
                }
            }
            else
            {
                if (m_task == null)
                {
                    Action<object> action = new Action<object>(InternalThreadEntry);
                    m_task = Task.Factory.StartNew(action, new ActionStateArgs<T>(cuda, log, m_evtCancel, nDeviceID, arg), TaskCreationOptions.LongRunning);
                }
            }
        }
 
        private void waitForTerminate()
        {
            m_evtAbort.Set();
            if (!m_evtDone.WaitOne(10000))
                throw new Exception("The Internal Thread (thread) failed to stop!");
        }
 
        public void StopInternalThread()
        {
            if (OnPreStop != null)
                OnPreStop(this, new EventArgs());
 
            if (m_thread != null)
            {
                m_evtCancel.Set();
                waitForTerminate();
                m_thread = null;
            }
 
            if (m_task != null)
            {
                m_evtCancel.Set();
                waitForTerminate();
                m_task = null;
            }
        }
 
        protected void InternalThreadEntry(object obj)
        {
            m_evtRunning.Set();
            ActionStateArgs<T> state = obj as ActionStateArgs<T>;
 
            try
            {
                if (state.InitialDelay > 0)
                    Thread.Sleep(state.InitialDelay);
 
                if (DoWork != null)
                    DoWork(this, state);
            }
            finally
            {
                m_evtRunning.Reset();
                m_evtDone.Set();
            }
        }
 
        public bool CancellationPending
        {
            get
            {
                if (m_evtAbort.WaitOne(0))
                    return true;
 
                return false;
            }
        }
 
        public bool IsStarted
        {
            get
            {
                if (m_task == null)
                    return false;
 
                return true;
            }
        }
    }
 
    public class ActionStateArgs<T> : EventArgs
    {
        CudaDnn<T> m_cuda = null;
        Log m_log = null;
        CancelEvent m_evtCancel;
        int m_nDeviceID = 0;
        int m_nInitialDelay = 0;
        object m_arg = null;
 
        public ActionStateArgs(CudaDnn<T> cuda, Log log, CancelEvent evtCancel, int nDeviceID = 0, object arg = null, int nInitialDelay = 0)
            : base()
        {
            m_log = log;
            m_cuda = cuda;
            m_evtCancel = evtCancel;
            m_nDeviceID = nDeviceID;
            m_arg = arg;
            m_nInitialDelay = nInitialDelay;
        }
 
        public CudaDnn<T> cuda
        {
            get { return m_cuda; }
            set { m_cuda = value; }
        }
 
        public Log log
        {
            get { return m_log; }
        }
 
        public CancelEvent CancelEvent
        {
            get { return m_evtCancel; }
        }
 
        public int DeviceID
        {
            get { return m_nDeviceID; }
        }
 
        public object Arg
        {
            get { return m_arg; }
        }
 
        public int InitialDelay
        {
            get { return m_nInitialDelay; }
        }
    }
}