Implement timer for Apple

Add support for timer based on GCD

Author: arturl

Release/include/pplx/pplxlinux.h

@@ -41,6 +41,7 @@
 
 #if defined(__APPLE__)
 #include "compat/apple_compat.h"
+#include <dispatch/dispatch.h>
 #else
 #include "compat/linux_compat.h"
 #include "boost/thread/mutex.hpp"
@@ -97,8 +98,8 @@ namespace platform
 
         void set()
         {
-			std::lock_guard<std::mutex> lock(_lock);
-			_signaled = true;
+            std::lock_guard<std::mutex> lock(_lock);
+            _signaled = true;
             _condition.notify_all();
         }
 
@@ -248,14 +249,13 @@ namespace platform
     };
 
     class linux_timer;
+    class apple_timer;
 
     class timer_impl
     {
     public:
         timer_impl()
-#if !defined(__APPLE__)
         : m_timerImpl(nullptr)
-#endif
         {
         }
 
@@ -264,8 +264,10 @@ namespace platform
         _PPLXIMP void start(unsigned int ms, bool repeat, TaskProc_t userFunc, _In_ void * context);
         _PPLXIMP void stop(bool waitForCallbacks);
 
-#if !defined(__APPLE__)
     private:
+#if defined(__APPLE__)
+        apple_timer * m_timerImpl;
+#else
         linux_timer * m_timerImpl;
 #endif
     };

Release/src/pplx/apple/pplxapple.cpp

@@ -66,25 +66,142 @@ namespace details {
     {
     }
 
-    timer_impl::~timer_impl()
+    class apple_timer
     {
-    }    
+        struct callback_finisher
+        {
+            apple_timer * m_timer;
+            callback_finisher(apple_timer *timer) : m_timer(timer)
+            {
+                m_timer->_in_callback = true;
+            }
+            ~callback_finisher()
+            {
+                m_timer->_in_callback = false;
+            }
+        };
 
-    void timer_impl::start(unsigned int ms, bool repeating, TaskProc_t proc, void * context)
-    {
-        if (repeating)
+    private:
+        bool _repeat;
+        dispatch_time_t _nextPopTime;
+        TaskProc_t _proc;
+        void * _context;
+        std::atomic_int _callbacks_pending;
+        std::atomic_bool _orphan;
+        pplx::extensibility::event_t _completed;
+        std::atomic_bool _stop_requested;
+        std::atomic_bool _in_callback; // support reentrancy
+
+        static void timer_callback(void * context)
         {
-            throw std::logic_error("PPLX repeating timer is not supported on the Apple platform.");
+            apple_timer * ptimer = (apple_timer*)context;
+            callback_finisher _(ptimer);
+            ptimer->_callbacks_pending--;
+            if(ptimer->_repeat)
+            {
+                if(ptimer->_stop_requested && ptimer->_callbacks_pending == 0) {
+                    ptimer->finalize_callback();
+                }
+                else{
+                    ptimer->_proc(ptimer->_context);
+                    ptimer->dispatch_repeated_worker();
+                }
+            }
+            else
+            {
+                ptimer->_proc(ptimer->_context);
+                ptimer->finalize_callback();
+            }
+        }
+    
+        void finalize_callback()
+        {
+            if(_orphan)
+            {
+                delete this;
+            }
+            else
+            {            
+                _completed.set();
+            }
         }
-
-        int64_t deltaNanoseconds = ms * NSEC_PER_MSEC;
-        dispatch_time_t dispatchTime = dispatch_time(DISPATCH_TIME_NOW, deltaNanoseconds);
 
-        dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
-        dispatch_after_f(dispatchTime, queue, context, proc);
+        void dispatch_repeated_worker()
+        {
+            _callbacks_pending++;
+            dispatch_after_f(_nextPopTime, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), this, timer_callback);
+        }
+ 
+        void dispatch_repeated(int64_t intervalInNanoSeconds)
+        {
+            dispatch_time_t firstPopTime = dispatch_time(DISPATCH_TIME_NOW, intervalInNanoSeconds);
+        
+            _nextPopTime = dispatch_time(firstPopTime, intervalInNanoSeconds);
+        
+            dispatch_repeated_worker();
+        }
+
+    public:
+        apple_timer(unsigned int ms, bool repeating, TaskProc_t proc, void * context) :
+            _repeat(repeating)
+            , _proc(proc)
+            , _context(context)
+            ,_callbacks_pending(0)
+            ,_orphan(false)
+            ,_stop_requested(false)
+            ,_in_callback(false)
+        {
+            int64_t deltaNanoseconds = ms * NSEC_PER_MSEC;
+            _completed.reset();
+    
+            if (repeating)
+            {
+                dispatch_repeated(deltaNanoseconds);
+            }
+            else
+            {
+                dispatch_time_t dispatchTime = dispatch_time(DISPATCH_TIME_NOW, deltaNanoseconds);
+                dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+                _callbacks_pending++;
+                dispatch_after_f(dispatchTime, queue, this, timer_callback);
+            }
+        }
+
+        void stop(bool wait)
+        {
+            _stop_requested = true;
+            if(_in_callback)
+            {
+                // this timer will clean up itself when it's done executing the callback
+                _orphan = true;
+            }
+            else
+            {
+                if (wait || !_repeat)
+                {
+                    _completed.wait();
+                }
+                delete this;
+            }
+        }
+    };
+
+    _PPLXIMP void timer_impl::start(unsigned int ms, bool repeating, TaskProc_t proc, void * context)
+    {
+        _ASSERTE(m_timerImpl == nullptr);
+        m_timerImpl = new apple_timer(ms, repeating, proc, context); 
+    }
+
+    _PPLXIMP void timer_impl::stop(bool waitForCallbacks)
+    {
+        if( m_timerImpl != nullptr )
+        {
+            m_timerImpl->stop(waitForCallbacks);
+            m_timerImpl = nullptr;
+        }
     }
 
-    void timer_impl::stop(bool /* waitForCallbacks */)
+    timer_impl::~timer_impl()
     {
     }
 

Release/tests/Functional/pplx/pplx_test/pplx_op_test.cpp

@@ -362,7 +362,7 @@ struct TimerCallbackContext
     }
 };
 
-TEST(timer_oneshot, "Ignore:Apple", "Not yet implemented")
+TEST(timer_oneshot)
 {
     TimerCallbackContext context;
     context.count = 1234;
@@ -374,7 +374,7 @@ TEST(timer_oneshot, "Ignore:Apple", "Not yet implemented")
     context.simpleTimer.stop(true);
 }
 
-TEST(timer_start_stop, "Ignore:Apple", "Not yet implemented")
+TEST(timer_start_stop)
 {
     TimerCallbackContext context;
     context.count = 1234;
@@ -391,7 +391,7 @@ TEST(timer_start_stop, "Ignore:Apple", "Not yet implemented")
     context.simpleTimer.stop(false);
 }
 
-TEST(timer_repeat, "Ignore:Apple", "Not yet implemented")
+TEST(timer_repeat)
 {
     TimerCallbackContext context;
     context.count = 10;