chore: ThreadPool

Author: vinniefalco

include/mrdox/Support/Path.hpp

@@ -71,6 +71,13 @@ forEachFile(
 
 namespace files {
 
+/** Return true if pathName is absolute.
+*/
+MRDOX_DECL
+bool
+isAbsolute(
+    std::string_view pathName) noexcept;
+
 /** Return true if pathName ends in a separator.
 */
 MRDOX_DECL

include/mrdox/Support/ParallelFor.hpp renamed to include/mrdox/Support/Thread.hpp

@@ -9,29 +9,112 @@
 // Official repository: https://github.com/cppalliance/mrdox
 //
 
-#ifndef MRDOX_SUPPORT_PARALLELFOR_HPP
-#define MRDOX_SUPPORT_PARALLELFOR_HPP
+#ifndef MRDOX_SUPPORT_THREAD_HPP
+#define MRDOX_SUPPORT_THREAD_HPP
 
 #include <mrdox/Platform.hpp>
 #include <mrdox/Support/Error.hpp>
 #include <iterator>
 #include <mutex>
 #include <thread>
+#include <utility>
 #include <vector>
 
-#include <algorithm>
-
 namespace clang {
 namespace mrdox {
 
+//------------------------------------------------
+
+/** A pool of threads for executing work concurrently.
+*/
+class MRDOX_VISIBLE
+    ThreadPool
+{
+    class Impl;
+
+    struct MRDOX_VISIBLE
+        Work
+    {
+        virtual ~Work() = 0;
+        virtual void operator()() = 0;
+    };
+
+    std::unique_ptr<Impl> impl_;
+
+public:
+    /** Destructor.
+    */
+    MRDOX_DECL
+    ~ThreadPool();
+
+    /** Constructor.
+    */
+    MRDOX_DECL
+    explicit
+    ThreadPool(
+        std::size_t concurrency);
+
+    /** Submit work to be executed.
+
+        The signature of the submitted function
+        object should be `void(void)`.
+    */
+    template<class F>
+    void
+    post(F&& f);
+
+    /** Block until all work has completed.
+    */
+    MRDOX_DECL
+    void
+    wait();
+
+private:
+    MRDOX_DECL void do_post(std::unique_ptr<Work>);
+};
+
+template<class F>
+void
+ThreadPool::
+post(F&& f)
+{
+    if(! impl_)
+    {
+        // no threads
+        f();
+        return;
+    }
+
+    struct WorkImpl : Work
+    {
+        F f;
+
+        ~WorkImpl() = default;
+
+        explicit WorkImpl(F&& f_)
+            : f(std::forward<F>(f_))
+        {
+        }
+
+        void operator()() override
+        {
+            f();
+        }
+    };
+
+    do_post(std::make_unique<WorkImpl>(std::forward<F>(f)));
+}
+
+//------------------------------------------------
+
 /** Visit all elements of a range concurrently.
 */
 template<
     class Elements,
     class Workers,
     class... Args>
 Error
-parallelFor(
+forEach(
     Elements& elements,
     Workers& workers,
     Args&&... args)

source/ConfigImpl.cpp

@@ -77,7 +77,9 @@ construct(
     namespace fs = llvm::sys::fs;
     namespace path = llvm::sys::path;
 
-    workingDir = workingDir_;
+    if(! files::isAbsolute(workingDir_))
+        return Error("path \"{}\" is not absolute", workingDir_);
+    workingDir = files::makeDirsy(files::normalizePath(workingDir_));
     configYaml = configYaml_;
     extraYaml = extraYaml_;
 
@@ -174,14 +176,6 @@ createConfigFromYAML(
     llvm::StringRef configYaml,
     llvm::StringRef extraYaml)
 {
-#if 0
-    namespace fs = llvm::sys::fs;
-    namespace path = llvm::sys::path;
-
-    SmallPathString temp(workingDir);
-    path::remove_dots(temp, true, path::Style::native);
-#endif
-
     auto config = std::make_shared<ConfigImpl>();
     if(auto err = config->construct(workingDir, configYaml, extraYaml))
         return err;

source/Support/Path.cpp

@@ -80,11 +80,21 @@ forEachFile(
 
 namespace files {
 
+bool
+isAbsolute(
+    std::string_view pathName) noexcept
+{
+    namespace path = llvm::sys::path;
+
+    return path::is_absolute(pathName);
+}
+
 bool
 isDirsy(
     std::string_view pathName) noexcept
 {
     namespace path = llvm::sys::path;
+
     if(pathName.empty())
         return false;
     if(! path::is_separator(

source/Support/Thread.cpp

@@ -0,0 +1,144 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdox
+//
+
+#include <mrdox/Support/Thread.hpp>
+#include <condition_variable>
+#include <cstdlib>
+#include <deque>
+#include <iterator>
+#include <memory>
+#include <mutex>
+#include <thread>
+#include <vector>
+
+namespace clang {
+namespace mrdox {
+
+ThreadPool::Work::~Work() = default;
+
+class ThreadPool::Impl
+{
+    std::vector<std::thread> threads_;
+    std::condition_variable work_cv_;
+    std::condition_variable join_cv_;
+    std::mutex mutex_;
+
+    std::deque<std::unique_ptr<Work>> work_;
+    std::size_t busy_ = 0;
+    bool destroy_ = false;
+
+    void
+    run()
+    {
+        std::unique_lock<std::mutex> lock(mutex_);
+        ++busy_;
+        for(;;)
+        {
+            --busy_;
+            work_cv_.wait(lock,
+                [&]
+                {
+                    return destroy_ || ! work_.empty();
+                });
+            ++busy_;
+            if(! work_.empty())
+            {
+                std::unique_ptr<Work> work =
+                    std::move(work_.front());
+                work_.pop_front();
+                lock.unlock();
+                (*work)();
+                continue;
+            }
+            if(destroy_)
+                break;
+        }
+        --busy_;
+        join_cv_.notify_all();
+    }
+
+public:
+    explicit
+    Impl(std::size_t concurrency)
+    {
+        threads_.resize(concurrency);
+        for(auto& t : threads_)
+            t = std::thread(&Impl::run, this);
+    }
+
+    ~Impl()
+    {
+        for(auto& t : threads_)
+            t.join();
+    }
+
+    void destroy() noexcept
+    {
+        std::unique_lock<std::mutex> lock(mutex_);
+        destroy_ = true;
+        work_cv_.notify_all();
+    }
+
+    void post(std::unique_ptr<Work> work)
+    {
+        std::unique_lock<std::mutex> lock(mutex_);
+        work_.emplace_back(std::move(work));
+        work_cv_.notify_one();
+    }
+
+    void wait()
+    {
+        std::unique_lock<std::mutex> lock(mutex_);
+        join_cv_.wait(lock,
+            [&]
+            {
+                return busy_ == 0;
+            });
+    }
+};
+
+ThreadPool::
+~ThreadPool()
+{
+    if(impl_)
+    {
+        wait();
+        impl_->destroy();
+    }
+}
+
+ThreadPool::
+ThreadPool(
+    std::size_t concurrency)
+{
+    if( concurrency == 0)
+        concurrency = std::thread::hardware_concurrency();
+    if(concurrency > 1)
+        impl_ = std::make_unique<Impl>(concurrency);
+}
+
+void
+ThreadPool::
+wait()
+{
+    if( impl_)
+        impl_->wait();
+}
+
+void
+ThreadPool::
+do_post(
+    std::unique_ptr<Work> work)
+{
+    impl_->post(std::move(work));
+}
+
+} // mrdox
+} // clang

source/TestAction.cpp

@@ -17,6 +17,7 @@
 #include <mrdox/Config.hpp>
 #include <mrdox/Generators.hpp>
 #include <mrdox/Support/Report.hpp>
+#include <mrdox/Support/Thread.hpp>
 #include <clang/Tooling/StandaloneExecution.h>
 #include <llvm/Support/CommandLine.h>
 #include <llvm/Support/FileSystem.h>
@@ -73,10 +74,9 @@ struct Results
 
 class TestRunner
 {
+    ThreadPool threadPool_;
     Results& results_;
     std::string extraYaml_;
-    std::shared_ptr<Config const> config_;
-    Config::WorkGroup wg_;
     llvm::ErrorOr<std::string> diff_;
     Generator const* xmlGen_;
     Generator const* adocGen_;
@@ -120,17 +120,9 @@ TestRunner::
 TestRunner(
     Results& results,
     llvm::StringRef extraYaml)
-    : results_(results)
+    : threadPool_(1)
+    , results_(results)
     , extraYaml_(extraYaml)
-    , config_([&extraYaml]
-        {
-            std::error_code ec;
-            auto config = loadConfigString(
-                "", extraYaml.str());
-            Assert(config);
-            return *config;
-        }())
-    , wg_(config_.get())
     , diff_(llvm::sys::findProgramByName("diff"))
     , xmlGen_(getGenerators().find("xml"))
     , adocGen_(getGenerators().find("adoc"))
@@ -342,7 +334,7 @@ handleDir(
             iter->type() == fs::file_type::regular_file &&
             path::extension(iter->path()).equals_insensitive(".cpp"))
         {
-            wg_.post(
+            threadPool_.post(
                 [this, config, filePath = SmallString(iter->path())]
                 {
                     handleFile(filePath, config).operator bool();
@@ -388,7 +380,7 @@ checkPath(
 
         auto config = makeConfig(workingDir);
         auto err = handleFile(inputPath, config);
-        wg_.wait();
+        threadPool_.wait();
         return err;
     }
 
@@ -398,7 +390,7 @@ checkPath(
         SmallString dirPath(inputPath);
         path::remove_dots(dirPath, true);
         auto err = handleDir(dirPath);
-        wg_.wait();
+        threadPool_.wait();
         return err;
     }