//******************************************************************************************************//  PrecisionInputTimer.cs - Gbtc////  Copyright © 2010, Grid Protection Alliance.  All Rights Reserved.////  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See//  the NOTICE file distributed with this work for additional information regarding copyright ownership.//  The GPA licenses this file to you under the Eclipse Public License -v 1.0 (the "License"); you may//  not use this file except in compliance with the License. You may obtain a copy of the License at:////      http://www.opensource.org/licenses/eclipse-1.0.php////  Unless agreed to in writing, the subject software distributed under the License is distributed on an//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the//  License for the specific language governing permissions and limitations.////  Code Modification History://  ----------------------------------------------------------------------------------------------------//  07/25/2012 - J. Ritchie Carroll//       Generated original version of source code.////****************************************************************************************************** using System;using System.Collections.Generic;using System.Threading; namespace GSF.TimeSeries{    /// <summary>    /// Precision input timer.    /// </summary>    /// <remarks>    /// This class is used to create highly accurate simulated data inputs aligned to the local clock.<br/>    /// One static instance of this internal class is created per encountered frame rate.    /// </remarks>    public sealed class PrecisionInputTimer : IDisposable    {        #region [ Members ]         // Fields        private PrecisionTimer m_timer;        private bool m_useWaitHandleA;        private SpinLock m_timerTickLock;        private ManualResetEventSlim m_frameWaitHandleA;        private ManualResetEventSlim m_frameWaitHandleB;        private readonly int m_framesPerSecond;        private readonly int m_frameWindowSize;        private readonly int[] m_frameMilliseconds;        private int m_lastFrameIndex;        private long m_lastFrameTime;        private long m_missedPublicationWindows;        private long m_lastMissedWindowTime;        private long m_resynchronizations;        private int m_referenceCount;        private Action<Exception> m_exceptionHandler;        private bool m_disposed;         #endregion         #region [ Constructors ]         /// <summary>        /// Create a new <see cref="PrecisionInputTimer"/> class.        /// </summary>        /// <param name="framesPerSecond">Desired frame rate for <see cref="PrecisionTimer"/>.</param>        internal PrecisionInputTimer(int framesPerSecond)        {            // Create synchronization objects            m_timerTickLock = new SpinLock();            m_frameWaitHandleA = new ManualResetEventSlim(false);            m_frameWaitHandleB = new ManualResetEventSlim(false);            m_useWaitHandleA = true;            m_framesPerSecond = framesPerSecond;             // Create a new precision timer for this timer state            m_timer = new PrecisionTimer();            m_timer.Resolution = 1;            m_timer.Period = 1;            m_timer.AutoReset = true;             // Attach handler for timer ticks            m_timer.Tick += m_timer_Tick;             m_frameWindowSize = (int)Math.Round(1000.0D / framesPerSecond) * 2;            m_frameMilliseconds = new int[framesPerSecond];             for (int frameIndex = 0; frameIndex < framesPerSecond; frameIndex++)            {                m_frameMilliseconds[frameIndex] = (int)(1.0D / framesPerSecond * (frameIndex * 1000.0D));            }             // Start high resolution timer on a separate thread so the start            // time can synchronized to the top of the millisecond            ThreadPool.QueueUserWorkItem(SynchronizeInputTimer);        }         /// <summary>        /// Releases the unmanaged resources before the <see cref="PrecisionInputTimer"/> object is reclaimed by <see cref="GC"/>.        /// </summary>        ~PrecisionInputTimer()        {            Dispose(false);        }         #endregion         #region [ Properties ]         /// <summary>        /// Gets frames per second for this <see cref="PrecisionInputTimer"/>.        /// </summary>        public int FramesPerSecond        {            get            {                return m_framesPerSecond;            }        }         /// <summary>        /// Gets array of frame millisecond times for this <see cref="PrecisionInputTimer"/>.        /// </summary>        public int[] FrameMilliseconds        {            get            {                return m_frameMilliseconds;            }        }         /// <summary>        /// Gets reference count for this <see cref="PrecisionInputTimer"/>.        /// </summary>        public int ReferenceCount        {            get            {                return m_referenceCount;            }        }         /// <summary>        /// Gets number of resynchronizations that have occurred for this <see cref="PrecisionInputTimer"/>.        /// </summary>        public long Resynchronizations        {            get            {                return m_resynchronizations;            }        }         /// <summary>        /// Gets time of last frame, in ticks.        /// </summary>        public long LastFrameTime        {            get            {                return m_lastFrameTime;            }        }         /// <summary>        /// Gets a reference to the frame wait handle.        /// </summary>        public ManualResetEventSlim FrameWaitHandle        {            get            {                if (m_useWaitHandleA)                    return m_frameWaitHandleA;                 return m_frameWaitHandleB;            }        }         /// <summary>        /// Gets or sets function used to handle exceptions.        /// </summary>        public Action<Exception> ExceptionHandler        {            get            {                return m_exceptionHandler;            }            set            {                m_exceptionHandler = value;            }        }         #endregion         #region [ Methods ]         /// <summary>        /// Releases all the resources used by the <see cref="PrecisionInputTimer"/> object.        /// </summary>        public void Dispose()        {            Dispose(true);            GC.SuppressFinalize(this);        }         /// <summary>        /// Releases the unmanaged resources used by the <see cref="PrecisionInputTimer"/> object and optionally releases the managed resources.        /// </summary>        /// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>        private void Dispose(bool disposing)        {            if (!m_disposed)            {                try                {                    if (disposing)                    {                        if (m_timer != null)                        {                            m_timer.Tick -= m_timer_Tick;                            m_timer.Dispose();                        }                        m_timer = null;                         if (m_frameWaitHandleA != null)                        {                            m_frameWaitHandleA.Set();                            m_frameWaitHandleA.Dispose();                        }                        m_frameWaitHandleA = null;                         if (m_frameWaitHandleB != null)                        {                            m_frameWaitHandleB.Set();                            m_frameWaitHandleB.Dispose();                        }                        m_frameWaitHandleB = null;                    }                }                finally                {                    m_disposed = true;  // Prevent duplicate dispose.                }            }        }         /// <summary>        /// Adds a reference to this <see cref="PrecisionInputTimer"/>.        /// </summary>        public void AddReference()        {            m_referenceCount++;        }         /// <summary>        /// Removes a reference to this <see cref="PrecisionInputTimer"/>.        /// </summary>        public void RemoveReference()        {            m_referenceCount--;        }         // This timer function is called every millisecond so that frames can be published at the exact desired time         private void m_timer_Tick(object sender, EventArgs e)        {            // Slower systems or systems under stress may have trouble keeping up with a 1-ms timer, so            // we only process this code if it's not already processing...            bool locked = false;             try            {                m_timerTickLock.TryEnter(2, ref locked);                 if (locked)                {                    DateTime now = PrecisionTimer.UtcNow;                    int frameMilliseconds, milliseconds = now.Millisecond;                    long ticks = now.Ticks;                    bool releaseTimer = false, resync = false;                     // Make sure current time is reasonably close to current frame index                    if (Math.Abs(milliseconds - m_frameMilliseconds[m_lastFrameIndex]) > m_frameWindowSize)                        m_lastFrameIndex = 0;                     // See if it is time to publish                    for (int frameIndex = m_lastFrameIndex; frameIndex < m_frameMilliseconds.Length; frameIndex++)                    {                        frameMilliseconds = m_frameMilliseconds[frameIndex];                         if (frameMilliseconds == milliseconds)                        {                            // See if system skipped a publication window                            if (m_lastFrameIndex != frameIndex)                            {                                // We monitor for missed windows in quick succession (within 1.5 seconds)                                if (ticks - m_lastMissedWindowTime > 15000000L)                                {                                    // Threshold has passed since last missed window, so we reset counters                                    m_lastMissedWindowTime = ticks;                                    m_missedPublicationWindows = 0;                                }                                 m_missedPublicationWindows++;                                 // If the system is starting to skip publications it could need resynchronization,                                // so in this case we restart the high-resolution timer to get the timer started                                // closer to the top of the millisecond                                resync = (m_missedPublicationWindows > 4);                            }                             // Prepare index for next check, time moving forward                            m_lastFrameIndex = frameIndex + 1;                             if (m_lastFrameIndex >= m_frameMilliseconds.Length)                                m_lastFrameIndex = 0;                             if (resync)                            {                                if (m_timer != null)                                {                                    m_timer.Stop();                                    ThreadPool.QueueUserWorkItem(SynchronizeInputTimer);                                    m_resynchronizations++;                                }                            }                             releaseTimer = true;                            break;                        }                        else if (frameMilliseconds > milliseconds)                        {                            // Time has yet to pass, wait till the next tick                            break;                        }                    }                     if (releaseTimer)                    {                        // Baseline timestamp to the top of the millisecond for frame publication                        m_lastFrameTime = ticks - ticks % Ticks.PerMillisecond;                         // Pulse all waiting threads toggling between ready handles                        if (m_useWaitHandleA)                        {                            m_frameWaitHandleB.Reset();                            m_useWaitHandleA = false;                            m_frameWaitHandleA.Set();                        }                        else                        {                            m_frameWaitHandleA.Reset();                            m_useWaitHandleA = true;                            m_frameWaitHandleB.Set();                        }                    }                }            }            catch (Exception ex)            {                ExceptionHandler(new InvalidOperationException("Exception thrown by precision input timer: " + ex.Message, ex));            }            finally            {                if (locked)                    m_timerTickLock.Exit();            }        }         private void SynchronizeInputTimer(object state)        {            // Start timer at as close to the top of the millisecond as possible             bool repeat = true;            long last = 0, next;             while (repeat)            {                next = PrecisionTimer.UtcNow.Ticks % Ticks.PerMillisecond % 1000;                repeat = (next > last);                last = next;            }             m_lastMissedWindowTime = 0;            m_missedPublicationWindows = 0;             if (m_timer != null)                m_timer.Start();        }         #endregion         #region [ Static ]         // Static Fields        private static readonly Dictionary<int, PrecisionInputTimer> s_inputTimers = new Dictionary<int, PrecisionInputTimer>();         // Static Methods          public static PrecisionInputTimer Attach(int framesPerSecond)        {            return Attach(framesPerSecond, null);        }                /// <summary>        /// Attach to a <see cref="PrecisionInputTimer"/> for the specified <paramref name="framesPerSecond"/>.        /// </summary>        /// <param name="framesPerSecond">Desired frames per second for the input timer.</param>        /// <param name="exceptionHandler">Optional delegate to handle exception reporting from the timer.</param>                /// /// <returns>A <see cref="PrecisionInputTimer"/> that can be used for the specified <paramref name="framesPerSecond"/>.</returns>        public static PrecisionInputTimer Attach(int framesPerSecond, Action<Exception> exceptionHandler)        {            PrecisionInputTimer timer;             lock (s_inputTimers)            {                // Get static input timer for given frames per second creating it if needed                if (!s_inputTimers.TryGetValue(framesPerSecond, out timer))                {                    try                    {                        // Create a new precision input timer                        timer = new PrecisionInputTimer(framesPerSecond);                        timer.ExceptionHandler = exceptionHandler;                         // Add timer state for given rate to static collection                        s_inputTimers.Add(framesPerSecond, timer);                    }                    catch (Exception ex)                    {                        // Process exception for logging                        if ((object)exceptionHandler != null)                            exceptionHandler(new InvalidOperationException("Failed to create precision input timer due to exception: " + ex.Message, ex));                        else                            throw;                    }                }                 // Increment reference count for input timer at given frame rate                timer.AddReference();            }             return timer;        }         /// <summary>        /// Detatch from the <see cref="PrecisionInputTimer"/>.        /// </summary>        /// <param name="timer">Timer instance to detach from.</param>        /// <remarks>        /// Timer reference will be set to <c>null</c> after detatch.        /// </remarks>        public static void Detach(ref PrecisionInputTimer timer)        {            if ((object)timer != null)            {                lock (s_inputTimers)                {                    // Verify static frame rate timer for given frames per second exists                    if (s_inputTimers.ContainsKey(timer.FramesPerSecond))                    {                        // Decrement reference count                        timer.RemoveReference();                         // If timer is no longer being referenced we stop it and remove it from static collection                        if (timer.ReferenceCount == 0)                        {                            timer.Dispose();                            s_inputTimers.Remove(timer.FramesPerSecond);                        }                    }                }            }             timer = null;        }         #endregion    }}