hxtask_queue.hpp

Go to the documentation of this file.

#pragma once
// SPDX-FileCopyrightText: © 2017-2026 Adrian Johnston.
// SPDX-License-Identifier: MIT
// This file is licensed under the MIT license found in the LICENSE.md file.

 
#include "libhatchet.h"
 
// HX_USE_MACROS_WITH_MODULE allows including macros alongside the module.
#if HX_USE_MACROS_WITH_MODULE
#error Header does not provide macros alone.
#endif
 
#include "hxvector.hpp"
#include "hxtask.hpp"
#include "hxthread.hpp"
 
HX_NS_BEGIN_

class hxtask_queue {
public:
    class record_t {
    public:
        hxtask* task;
        int priority;

        bool operator<(const record_t& x_) const { return this->priority < x_.priority; }
 
#if (HX_HARDENING_MODE) == HX_HARDENING_MODE_DEBUG
        const char* label;
        ~record_t() { ::memset(reinterpret_cast<void*>(this), 0xefu, sizeof *this); }
#endif
    };

    explicit hxtask_queue(int32_t task_queue_size_, int32_t thread_pool_size_) noexcept;

    ~hxtask_queue(void);

    template<typename callable_t_>
    hxattr_nodiscard bool all_of(callable_t_&& callable_) const noexcept;

    template<typename callable_t_>
    hxattr_nodiscard bool any_of(callable_t_&& callable_) const noexcept;

    bool cancel(hxtask* task_) noexcept hxattr_nonnull(2);

    void clear(void) noexcept;

    hxattr_nodiscard bool empty(void) const;

    void enqueue(hxtask* task_, int priority_=0) noexcept hxattr_nonnull(2);

    template<typename callable_t_>
    hxsize_t erase_if(callable_t_&& callable_) noexcept;

    template<typename callable_t_>
    void for_each(callable_t_&& callable_) const noexcept;

    template<typename callable_t_>
    void for_each(callable_t_&& callable_) noexcept;

    hxattr_nodiscard bool full(void) const;

    hxattr_nodiscard hxsize_t max_size(void) const;

    hxattr_nodiscard hxsize_t size(void) const;

    void wait_for_all(void) noexcept;
 
private:
    hxtask_queue(const hxtask_queue&) = delete;
    void operator=(const hxtask_queue&) = delete;
 
    hxvector<record_t> m_tasks_;
 
#if HX_USE_THREADS
#define hxtask_queue_lock_ const hxunique_lock lock_(m_mutex_)
 
    template<int32_t> friend class hxtask_dag_node;
 
    enum class thread_mode_ : uint8_t {
        pool_,
        waiting_,
        stopping_
    };
    enum class run_level_ : uint32_t {
        running_ = 0x00c0ffeeu,
        stopped_ = 0xdeadbeefu
    };
 
    static hxthread::return_t thread_task_loop_entry_(hxtask_queue* q_) noexcept;
    static void thread_task_loop_(hxtask_queue& q_, thread_mode_ mode_) noexcept;
 
    run_level_ m_queue_run_level_;
    int32_t m_thread_pool_size_;
    int32_t m_executing_count_;
    hxthread* m_threads_;
    mutable hxmutex m_mutex_;
    hxcondition_variable m_cond_var_new_tasks_;
    hxcondition_variable m_cond_var_completion_;
#else
#define hxtask_queue_lock_ ((void)0)
#endif
};
 
#include "detail/hxtask_queue.inl"
HX_NS_END_