Iteration 2 on global c/d-tor fix

Author: ras0219-msft

Release/include/pplx/pplxlinux.h

@@ -245,8 +245,6 @@ namespace platform
     {
     public:
         _PPLXIMP virtual void schedule( TaskProc_t proc, _In_ void* param);
-        
-        virtual ~apple_scheduler();
     };
 #else
     class linux_scheduler : public pplx::scheduler_interface
@@ -255,7 +253,7 @@ namespace platform
         _PPLXIMP virtual void schedule( TaskProc_t proc, _In_ void* param);
     };
 #endif
-    
+
 } // namespace details
 
 /// <summary>

Release/src/pplx/apple/pplxapple.cpp

@@ -31,40 +31,36 @@
 #include "stdafx.h"
 #include "pplx/pplx.h"
 
-// DEVNOTE: 
+// DEVNOTE:
 // The use of mutexes is suboptimal for synchronization of task execution.
 // Given that scheduler implementations should use GCD queues, there are potentially better mechanisms available to coordinate tasks (such as dispatch groups).
 
 namespace pplx
 {
 
 namespace details {
-    
+
     namespace platform
     {
         _PPLXIMP long GetCurrentThreadId()
         {
             pthread_t threadId = pthread_self();
             return (long)threadId;
         }
-        
+
         void YieldExecution()
         {
             sleep(0);
         }
-        
+
     } // namespace platform
-    
+
     void apple_scheduler::schedule( TaskProc_t proc, void* param)
     {
         dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
         dispatch_async_f(queue, param, proc);
     }
-    
-    apple_scheduler::~apple_scheduler()
-    {
-    }
-    
+
 } // namespace details
-    
-} // pplx
+
+} // pplx

Release/src/pplx/pplx.cpp

@@ -1,12 +1,12 @@
 /***
 * ==++==
 *
-* Copyright (c) Microsoft Corporation. All rights reserved. 
+* Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
-* 
+*
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -33,13 +33,13 @@
 
 #include "pplx/pplx.h"
 
-// Disable false alarm code analyze warning 
+// Disable false alarm code analyze warning
 #pragma warning (disable : 26165 26110)
-namespace pplx 
+namespace pplx
 {
 
 
-namespace details 
+namespace details
 {
     /// <summary>
     /// Spin lock to allow for locks to be used in global scope
@@ -57,7 +57,7 @@ namespace details
         {
             if ( details::atomic_compare_exchange(_M_lock, 1l, 0l) != 0l )
             {
-                do 
+                do
                 {
                     pplx::details::platform::YieldExecution();
 
@@ -78,33 +78,80 @@ namespace details
     typedef ::pplx::scoped_lock<_Spin_lock> _Scoped_spin_lock;
 } // namespace details
 
-static std::shared_ptr<pplx::scheduler_interface> *_M_Scheduler;
-static pplx::details::_Spin_lock _M_SpinLock;
+static struct _pplx_g_sched_t {
+    typedef std::shared_ptr<pplx::scheduler_interface> sched_ptr;
 
-_PPLXIMP std::shared_ptr<pplx::scheduler_interface> __cdecl get_ambient_scheduler()
-{
-    if ( !_M_Scheduler)
+    _pplx_g_sched_t()
+    {
+        m_state = post_ctor;
+    }
+
+    ~_pplx_g_sched_t()
+    {
+        m_state = post_dtor;
+    }
+
+    sched_ptr get_scheduler()
     {
-        ::pplx::details::_Scoped_spin_lock _Lock(_M_SpinLock);
-        if (!_M_Scheduler)
+        switch (m_state)
         {
-            _M_Scheduler = new std::shared_ptr<pplx::scheduler_interface>(std::make_shared< ::pplx::default_scheduler_t>());
+        case post_ctor:
+            // This is the 99.9% case.
+
+            if (!m_scheduler)
+            {
+                ::pplx::details::_Scoped_spin_lock lock(m_spinlock);
+                if (!m_scheduler)
+                {
+                    m_scheduler = std::make_shared< ::pplx::default_scheduler_t>();
+                }
+            }
+
+            return m_scheduler;
+        case pre_ctor:
+        case post_dtor:
+        default:
+            // This case means the global m_scheduler is not available.
+            // We spin off an individual scheduler instead.
+            return std::make_shared< ::pplx::default_scheduler_t>();
         }
     }
 
-    return *_M_Scheduler;
-}
+    void set_scheduler(sched_ptr scheduler)
+    {
+        if (m_state == pre_ctor || m_state == post_dtor) {
+            throw invalid_operation("Scheduler cannot be initialized now");
+        }
 
-_PPLXIMP void __cdecl set_ambient_scheduler(std::shared_ptr<pplx::scheduler_interface> _Scheduler)
-{
-    ::pplx::details::_Scoped_spin_lock _Lock(_M_SpinLock);
+        ::pplx::details::_Scoped_spin_lock lock(m_spinlock);
 
-    if (_M_Scheduler != nullptr)
-    {
-        throw invalid_operation("Scheduler is already initialized");
+        if (m_scheduler != nullptr)
+        {
+            throw invalid_operation("Scheduler is already initialized");
+        }
+
+        m_scheduler = std::move(scheduler);
     }
 
-    _M_Scheduler = new std::shared_ptr<pplx::scheduler_interface>(std::move(_Scheduler));
+    enum {
+        pre_ctor = 0,
+        post_ctor = 1,
+        post_dtor = 2
+    } m_state;
+
+private:
+    pplx::details::_Spin_lock m_spinlock;
+    sched_ptr m_scheduler;
+} _pplx_g_sched;
+
+_PPLXIMP std::shared_ptr<pplx::scheduler_interface> __cdecl get_ambient_scheduler()
+{
+    return _pplx_g_sched.get_scheduler();
+}
+
+_PPLXIMP void __cdecl set_ambient_scheduler(std::shared_ptr<pplx::scheduler_interface> _Scheduler)
+{
+    _pplx_g_sched.set_scheduler(std::move(_Scheduler));
 }
 
 } // namespace pplx