Introduce Semaphore class & fix deadlock in PooledThreadExecutor (#97)

The problem is calling |wait| after a |notify_all| blocks the thread.
The semaphore solves this problem by not blocking if we have enough
"credits" that have been released.

Author: marcomagdy

aws-cpp-sdk-core/include/aws/core/utils/threading/Executor.h

@@ -22,7 +22,7 @@
 #include <functional>
 #include <future>
 #include <mutex>
-#include <condition_variable>
+#include <aws/core/utils/threading/Semaphore.h>
 
 namespace Aws
 {
@@ -99,8 +99,7 @@ namespace Aws
             private:
                 Aws::Queue<std::function<void()>*> m_tasks;
                 std::mutex m_queueLock;
-                std::mutex m_syncPointLock;
-                std::condition_variable m_syncPoint;
+                Aws::Utils::Threading::Semaphore m_sync;
                 Aws::Vector<ThreadTask*> m_threadTaskHandles;
                 size_t m_poolSize;
                 OverflowPolicy m_overflowPolicy;

aws-cpp-sdk-core/include/aws/core/utils/threading/Semaphore.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2010-2017 Amazon.com, Inc. or its affiliates. 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.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+#pragma once
+
+#include <aws/core/Core_EXPORTS.h>
+#include <mutex>
+#include <condition_variable>
+
+namespace Aws
+{
+    namespace Utils
+    {
+        namespace Threading
+        {
+            class AWS_CORE_API Semaphore {
+                public:
+                    /**
+                     * Initializes a new instance of Semaphore class specifying the initial number of entries and 
+                     * the maximum number of concurrent entries.
+                     */
+                    Semaphore(size_t initialCount, size_t maxCount);
+                    /**
+                     * Blocks the current thread until it receives a signal.
+                     */
+                    void WaitOne();
+                    /**
+                     * Exits the semaphore once.
+                     */
+                    void Release();
+                    /**
+                     * Exit the semaphore up to the maximum number of entries available.
+                     */
+                    void ReleaseAll();
+                private:
+                    size_t m_count;
+                    const size_t m_maxCount;
+                    std::mutex m_mutex;
+                    std::condition_variable m_syncPoint;
+            };
+        }
+    }
+}

aws-cpp-sdk-core/source/utils/threading/Executor.cpp

@@ -29,7 +29,7 @@ bool DefaultExecutor::SubmitToThread(std::function<void()>&&  fx)
 }
 
 PooledThreadExecutor::PooledThreadExecutor(size_t poolSize, OverflowPolicy overflowPolicy) :
-    m_poolSize(poolSize), m_overflowPolicy(overflowPolicy)
+    m_sync(0, poolSize), m_poolSize(poolSize), m_overflowPolicy(overflowPolicy)
 {
     for (size_t index = 0; index < m_poolSize; ++index)
     {
@@ -41,10 +41,10 @@ PooledThreadExecutor::~PooledThreadExecutor()
 {
     for(auto threadTask : m_threadTaskHandles)
     {
-        threadTask->StopProcessingWork();       
+        threadTask->StopProcessingWork();
     }
 
-    m_syncPoint.notify_all();
+    m_sync.ReleaseAll();
 
     for (auto threadTask : m_threadTaskHandles)
     {
@@ -80,7 +80,7 @@ bool PooledThreadExecutor::SubmitToThread(std::function<void()>&& fn)
         m_tasks.push(fnCpy);
     }
 
-    m_syncPoint.notify_one();
+    m_sync.Release();
 
     return true;
 }

aws-cpp-sdk-core/source/utils/threading/Semaphore.cpp

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2010-2017 Amazon.com, Inc. or its affiliates. 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.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+#include <aws/core/utils/threading/Semaphore.h>
+#include <algorithm>
+
+using namespace Aws::Utils::Threading;
+
+Semaphore::Semaphore(size_t initialCount, size_t maxCount)
+    : m_count(initialCount), m_maxCount(maxCount)
+{
+}
+
+void Semaphore::WaitOne()
+{
+    std::unique_lock<std::mutex> locker(m_mutex);
+    if(0 == m_count)
+    {
+        m_syncPoint.wait(locker, [this] { return m_count > 0; });
+    }
+    --m_count;
+}
+
+void Semaphore::Release()
+{
+    std::lock_guard<std::mutex> locker(m_mutex);
+    m_count = std::min(m_maxCount, m_count + 1);
+    m_syncPoint.notify_one();
+}
+
+void Semaphore::ReleaseAll()
+{    
+    std::lock_guard<std::mutex> locker(m_mutex);
+    m_count = m_maxCount;
+    m_syncPoint.notify_all();
+}
+

aws-cpp-sdk-core/source/utils/threading/ThreadTask.cpp

@@ -43,10 +43,9 @@ void ThreadTask::MainTaskRunner()
             }
         }
 
-        std::unique_lock<std::mutex> locker(m_executor.m_syncPointLock);
         if(m_continue)
         {
-            m_executor.m_syncPoint.wait(locker);    
+            m_executor.m_sync.WaitOne();
         }
     }
 }