Struct liriodendron::task::tasksmanager::TasksManager

pub struct TasksManager {
    nb_running_threads: Arc<Mutex<usize>>,
    waiting_tasks: Arc<Mutex<usize>>,
    is_sending: Arc<Mutex<bool>>,
    threadpool: ThreadPool,
    sender: Sender<Option<(ThreadId, (u16, u16))>>,
    receiver: Receiver<Option<(ThreadId, (u16, u16))>>,
    tasks: VecDeque<Box<dyn Task + Send>>,
    todo_tasks: usize,
    done_tasks: usize,
    threads_monitor: HashMap<ThreadId, (u16, u16)>,
    threads_number: usize,
    max_tasks: usize,
}

Multi-threaded struct to support expensive users queries and avoid blocking tasks

Fields

nb_running_threads: Arc<Mutex<usize>>

Running threads counter

waiting_tasks: Arc<Mutex<usize>>

Queue's length

is_sending: Arc<Mutex<bool>>

When true, threads send their progression

threadpool: ThreadPool

sender: Sender<Option<(ThreadId, (u16, u16))>>

receiver: Receiver<Option<(ThreadId, (u16, u16))>>

tasks: VecDeque<Box<dyn Task + Send>>

Waiting tasks are stocked in this queue

todo_tasks: usize

done_tasks: usize

threads_monitor: HashMap<ThreadId, (u16, u16)>

Stocks threads' progression

threads_number: usize

Customizable member

max_tasks: usize

Customizable member

Methods

impl TasksManager

pub fn new(threads_number: usize, max_tasks: usize) -> TasksManager

pub fn new_generation_task(&mut self, log: &Log) -> (Result<()>, bool)

fn get_nb_running_threads(&self) -> usize

pub fn get_todo_and_max_tasks(&self) -> (usize, usize)

pub fn get_done_and_todo_tasks(&self) -> (usize, usize)

pub fn check_queue(&mut self)

Checks if a task is in the queue. If a thread is available, it runs the task and pop it from the queue.

pub fn start_sender_channel(&mut self)

pub fn compute_todotasks(&mut self)

pub fn spawn_unlocking_thread(&self)

Unlocks a blocking std::sync::mpsc::Receiver.recv() call

pub fn shutdown(self)

pub fn get_threads_monitor(&self) -> &HashMap<ThreadId, (u16, u16)>

pub fn is_running(&mut self) -> bool

While the receiver is receiving data from the threadpool, a thread is running