pytq-cxx 1.0.2__tar.gz

pytq_cxx-1.0.2/MANIFEST.in

@@ -0,0 +1,4 @@
+include _yatq/traits.h
+recursive-include _yatq/include *.h
+recursive-include setup_helpers *.cmake
+global-exclude */__pycache__/*

pytq_cxx-1.0.2/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.1
+Name: pytq-cxx
+Version: 1.0.2
+Summary: single-threaded timer demultiplexer backed by C++ implementation
+Author-email: Nikita Vaganov <nikita.e.vaganov@gmail.com>
+Project-URL: Homepage, https://github.com/vaganov/yatq
+Project-URL: Bug Tracker, https://github.com/vaganov/yatq/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# pytq-cxx
+**pytq-cxx** is a _python_ wrapper for **yatq** -- a _C++_ template library. For the documentation and examples please
+see [yatq homepage](https://github.com/vaganov/yatq)
+
+**NB:** This package has nothing to do with [pytq package](https://pypi.org/project/pytq)
+
+**NB:** Module name is, however, **pytq**
+
+    from pytq import ThreadPool, TimerQueue, AwaitableFuture

pytq_cxx-1.0.2/README_pytq.md

@@ -0,0 +1,9 @@
+# pytq-cxx
+**pytq-cxx** is a _python_ wrapper for **yatq** -- a _C++_ template library. For the documentation and examples please
+see [yatq homepage](https://github.com/vaganov/yatq)
+
+**NB:** This package has nothing to do with [pytq package](https://pypi.org/project/pytq)
+
+**NB:** Module name is, however, **pytq**
+
+    from pytq import ThreadPool, TimerQueue, AwaitableFuture

pytq_cxx-1.0.2/_yatq/bind.cpp

@@ -0,0 +1,72 @@
+#define PYBIND11_DETAILED_ERROR_MESSAGES
+#include <pybind11/pybind11.h>
+#include <pybind11/chrono.h>
+#include <pybind11/functional.h>
+
+#ifndef YATQ_DISABLE_FUTURES
+#define BOOST_THREAD_PROVIDES_FUTURE
+#define BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION
+#include <boost/thread/future.hpp>
+#endif
+
+#include "yatq/thread_pool.h"
+#include "yatq/timer_queue.h"
+#include "yatq/version.h"
+
+#include "traits.h"
+
+namespace py = pybind11;
+
+using result_type = py::object;
+using Future = boost::future<result_type>;
+using Executable = std::function<result_type(void)>;
+using ThreadPool = yatq::ThreadPool<Executable>;
+using TimerQueue = yatq::TimerQueue<ThreadPool>;
+
+PYBIND11_MODULE(_yatq, m) {
+#ifndef YATQ_DISABLE_FUTURES
+    auto boost_submodule = m.def_submodule("boost");
+    py::class_<Future>(boost_submodule, "future")
+        .def("get", &Future::get, py::call_guard<py::gil_scoped_release>())
+        .def("wait", &Future::wait, py::call_guard<py::gil_scoped_release>())
+        .def("is_ready", py::overload_cast<>(&Future::is_ready, py::const_));
+#endif
+
+#ifndef YATQ_DISABLE_PTHREAD
+    auto utils_submodule = m.def_submodule("utils");
+    py::enum_<yatq::utils::priority_t>(utils_submodule, "priority_t")
+        .value("min_priority", yatq::utils::min_priority)
+        .value("max_priority", yatq::utils::max_priority)
+        .export_values();
+#endif
+
+    py::class_<ThreadPool>(m, "ThreadPool")
+        .def(py::init<>())
+        .def("start", &ThreadPool::start, py::arg("num_threads"))
+        .def("stop", &ThreadPool::stop)
+        .def("execute", &ThreadPool::execute, py::arg("job"));
+
+    py::class_<TimerQueue::TimerHandle>(m, "TimerHandle")
+        .def_readwrite("uid", &TimerQueue::TimerHandle::uid)
+        .def_readwrite("deadline", &TimerQueue::TimerHandle::deadline)
+#ifndef YATQ_DISABLE_FUTURES
+        .def_readonly("result", &TimerQueue::TimerHandle::result)
+#endif
+        ;
+
+    py::class_<TimerQueue>(m, "TimerQueue")
+        .def(py::init<ThreadPool*>(), py::arg("executor"))
+        .def("start", py::overload_cast<>(&TimerQueue::start))
+#ifndef YATQ_DISABLE_PTHREAD
+        .def("start", py::overload_cast<int, yatq::utils::priority_t>(&TimerQueue::start), py::arg("sched_policy"), py::arg("priority") = yatq::utils::max_priority)
+        .def("start", py::overload_cast<int, int>(&TimerQueue::start), py::arg("sched_policy"), py::arg("priority"))
+#endif
+        .def("stop", &TimerQueue::stop)
+        .def("enqueue", &TimerQueue::enqueue, py::arg("deadline"), py::arg("job"))
+        .def("cancel", &TimerQueue::cancel, py::arg("uid"))
+        .def("clear", &TimerQueue::clear)
+        .def("purge", &TimerQueue::purge)
+        .def("in_queue", &TimerQueue::in_queue, py::arg("uid"));
+
+    m.attr("__version__") = YATQ_VERSION;
+}

pytq_cxx-1.0.2/_yatq/include/yatq/internal/concepts.h

@@ -0,0 +1,61 @@
+#ifndef _YATQ_INTERNAL_CONCEPTS_H
+#define _YATQ_INTERNAL_CONCEPTS_H
+
+#include <chrono>
+#include <concepts>
+
+namespace yatq::internal {
+
+// template<typename Clock>
+// concept ClockGeneric = std::chrono::is_clock<Clock>;
+
+// 'std::chrono::is_clock' seems to be not yet implemented for all architectures
+// ok, we only these from 'Clock'
+template<typename Clock>
+concept ClockGeneric = requires (Clock::time_point t1, Clock::time_point t2) {
+    typename Clock::duration;
+    typename Clock::time_point;
+    { Clock::now() } -> std::convertible_to<typename Clock::time_point>;
+    { t1 > t2 } -> std::convertible_to<bool>;
+    { t1 <= t2 } -> std::convertible_to<bool>;
+#ifndef YATQ_DISABLE_LOGGING
+    t1.time_since_epoch().count();
+#endif
+};
+
+template<typename Executable>
+concept ExecutableGeneric = requires {
+    typename Executable::result_type;
+    std::invocable<Executable>;
+    std::movable<Executable>;
+};
+
+#ifndef YATQ_DISABLE_FUTURES
+template<typename Future, typename result_type>
+concept ChainableFutureGeneric = requires(Future future, void (*then) (Future)) {
+    std::movable<Future>;
+    { future.get() } -> std::convertible_to<result_type>;
+    future.then(then);
+};
+#endif
+
+template<typename Executor>
+concept ExecutorGeneric =
+#ifndef YATQ_DISABLE_FUTURES
+        ChainableFutureGeneric<typename Executor::Future, typename Executor::Executable::result_type> &&
+#endif
+        requires(Executor executor, Executor::Executable job) {
+    typename Executor::Executable;
+    typename Executor::Executable::result_type;
+    std::movable<typename Executor::Executable>;
+#ifndef YATQ_DISABLE_FUTURES
+    typename Executor::Future;
+    { executor.execute(job) } -> std::convertible_to<typename Executor::Future>;
+#else
+    executor.execute(job);
+#endif
+};
+
+}
+
+#endif

pytq_cxx-1.0.2/_yatq/include/yatq/internal/log4cxx_proxy.h

@@ -0,0 +1,23 @@
+#ifndef _YATQ_INTERNAL_LOG4CXX_PROXY_H
+#define _YATQ_INTERNAL_LOG4CXX_PROXY_H
+
+#ifndef YATQ_DISABLE_LOGGING
+
+#include <log4cxx/logger.h>
+#include <log4cxx/mdc.h>
+
+#define SET_THREAD_TAG(tag) log4cxx::MDC::put("threadTag", tag)
+
+#else
+
+#define LOG4CXX_TRACE(...)
+#define LOG4CXX_DEBUG(...)
+#define LOG4CXX_INFO(...)
+#define LOG4CXX_WARN(...)
+#define LOG4CXX_ERROR(...)
+
+#define SET_THREAD_TAG(...)
+
+#endif
+
+#endif

pytq_cxx-1.0.2/_yatq/include/yatq/internal/promise_utils.h

@@ -0,0 +1,32 @@
+#ifndef _YATQ_INTERNAL_PROMISE_UTILS_H
+#define _YATQ_INTERNAL_PROMISE_UTILS_H
+
+#include <type_traits>
+
+namespace yatq::internal {
+
+template<typename result_type, typename Job, typename Promise>
+std::enable_if_t<!std::is_void_v<result_type>> run_and_set_value(Job job, Promise promise) {
+    promise.set_value(job());
+}
+
+template<typename result_type, typename Job, typename Promise>
+std::enable_if_t<std::is_void_v<result_type>> run_and_set_value(Job job, Promise promise) {
+    job();
+    promise.set_value();
+}
+
+template<typename result_type, typename Future, typename Promise>
+std::enable_if_t<!std::is_void_v<result_type>> get_and_set_value(Future future, Promise promise) {
+    promise.set_value(future.get());
+}
+
+template<typename result_type, typename Future, typename Promise>
+std::enable_if_t<std::is_void_v<result_type>> get_and_set_value(Future future, Promise promise) {
+    future.get();
+    promise.set_value();
+}
+
+}
+
+#endif

pytq_cxx-1.0.2/_yatq/include/yatq/thread_pool.h

@@ -0,0 +1,156 @@
+#ifndef _YATQ_THREAD_POOL_H
+#define _YATQ_THREAD_POOL_H
+
+#include <condition_variable>
+#include <cstdlib>
+#include <deque>
+#include <functional>
+#include <mutex>
+#include <string>
+#include <thread>
+#include <vector>
+
+#ifndef YATQ_DISABLE_FUTURES
+#define BOOST_THREAD_PROVIDES_FUTURE
+#define BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION
+#include <boost/thread/future.hpp>
+#endif
+
+#include "yatq/internal/concepts.h"
+#include "yatq/internal/promise_utils.h"
+#include "yatq/internal/log4cxx_proxy.h"
+
+namespace yatq {
+
+using internal::ExecutableGeneric;
+
+template<ExecutableGeneric _Executable = std::function<void(void)>>
+class ThreadPool {
+public:
+    using Executable = _Executable;
+    using result_type = Executable::result_type;
+#ifndef YATQ_DISABLE_FUTURES
+    using Future = boost::future<result_type>;
+#endif
+
+private:
+#ifndef YATQ_DISABLE_FUTURES
+    using Promise = boost::promise<result_type>;
+#endif
+
+    typedef struct {
+        Executable job;
+#ifndef YATQ_DISABLE_FUTURES
+        Promise promise;
+#endif
+    } QueueEntry;
+
+    bool _running;
+    std::mutex _lock;
+    std::condition_variable _cond;
+    std::deque<QueueEntry> _queue;
+    std::vector<std::thread> _pool;
+
+public:
+    /**
+     * create thread pool
+     */
+    ThreadPool(): _running(false) {}
+
+    /**
+     * start thread pool
+     * @param num_threads number of threads
+     */
+    void start(std::size_t num_threads) {
+        if (!_running) {
+            _running = true;
+            for (int i = 0; i < num_threads; ++i) {
+                std::string thread_tag = "pool thread #" + std::to_string(i);
+                auto thread = std::thread(&ThreadPool::thread_routine, this, thread_tag);
+                _pool.push_back(std::move(thread));
+            }
+        }
+    }
+
+    /**
+     * stop thread pool and join all the threads
+     */
+    void stop() {
+        if (_running) {
+            _running = false;
+            _cond.notify_all();
+            for (auto&& thread: _pool) {
+                if (thread.joinable()) {
+                    thread.join();
+                }
+            }
+            _pool.clear();
+        }
+    }
+
+    /**
+     * execute job in a thread
+     * @param job job to execute
+     * @return future object. use it to obtain job result
+     */
+#ifndef YATQ_DISABLE_FUTURES
+    Future
+#else
+    void
+#endif
+    execute(Executable job) {
+#ifndef YATQ_DISABLE_FUTURES
+        Promise promise;
+        auto future = promise.get_future();
+#endif
+        {
+            std::lock_guard<std::mutex> guard(_lock);
+            _queue.push_back({
+                std::move(job)
+#ifndef YATQ_DISABLE_FUTURES
+                , std::move(promise)
+#endif
+            });
+        }
+        _cond.notify_one();
+#ifndef YATQ_DISABLE_FUTURES
+        return std::move(future);
+#endif
+    }
+
+private:
+    void thread_routine(const std::string& thread_tag) {
+#ifndef YATQ_DISABLE_LOGGING
+        static auto logger = log4cxx::Logger::getLogger("yatq.thread_pool");
+#endif
+
+        SET_THREAD_TAG(thread_tag);
+        LOG4CXX_INFO(logger, "Start");
+
+        while (_running) {
+            QueueEntry queue_entry;
+            {
+                std::unique_lock<std::mutex> guard(_lock);
+                _cond.wait(guard, [this] () { return !_queue.empty() || !_running; });
+                if (!_running) {
+                    break;
+                }
+                queue_entry = std::move(_queue.front());
+                _queue.pop_front();
+            }
+            LOG4CXX_TRACE(logger, "Start job");
+#ifndef YATQ_DISABLE_FUTURES
+            internal::run_and_set_value<result_type>(std::move(queue_entry.job), std::move(queue_entry.promise));
+#else
+            queue_entry.job();
+#endif
+            LOG4CXX_TRACE(logger, "Job complete");
+        }
+
+        LOG4CXX_INFO(logger, "Stop");
+    }
+};
+
+}
+
+#endif

pytq_cxx-1.0.2/_yatq/include/yatq/timer_queue.h

@@ -0,0 +1,368 @@
+#ifndef _YATQ_TIMER_QUEUE_H
+#define _YATQ_TIMER_QUEUE_H
+
+#include <algorithm>
+#include <chrono>
+#include <condition_variable>
+#include <mutex>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+#ifndef YATQ_DISABLE_FUTURES
+#define BOOST_THREAD_PROVIDES_FUTURE
+#define BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION
+#include <boost/thread/future.hpp>
+#endif
+
+#include "yatq/internal/concepts.h"
+#include "yatq/internal/promise_utils.h"
+#include "yatq/internal/log4cxx_proxy.h"
+#include "yatq/utils/logging_utils.h"
+#ifndef YATQ_DISABLE_PTHREAD
+#include "yatq/utils/sched_utils.h"
+#endif
+#include "yatq/thread_pool.h"
+
+namespace yatq {
+
+using internal::ClockGeneric;
+using internal::ExecutorGeneric;
+
+template<ExecutorGeneric _Executor = ThreadPool<>, ClockGeneric _Clock = std::chrono::system_clock>
+class TimerQueue {
+public:
+    using Clock = _Clock;
+    using Executor = _Executor;
+    using Executable = Executor::Executable;
+    using result_type = Executable::result_type;
+#ifndef YATQ_DISABLE_FUTURES
+    using Future = boost::future<result_type>;  // NB: doesn't have to match 'Executor::Future'
+#endif
+
+    using uid_t = unsigned int;
+
+    typedef struct {
+        /**
+         * opaque timer uid. use it to cancel the timer or to check whether it is still in queue
+         */
+        uid_t uid;
+        /**
+         * scheduled execution timepoint. added for the sake of convenience
+         */
+        Clock::time_point deadline;
+#ifndef YATQ_DISABLE_FUTURES
+        /**
+         * future object. use it to obtain job result
+         */
+        Future result;
+#endif
+    } TimerHandle;
+
+private:
+#ifndef YATQ_DISABLE_FUTURES
+    using Promise = boost::promise<result_type>;
+#endif
+
+    typedef struct {
+        Executable job;
+#ifndef YATQ_DISABLE_FUTURES
+        Promise promise;
+#endif
+    } MapEntry;
+
+    typedef struct {
+        uid_t uid;
+        Clock::time_point deadline;
+    } HeapEntry;
+
+    bool _running;
+    uid_t _next_uid;
+    mutable std::mutex _lock;
+    std::condition_variable _cond;
+    std::unordered_map<uid_t, MapEntry> _jobs;
+    std::vector<HeapEntry> _heap;
+    Executor* const _executor;
+    std::thread _thread;
+
+public:
+    /**
+     * create timer queue
+     * @param executor raw pointer to the job executor; cannot be \a nullptr. ownership not taken
+     */
+    explicit TimerQueue(Executor* executor): _running(false), _next_uid(0), _executor(executor) {}
+
+    /**
+     * start timer queue thread with default scheduling parameters
+     */
+    void start() {
+        if (!_running) {
+            _running = true;
+            _thread = std::thread(&TimerQueue::demux, this);
+        }
+    }
+
+#ifndef YATQ_DISABLE_PTHREAD
+    /**
+     * start timer queue thread with specified scheduling policy and priority
+     * @param sched_policy \a SCHED_OTHER | \a SCHED_RR | \a SCHED_FIFO
+     * @param priority \a yatq::utils::max_priority | \a yatq::utils::min_priority
+     */
+    void start(int sched_policy, utils::priority_t priority = utils::max_priority) {
+        start();
+        utils::set_sched_params(_thread.native_handle(), sched_policy, priority, "timer_queue");
+    }
+
+    /**
+     * start timer queue thread with specified scheduling policy and priority
+     * @param sched_policy \a SCHED_OTHER | \a SCHED_RR | \a SCHED_FIFO
+     * @param priority explicit priority
+     */
+    void start(int sched_policy, int priority) {
+        start();
+        utils::set_sched_params(_thread.native_handle(), sched_policy, priority, "timer_queue");
+    }
+#endif
+
+    /**
+     * stop timer queue thread
+     */
+    void stop() {
+        if (_running) {
+            _running = false;
+            _cond.notify_one();
+            if (_thread.joinable()) {
+                _thread.join();
+            }
+        }
+    }
+
+    /**
+     * add timed job to the queue
+     * @param deadline scheduled execution timepoint
+     * @param job job to execute
+     * @return timer handle to obtain result or cancel
+     */
+    TimerHandle enqueue(const Clock::time_point& deadline, Executable job) {
+#ifndef YATQ_DISABLE_LOGGING
+        static auto logger = log4cxx::Logger::getLogger("yatq.timer_queue");
+#endif
+
+#ifndef YATQ_DISABLE_FUTURES
+        Promise promise;
+        auto future = promise.get_future();
+#endif
+        uid_t uid;
+        bool is_first;
+        {
+            std::lock_guard<std::mutex> guard(_lock);
+            uid = _next_uid++;
+            MapEntry map_entry {
+                std::move(job)
+#ifndef YATQ_DISABLE_FUTURES
+                , std::move(promise)
+#endif
+            };
+            _jobs.insert(std::make_pair(uid, std::move(map_entry)));
+            _heap.push_back(HeapEntry {uid, deadline});
+            std::push_heap(_heap.begin(), _heap.end(), TimerQueue::heap_cmp);
+            is_first = (_heap[0].uid == uid);
+        }
+        if (is_first) {
+            _cond.notify_one();
+        }
+        LOG4CXX_DEBUG(logger, "New timer uid=" + std::to_string(uid));
+        return {
+            uid
+            , deadline
+#ifndef YATQ_DISABLE_FUTURES
+            , std::move(future)
+#endif
+        };
+    }
+
+    /**
+     * cancel timed job
+     * @param uid timer uid
+     * @return \a true if timer was present in the queue; \a false otherwise
+     */
+    bool cancel(uid_t uid) {
+#ifndef YATQ_DISABLE_LOGGING
+        static auto logger = log4cxx::Logger::getLogger("yatq.timer_queue");
+#endif
+
+        bool was_removed;
+        bool was_first;
+        {
+            std::lock_guard<std::mutex> guard(_lock);
+            auto i = _jobs.find(uid);
+            if (i != _jobs.end()) {
+                LOG4CXX_DEBUG(logger, "Canceling timer uid=" + std::to_string(uid));
+                _jobs.erase(i);
+                was_removed = true;
+                was_first = (_heap[0].uid == uid);
+            }
+            else {
+                was_removed = false;
+            }
+        }
+        if (was_removed && was_first) {
+            _cond.notify_one();
+        }
+        return was_removed;
+    }
+
+    /**
+     * delete all jobs from the queue
+     */
+    void clear() {
+#ifndef YATQ_DISABLE_LOGGING
+        static auto logger = log4cxx::Logger::getLogger("yatq.timer_queue");
+#endif
+
+        std::size_t total_jobs;
+        std::size_t total_timers;
+        {
+            std::lock_guard<std::mutex> guard(_lock);
+            total_jobs = _jobs.size();
+            _jobs.clear();
+            total_timers = _heap.size();
+            _heap.clear();
+        }
+        if (total_jobs > 0) {
+            _cond.notify_one();
+        }
+        auto canceled_timers = total_timers - total_jobs;
+        LOG4CXX_DEBUG(logger, "Cleared " + std::to_string(total_jobs) + " timers and " + std::to_string(canceled_timers) + " canceled timers");
+    }
+
+    /**
+     * delete all canceled timers from the queue
+     */
+    void purge() {
+#ifndef YATQ_DISABLE_LOGGING
+        static auto logger = log4cxx::Logger::getLogger("yatq.timer_queue");
+#endif
+
+        std::size_t canceled_timers;
+        {
+            std::lock_guard<std::mutex> guard(_lock);
+            auto total_jobs = _jobs.size();
+            auto total_timers = _heap.size();
+            canceled_timers = total_timers - total_jobs;
+            if (total_timers > total_jobs) {
+                std::vector<HeapEntry> heap(total_jobs);
+                auto i = heap.begin();
+                for (auto&& heap_entry: _heap) {
+                    if (_jobs.contains(heap_entry.uid)) {
+                        *i++ = std::move(heap_entry);
+                    }
+                    else {
+                        LOG4CXX_DEBUG(logger, "Timer uid=" + std::to_string(heap_entry.uid) + " has been canceled");
+                    }
+                }
+                std::make_heap(heap.begin(), heap.end(), TimerQueue::heap_cmp);
+                _heap.swap(heap);
+            }
+        }
+        // NB: 'demux()' never waits on a canceled timer => no need to notify
+        LOG4CXX_DEBUG(logger, "Purged " + std::to_string(canceled_timers) + " canceled timers");
+    }
+
+    /**
+     * check whether a job is still in the queue
+     * @param uid timer uid
+     */
+    bool in_queue(uid_t uid) const {
+        std::lock_guard<std::mutex> guard(_lock);
+        return _jobs.contains(uid);
+    }
+
+private:
+    static bool heap_cmp(const HeapEntry& lhs, const HeapEntry& rhs) {
+        return lhs.deadline > rhs.deadline;  // NB: '>'
+    }
+
+    void demux() {
+#ifndef YATQ_DISABLE_LOGGING
+        static auto logger = log4cxx::Logger::getLogger("yatq.timer_queue");
+#endif
+
+        SET_THREAD_TAG("timer_queue");
+        LOG4CXX_INFO(logger, "Start");
+
+        std::unique_lock<std::mutex> guard(_lock);
+        while (_running) {
+            bool deadline_expired = false;
+            while (!_heap.empty()) {
+                auto current_uid = _heap[0].uid;
+                auto i = _jobs.find(current_uid);
+                if (i == _jobs.end()) {
+                    LOG4CXX_DEBUG(logger, "Timer uid=" + std::to_string(current_uid) + " has been canceled");
+                    std::pop_heap(_heap.begin(), _heap.end(), TimerQueue::heap_cmp);
+                    _heap.pop_back();
+                    deadline_expired = false;
+                    continue;
+                }
+                if (!deadline_expired) {
+                    auto now = Clock::now();  // NB: system call => context switch
+                    deadline_expired = (_heap[0].deadline <= now);
+                }
+                if (deadline_expired) {
+                    LOG4CXX_DEBUG(logger, "Executing timer uid=" + std::to_string(current_uid));
+                    auto node = _jobs.extract(i);
+                    std::pop_heap(_heap.begin(), _heap.end(), TimerQueue::heap_cmp);
+                    _heap.pop_back();
+                    auto map_entry = std::move(node.mapped());
+
+                    guard.unlock();
+#ifndef YATQ_DISABLE_FUTURES
+                    auto future =
+#endif
+                    _executor->execute(std::move(map_entry.job));
+                    guard.lock();
+
+#ifndef YATQ_DISABLE_FUTURES
+                    future.then(  // future chaining -- this is why we use 'boost::future' instead of 'std::future'
+                        boost::launch::sync,  // FIXME: does not match the concept
+                        [promise = std::move(map_entry.promise)]
+                        (Executor::Future future) mutable
+                        { internal::get_and_set_value<result_type>(std::move(future), std::move(promise)); }
+                    );
+#endif
+                    deadline_expired = false;
+                }
+                else {
+                    // NB: without this explicit cast duration type may be deduced incorrectly
+                    // on Linux this leads to waiting for a random time point
+                    std::chrono::time_point<Clock, typename Clock::duration> deadline = _heap[0].deadline;
+                    LOG4CXX_TRACE(logger, "Wait until " + utils::time_point_to_string(deadline));
+                    bool notified = _cond.wait_until(
+                            guard,
+                            deadline,
+                            [this, current_uid] () {
+                                return !_jobs.contains(current_uid) || (_heap[0].uid != current_uid) || !_running;
+                            }
+                    );
+                    LOG4CXX_TRACE(logger, "Wake-up");
+                    if (!_running) {
+                        LOG4CXX_WARN(logger, "Stopping timer queue with unprocessed timers");
+                        return;
+                    }
+                    if (!notified) {  // => timeout
+                        deadline_expired = true;
+                    }
+                }
+            }
+            LOG4CXX_TRACE(logger, "Wait");
+            _cond.wait(guard, [this] () { return !_heap.empty() || !_running; });
+            LOG4CXX_TRACE(logger, "Wake-up");
+        }
+
+        LOG4CXX_INFO(logger, "Stop");
+    }
+};
+
+}
+
+#endif

pytq_cxx-1.0.2/_yatq/include/yatq/utils/logging_utils.h

@@ -0,0 +1,51 @@
+#ifndef _YATQ_UTILS_LOGGING_UTILS_H
+#define _YATQ_UTILS_LOGGING_UTILS_H
+
+#include <chrono>
+#include <iomanip>
+#include <locale>
+#include <sstream>
+
+#include <sched.h>
+
+namespace yatq::utils {
+
+template<typename time_point>
+std::string time_point_to_string(const time_point& t) {
+    return std::to_string(t.time_since_epoch().count());
+}
+
+template<>
+inline std::string time_point_to_string(const std::chrono::system_clock::time_point& time_point) {
+    std::stringstream stream;
+
+    std::time_t timestamp = std::chrono::system_clock::to_time_t(time_point);
+    std::tm* tm_info_p = std::localtime(&timestamp);  // static initialization, no need for memory management
+    stream << std::put_time(tm_info_p, "%F %T");
+
+    // locale-aware decimal point
+    static const char decimal_point = std::use_facet<std::numpunct<char>>(std::locale("")).decimal_point();
+
+    auto time_point_ms = std::chrono::time_point_cast<std::chrono::milliseconds>(time_point);
+    auto milliseconds = time_point_ms.time_since_epoch().count() % 1000;
+    stream << decimal_point << std::setfill('0') << std::setw(3) << milliseconds;
+
+    return stream.str();
+}
+
+inline std::string sched_policy_to_string(int sched_policy) {
+    switch (sched_policy) {
+        case SCHED_OTHER:
+            return "SCHED_OTHER";
+        case SCHED_FIFO:
+            return "SCHED_FIFO";
+        case SCHED_RR:
+            return "SCHED_RR";
+        default:
+            return std::to_string(sched_policy);
+    }
+}
+
+}
+
+#endif

pytq_cxx-1.0.2/_yatq/include/yatq/utils/sched_utils.h

@@ -0,0 +1,50 @@
+#ifndef _YATQ_UTILS_SCHED_UTILS_H
+#define _YATQ_UTILS_SCHED_UTILS_H
+
+#include <cerrno>
+#include <string>
+
+#include <pthread.h>
+
+#include "yatq/internal/log4cxx_proxy.h"
+#include "yatq/utils/logging_utils.h"
+
+namespace yatq::utils {
+
+typedef enum {min_priority = 0, max_priority = -1} priority_t;
+
+inline bool set_sched_params(pthread_t handle, int sched_policy, int priority, const std::string& thread_tag = "unspecified") {
+#ifndef YATQ_DISABLE_LOGGING
+    static auto logger = log4cxx::Logger::getLogger("yatq.utils.sched");
+#endif
+
+    int prev_sched_policy;  // Linux implementation crashes on 'nullptr'
+    sched_param sched;
+    pthread_getschedparam(handle, &prev_sched_policy, &sched);
+    sched.sched_priority = priority;
+    if (pthread_setschedparam(handle, sched_policy, &sched) == 0) {
+        LOG4CXX_INFO(logger, "Set sched params thread=" + thread_tag + " policy=" + sched_policy_to_string(sched_policy) + " priority=" + std::to_string(priority));
+        return true;
+    }
+    else {
+        LOG4CXX_WARN(logger, "Failed to set sched params thread=" + thread_tag + ": " + std::string(std::strerror(errno)));
+        return false;
+    }
+}
+
+inline bool set_sched_params(pthread_t handle, int sched_policy, priority_t priority_tag, const std::string& thread_tag = "unspecified") {
+    int priority;
+    switch (priority_tag) {
+        case min_priority:
+            priority = sched_get_priority_min(sched_policy);
+            break;
+        case max_priority:
+            priority = sched_get_priority_max(sched_policy);
+            break;
+    }
+    return set_sched_params(handle, sched_policy, priority, thread_tag);
+}
+
+}
+
+#endif

pytq_cxx-1.0.2/_yatq/include/yatq/version.h

@@ -0,0 +1,6 @@
+#ifndef _YATQ_VERSION_H
+#define _YATQ_VERSION_H
+
+#define YATQ_VERSION "1.0.2"
+
+#endif

pytq_cxx-1.0.2/_yatq/traits.h

@@ -0,0 +1,19 @@
+#ifndef _YATQ_BINDINGS_PYTHON_YATQ_TRAITS_H
+#define _YATQ_BINDINGS_PYTHON_YATQ_TRAITS_H
+
+#define PYBIND11_DETAILED_ERROR_MESSAGES
+#include <pybind11/pybind11.h>
+
+#define BOOST_THREAD_PROVIDES_FUTURE
+#define BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION
+#include <boost/thread/future.hpp>
+
+namespace pybind11::detail {
+
+// only needed for 'result_type = void'
+template <>
+struct is_move_constructible<boost::future<void>>: std::true_type {};
+
+}
+
+#endif

pytq_cxx-1.0.2/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools >= 65.0.0", "pybind11 >= 2.13.6", "wheel >= 0.44.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pytq-cxx"
+version = "1.0.2"
+authors = [{name="Nikita Vaganov", email="nikita.e.vaganov@gmail.com"}]
+description = "single-threaded timer demultiplexer backed by C++ implementation"
+readme = "README_pytq.md"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)",
+]
+requires-python = ">=3.7"
+
+[project.urls]
+"Homepage" = "https://github.com/vaganov/yatq"
+"Bug Tracker" = "https://github.com/vaganov/yatq/issues"

pytq_cxx-1.0.2/pytq/__init__.py

@@ -0,0 +1,5 @@
+from _yatq import __version__, TimerQueue, TimerHandle, ThreadPool, utils
+from .awaitable_future import AwaitableFuture
+
+
+__all__ = ['__version__', 'TimerQueue', 'TimerHandle', 'ThreadPool', 'utils', 'AwaitableFuture']

pytq_cxx-1.0.2/pytq/awaitable_future.py

@@ -0,0 +1,19 @@
+import asyncio
+
+
+__all__ = ['AwaitableFuture']
+
+
+class AwaitableFuture:
+    def __init__(self, future):
+        self._future = future
+
+    def __await__(self):
+        while not self._future.is_ready():
+            yield
+        return self._future.get()  # NB: return, not yield
+
+    async def get(self):
+        while not self._future.is_ready():
+            await asyncio.sleep(0)
+        return self._future.get()

pytq_cxx-1.0.2/pytq_cxx.egg-info/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.1
+Name: pytq-cxx
+Version: 1.0.2
+Summary: single-threaded timer demultiplexer backed by C++ implementation
+Author-email: Nikita Vaganov <nikita.e.vaganov@gmail.com>
+Project-URL: Homepage, https://github.com/vaganov/yatq
+Project-URL: Bug Tracker, https://github.com/vaganov/yatq/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# pytq-cxx
+**pytq-cxx** is a _python_ wrapper for **yatq** -- a _C++_ template library. For the documentation and examples please
+see [yatq homepage](https://github.com/vaganov/yatq)
+
+**NB:** This package has nothing to do with [pytq package](https://pypi.org/project/pytq)
+
+**NB:** Module name is, however, **pytq**
+
+    from pytq import ThreadPool, TimerQueue, AwaitableFuture

pytq_cxx-1.0.2/pytq_cxx.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+MANIFEST.in
+README_pytq.md
+pyproject.toml
+setup.py
+_yatq/bind.cpp
+_yatq/traits.h
+_yatq/include/yatq/thread_pool.h
+_yatq/include/yatq/timer_queue.h
+_yatq/include/yatq/version.h
+_yatq/include/yatq/internal/concepts.h
+_yatq/include/yatq/internal/log4cxx_proxy.h
+_yatq/include/yatq/internal/promise_utils.h
+_yatq/include/yatq/utils/logging_utils.h
+_yatq/include/yatq/utils/sched_utils.h
+pytq/__init__.py
+pytq/awaitable_future.py
+pytq_cxx.egg-info/PKG-INFO
+pytq_cxx.egg-info/SOURCES.txt
+pytq_cxx.egg-info/dependency_links.txt
+pytq_cxx.egg-info/top_level.txt
+setup_helpers/find_dep_headers.cmake
+setup_helpers/find_dep_libs.cmake

pytq_cxx-1.0.2/pytq_cxx.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pytq_cxx-1.0.2/pytq_cxx.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+_yatq
+pytq

pytq_cxx-1.0.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pytq_cxx-1.0.2/setup.py

@@ -0,0 +1,60 @@
+from pathlib import Path
+import subprocess
+import sys
+
+from setuptools import setup
+from pybind11.setup_helpers import Pybind11Extension, build_ext
+
+
+def ugly_helper():  # https://github.com/vaganov/yatq/issues/2
+    dirpath = str(Path(__file__).parent / 'setup_helpers')
+
+    args = ['cmake', '-P', 'find_dep_headers.cmake']
+    result = subprocess.run(args, cwd=dirpath, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    if result.returncode != 0:
+        print(result.stderr.decode(), end='', file=sys.stderr, flush=True)
+        raise RuntimeError(f"{' '.join(args)} returned {result.returncode}")
+
+    _inc_dirs = set(line.strip() for line in result.stderr.decode().split())  # sic! 'stderr'
+    inc_dirs = list(_inc_dirs)
+
+    args = ['cmake', '-P', 'find_dep_libs.cmake']
+    result = subprocess.run(args, cwd=dirpath, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    if result.returncode != 0:
+        print(result.stderr.decode(), end='', file=sys.stderr, flush=True)
+        raise RuntimeError(f"{' '.join(args)} returned {result.returncode}")
+
+    lib_prefix = 'lib'
+    lib_prefix_len = len(lib_prefix)
+
+    _lib_dirs = set()
+    libs = []
+    for line in result.stderr.decode().split():  # sic! 'stderr'
+        path = Path(line.strip())
+        _lib_dirs.add(str(path.parent))
+        libname = path.stem
+        if libname.startswith(lib_prefix):
+            libname = libname[lib_prefix_len:]
+        libs.append(libname)
+    lib_dirs = list(_lib_dirs)
+
+    return {'inc_dirs': inc_dirs, 'lib_dirs': lib_dirs, 'libs': libs}
+
+
+HELPER_FLAGS = ugly_helper()
+
+
+setup(
+    packages=['pytq'],
+    ext_modules=[
+        Pybind11Extension(
+            '_yatq',
+            ['_yatq/bind.cpp'],
+            include_dirs=HELPER_FLAGS['inc_dirs'] + ['_yatq/include'],  # https://github.com/vaganov/yatq/issues/4
+            library_dirs=HELPER_FLAGS['lib_dirs'],
+            libraries=HELPER_FLAGS['libs'],
+            cxx_std=20,
+        ),
+    ],
+    cmdclass=dict(build_ext=build_ext),
+)

pytq_cxx-1.0.2/setup_helpers/find_dep_headers.cmake

@@ -0,0 +1,9 @@
+#! cmake -P
+cmake_minimum_required(VERSION 3.22)
+
+set(INCLUDE_PATHS /usr/include /usr/local/include)
+
+find_path(boost_include_dir boost PATHS ${INCLUDE_PATHS} REQUIRED)
+message("${boost_include_dir}")
+find_path(log4cxx_include_dir log4cxx PATHS ${INCLUDE_PATHS} REQUIRED)
+message("${log4cxx_include_dir}")

pytq_cxx-1.0.2/setup_helpers/find_dep_libs.cmake

@@ -0,0 +1,9 @@
+#! cmake -P
+cmake_minimum_required(VERSION 3.22)
+
+set(LIB_PATHS /lib /lib/x86_64-linux-gnu /usr/lib /usr/local/lib)
+
+find_library(boost_thread_lib NAMES boost_thread boost_thread-mt PATHS ${LIB_PATHS} REQUIRED)
+message("${boost_thread_lib}")
+find_library(log4cxx_lib log4cxx PATHS ${LIB_PATHS} REQUIRED)
+message("${log4cxx_lib}")