ThreadPool Class Reference

Thread pool for parallel tensor loading operations. More...

#include <safetensors_loader.h>

Collaboration diagram for ThreadPool:

Public Member Functions
	ThreadPool (size_t num_threads)
	Constructs a thread pool with specified number of threads.
	~ThreadPool ()
	Destructor that ensures proper cleanup of threads.
template<class F , class... Args>
std::future< typename std::result_of< F(Args...)>::type >	submit (F &&f, Args &&... args)
	Submits a task to the thread pool.

Private Attributes
std::vector< std::thread >	workers_
std::queue< std::function< void()> >	tasks_
std::mutex	queue_mutex_
std::condition_variable	condition_
bool	stop_ = false

Detailed Description

Thread pool for parallel tensor loading operations.

Manages a pool of worker threads for parallel processing of tensor data. Used by SafeTensorsLoader for parallel loading operations.

Definition at line 260 of file safetensors_loader.h.

Constructor & Destructor Documentation

ThreadPool()

ThreadPool::ThreadPool ( size_t  num_threads )

explicit

Constructs a thread pool with specified number of threads.

Parameters

num_threads

Number of worker threads to create

Definition at line 684 of file safetensors_loader.cpp.

                                         : stop_(false) {
    for (size_t i = 0; i < num_threads; ++i) {
        workers_.emplace_back([this] {
            while (true) {
                std::function<void()> task;
                {
                    std::unique_lock<std::mutex> lock(this->queue_mutex_);
                    this->condition_.wait(lock, [this] {
                        return this->stop_ || !this->tasks_.empty();
                    });
                    if (this->stop_ && this->tasks_.empty()) return;
                    task = std::move(this->tasks_.front());
                    this->tasks_.pop();
                }
                if(task) task(); 
            }
        });
    }
}

References condition_, queue_mutex_, stop_, tasks_, and workers_.

~ThreadPool()

ThreadPool::~ThreadPool

(

)

Destructor that ensures proper cleanup of threads.

Definition at line 704 of file safetensors_loader.cpp.

                        {
    {
        std::unique_lock<std::mutex> lock(queue_mutex_);
        stop_ = true;
    }
    condition_.notify_all();
    for (std::thread& worker : workers_) {
        if (worker.joinable()) { 
            worker.join();
        }
    }
}

References condition_, queue_mutex_, stop_, and workers_.

Member Function Documentation

submit()

template<class F , class... Args>

std::future< typename std::result_of< F(Args...)>::type > ThreadPool::submit	(	F &&	f,
		Args &&...	args
	)

Submits a task to the thread pool.

Template Parameters

F	Function type
Args	Argument types

Parameters

f	Function to execute
args	Arguments for the function

Returns

Future containing the result of the function

Definition at line 294 of file safetensors_loader.h.

                           {
  using return_type = typename std::result_of<F(Args...)>::type;
 
  auto task = std::make_shared<std::packaged_task<return_type()>>(
      std::bind(std::forward<F>(f), std::forward<Args>(args)...));
 
  std::future<return_type> res = task->get_future();
  {
    std::unique_lock<std::mutex> lock(queue_mutex_);
    if (stop_) throw std::runtime_error("submit on stopped ThreadPool");
    tasks_.emplace([task]() { (*task)(); });
  }
  condition_.notify_one();
  return res;
}

References condition_, queue_mutex_, stop_, and tasks_.

Referenced by SafeTensorsLoader::load_all_tensors_parallel().

Member Data Documentation

condition_

std::condition_variable ThreadPool::condition_

private

Condition variable for thread synchronization

Definition at line 288 of file safetensors_loader.h.

Referenced by submit(), ThreadPool(), and ~ThreadPool().

queue_mutex_

std::mutex ThreadPool::queue_mutex_

private

Mutex for task queue access

Definition at line 287 of file safetensors_loader.h.

Referenced by submit(), ThreadPool(), and ~ThreadPool().

stop_

bool ThreadPool::stop_ = false

private

Flag to stop worker threads

Definition at line 289 of file safetensors_loader.h.

Referenced by submit(), ThreadPool(), and ~ThreadPool().

tasks_

std::queue<std::function<void()> > ThreadPool::tasks_

private

Queue of pending tasks

Definition at line 286 of file safetensors_loader.h.

Referenced by submit(), and ThreadPool().

workers_

std::vector<std::thread> ThreadPool::workers_

private

Worker threads

Definition at line 285 of file safetensors_loader.h.

Referenced by ThreadPool(), and ~ThreadPool().

---

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

• safetensors_loader.h
• safetensors_loader.cpp