AgingPriorityPool Class Reference

A priority-based thread pool that implements an Aging Algorithm. More...

Collaboration diagram for AgingPriorityPool:

Public Member Functions
	AgingPriorityPool (size_t threads)
	Constructs the pool and starts both workers and the aging monitor.
void	enqueue (int priority, std::string name, std::function< void()> f)
	Enqueues a task with an initial priority.
	~AgingPriorityPool ()
	Gracefully shuts down the monitor and worker threads.

Detailed Description

A priority-based thread pool that implements an Aging Algorithm.

• This pool uses a std::vector as a binary heap and a dedicated monitor thread to "age" tasks, ensuring that low-priority tasks eventually gain enough priority to be executed even under high load.

Definition at line 50 of file AgingPriority.cpp.

Constructor & Destructor Documentation

AgingPriorityPool()

AgingPriorityPool::AgingPriorityPool ( size_t  threads )

inline

Constructs the pool and starts both workers and the aging monitor.

Parameters

threads

Number of worker threads to spawn.

Definition at line 131 of file AgingPriority.cpp.

                                      : stop(false) {
        for (size_t i = 0; i < threads; ++i) {
            workers.emplace_back(&AgingPriorityPool::workerLoop, this);
        }
        monitor_thread = std::thread(&AgingPriorityPool::monitorLoop, this);
    }

~AgingPriorityPool()

AgingPriorityPool::~AgingPriorityPool ( )

inline

Gracefully shuts down the monitor and worker threads.

Definition at line 163 of file AgingPriority.cpp.

                         {
        stop = true;
        cv.notify_all();
        if (monitor_thread.joinable()) monitor_thread.join();
        for (auto &w : workers) if (w.joinable()) w.join();
    }

Member Function Documentation

enqueue()

void AgingPriorityPool::enqueue ( int  priority, std::string  name, std::function< void()>  f  )

inline

Enqueues a task with an initial priority.

Parameters

priority	Initial importance level.
name	Name for identifying the task in logs.
f	The function to execute.

Definition at line 144 of file AgingPriority.cpp.

                                                                      {
        {
            std::lock_guard<std::mutex> lock(queue_mtx);
            AgedTask newTask;
            newTask.original_priority = priority;
            newTask.current_priority = priority;
            newTask.arrival_time = system_clock::now();
            newTask.func = std::move(f);
            newTask.task_name = name;
 
            task_heap.push_back(std::move(newTask));
            std::push_heap(task_heap.begin(), task_heap.end());
        }
        cv.notify_one();
    }

References AgedTask::arrival_time, AgedTask::current_priority, AgedTask::func, AgedTask::original_priority, and AgedTask::task_name.

Referenced by main().

Here is the caller graph for this function:

---

The documentation for this class was generated from the following file:

• ThreadPools/AgingPriority.cpp