Main scheduling class. More...

#include <scheduler.h>

Public Types
using	Task_return_type = Task_result

using	Thread_pool_type = Thread_pool< Task_return_type >

using	Thread_pool_ptr = std::shared_ptr< Thread_pool_type >

using	Scheduled_task_type = Scheduled_task

using	Mutex_type = concurrency::Mutex

using	Task_queue_type = std::priority_queue< Scheduled_task >

Public Member Functions
virtual	~Scheduler ()
	Destructor. More...

void	deinit ()
	Ends the scheduler if stop was not yet requested. More...

	Scheduler (const Scheduler &src)=delete
	Copying constructor is deleted. More...

	Scheduler (Thread_pool_ptr shared_thread_pool, Scheduler_clock_ptr shared_clock, Dependency_tracker_ptr dependency_tracker, int instance_id=0, std::size_t allowed_task_count=std::numeric_limits< std::size_t >::max(), Scheduler_psi psi_params={})
	Constructor. More...

template<typename FType , typename... Args>
bool	enqueue (Task_schedule_ptr schedule, FType &&task, Args &&...args)
	Enqueues a task. More...

template<typename FType , typename... Args>
bool	enqueue_after (const Task_id &predecessor, Task_schedule_ptr schedule, FType &&task, Args &&...args)
	Enqueues a task that should execute after a predecessor task finishes. More...

bool	synchronize (bool force=true, bool print_checkpoint=false)
	This function waits for currently fired tasks to finish (blocking) More...

std::size_t	get_timeouts () const
	Access "timeouts" observability statistics - the number of times scheduler timed out while waiting for tasks to schedule. More...

bool	is_error () const
	Internal function to check on whether error has been set. More...

std::size_t	get_scheduled_tasks_count () const
	Obtain the number of scheduled, ongoing tasks. More...

bool	register_phase (Scheduler_clock_ptr phase_clock)
	Register task phase run according to the given clock. More...

void	stop_now ()
	Instruct the scheduler to stop now and withdraw all work. More...

void	notify_scheduler ()
	Function used to notify scheduler thread by the other thread (enqueueing thread / worker poll thread) More...

bool	ensure_space ()
	Ensure space for the next task (eliminates possible wait in the enqueue) More...

void	request_unblock ()
	This function requests unblocking of the scheduler. More...

Static Public Attributes
static constexpr Sync_method	sync_method {Sync_method::active}

Protected Types
using	Task_future = std::future< Task_result >

using	Futures_list = std::list< Task_future >

Protected Member Functions
bool	add_dependency (const Task_id &predecessor, const Task_id &successor)
	add_dependency More...

template<typename FType , typename... Args>
bool	enqueue_internal (Task_schedule_ptr schedule, FType &&task, Args &&...args)
	Enqueues a task identified by the task_id. More...

void	end_execution ()
	end_execution More...

void	wait_for_scheduler_thread_to_stop ()
	Waits for scheduler thread to finish its work. More...

void	run_main_thread ()
	Scheduler run function. More...

bool	are_phase_queues_empty () const
	Checks phase queues and return true if all are empty. More...

bool	is_task_phase_ready () const
	Checks whether any phase of the task is ready for execution. More...

template<typename Repeatable_task_type >
Task_result	callback (Task_schedule_ptr schedule, Scheduler_clock::Time_point_t task_delay, bool task_error, std::shared_ptr< Repeatable_task_type > repeatable_task, unsigned int current_thread_id)
	Function used to notify that task ended its execution. More...

Task_result	callback_phase (Task_schedule_ptr schedule, bool task_error, unsigned int phase_id)
	Function used to notify that task phase ended its execution. More...

template<typename Repeatable_task_type >
bool	enqueue_phase (Task_schedule_ptr schedule, Scheduler_clock::Time_point_t task_delay, std::shared_ptr< Repeatable_task_type > repeatable_task, unsigned int current_thread_id, unsigned int phase_id)
	Function that enqueues next task phase. More...

void	wait_until_done ()

void	handle_error ()
	Worker error handling function. More...

void	scheduler_clean_up ()
	Scheduler error handling function. More...

bool	enqueue_helper (Scheduled_task &&task)
	Enqueue helper. More...

void	synchronize_active (bool print_checkpoint, std::size_t expected, bool force)
	Synchronizes the scheduler by actively waiting for finished tasks count. More...

void	synchronize_partial (bool print_checkpoint=false)
	Waits for percent of tasks to finish. More...

void	synchronize_active_partial (bool print_checkpoint)
	Actively waits for percent of tasks to finish. More...

Task_queue_type &	get_phase_queue (Scheduler_clock_ptr phase_clock)

Mutex_type &	get_phase_queue_lock (Scheduler_clock_ptr phase_clock)

bool	is_task_ready () const
	Helper function to check if the task at the top of the task queue is ready. More...

bool	is_stop_requested () const
	Internal function to check if immediate stop was requested, externally or due to an error. More...

Private Types
using	Thread_type = concurrency::Thread

Private Attributes
std::priority_queue< Scheduled_task >	m_tasks
	This is a queue which holds task ready for scheduling. More...

bool	m_scheduler_thread_active {true}
	Variable indicating that scheduler thread finished its execution, protected with m_mutex_end. More...

Mutex_type	m_mutex_notification
	Mutex protecting access to scheduler notifications. More...

Mutex_type	m_mutex_tasks
	Mutex protecting access to m_tasks, data structure populated by the enqueuing thread. More...

Mutex_type	m_mutex_phases
	This mutex protect access to phase. More...

std::atomic< bool >	m_notification {false}
	True if scheduler has been notified. More...

concurrency::Condition_variable	m_cv_scheduler
	Cv used by the scheduler main thread to wait on, when no task is available or tasks in m_task queue are not read to execute. More...

Mutex_type	m_mutex_end
	Mutex used to finish execution of the Scheduler, protects m_scheduler_thread_active and it is used together with m_cv_end. More...

concurrency::Condition_variable	m_cv_end
	cv used by a thread requesting scheduler to finish its work More...

std::unordered_map< Task_id, Scheduled_task >	m_tasks_waiting_for_deps
	Internal map that keeps tasks waiting for dependencies defined in the Dependency Graph (distinct from time dependencies implemented in the Scheduler clock) More...

container::Integrals_lockfree_queue< uint64_t >	m_notified_tasks
	Lock-free queue of task IDs that are ready for execution. More...

Thread_type	m_scheduler_thread
	Scheduler main thread. More...

std::atomic< bool >	m_scheduler_active {true}
	Variable that checks whether scheduler should run (true) or end its execution (false) More...

std::atomic< bool >	m_deinitialized {false}
	Ensures deinit() is executed only once. More...

std::atomic< bool >	m_stop_now {false}
	Variable that instructs scheduler to withdraw all work and stop. More...

std::atomic< std::size_t >	m_scheduled_tasks_cnt {0}
	The number of scheduled tasks. More...

Scheduler_clock_ptr	m_scheduler_clock
	Scheduler clock. More...

std::unordered_map< Scheduler_clock_ptr, Task_queue_type >	m_task_phases
	Tasks may be divided into phases, each phase works according to a defined clock, registered with "register_phase" function. More...

std::unordered_map< Scheduler_clock_ptr, Mutex_type >	m_task_phases_locks

Dependency_tracker_ptr	m_dependencies
	Task dependencies, used mainly to implement dependencies between events in one transaction or between commit event and parent transaction last event (to disallow a transaction to enter a commit when a parent transaction, i.e. More...

Thread_pool_ptr	m_thread_pool
	Thread pool with threads that execute tasks. More...

std::atomic_flag	m_is_error = ATOMIC_FLAG_INIT

std::atomic< Scheduler_status >	m_status {Scheduler_status::idle}
	Observability variables. More...

std::atomic< std::size_t >	m_timeouts {0}

unsigned int	m_instance_id {0}
	Instance id. More...

Statistics_instance_monitor_ref	m_stat_monitor
	Statistics monitoring object for the current instance. More...

std::atomic< std::size_t >	m_allowed_task_count
	Maximum allowed number of tasks active in the scheduler. More...

bool	m_wait_for_task_limit {false}
	Information on whether enqueueing thread is waiting for available task count limit. More...

std::atomic< bool >	m_unblock_request {0}
	Stores unblock requests from external threads, will allow N task to enter phase. More...

Scheduler_psi	m_psi
	PSI parameters. More...

Detailed Description

Main scheduling class.

Member Typedef Documentation

◆ Futures_list

using mysql::scheduler::Scheduler::Futures_list = std::list<Task_future>

protected

◆ Mutex_type

using mysql::scheduler::Scheduler::Mutex_type = concurrency::Mutex

◆ Scheduled_task_type

using mysql::scheduler::Scheduler::Scheduled_task_type = Scheduled_task

◆ Task_future

using mysql::scheduler::Scheduler::Task_future = std::future<Task_result>

protected

◆ Task_queue_type

using mysql::scheduler::Scheduler::Task_queue_type = std::priority_queue<Scheduled_task>

◆ Task_return_type

using mysql::scheduler::Scheduler::Task_return_type = Task_result

◆ Thread_pool_ptr

using mysql::scheduler::Scheduler::Thread_pool_ptr = std::shared_ptr<Thread_pool_type>

◆ Thread_pool_type

using mysql::scheduler::Scheduler::Thread_pool_type = Thread_pool<Task_return_type>

◆ Thread_type

using mysql::scheduler::Scheduler::Thread_type = concurrency::Thread

private

Constructor & Destructor Documentation

◆ ~Scheduler()

mysql::scheduler::Scheduler::~Scheduler ( )

virtual

Destructor.

◆ Scheduler() [1/2]

mysql::scheduler::Scheduler::Scheduler ( const Scheduler & src )

delete

Copying constructor is deleted.

◆ Scheduler() [2/2]

mysql::scheduler::Scheduler::Scheduler	(	Thread_pool_ptr	shared_thread_pool,
		Scheduler_clock_ptr	shared_clock,
		Dependency_tracker_ptr	dependency_tracker,
		int	instance_id = `0`,
		std::size_t	allowed_task_count = `std::numeric_limits<std::size_t>::max()`,
		Scheduler_psi	psi_params = `{}`
	)

Constructor.

Parameters

shared_thread_pool	Shared thread pool
shared_clock	Shared scheduler clock
dependency_tracker	Dependency tracker
instance_id	Unique instance id for statistics monitoring
allowed_task_count	Sets the number of ongoing tasks limit to selected number. If the number of tasks reaches this number, scheduler will synchronize to reach 25% of allowed_count tasks
psi_params	PSI parameters

Member Function Documentation

◆ add_dependency()

bool mysql::scheduler::Scheduler::add_dependency	(	const Task_id &	predecessor,
		const Task_id &	successor
	)

protected

add_dependency

Parameters

predecessor	Predecessor task ID
successor	Sucessor task ID

Add dependency function

Return values

true	Dependency added successfully
false	Failed to add dependency

◆ are_phase_queues_empty()

bool mysql::scheduler::Scheduler::are_phase_queues_empty ( ) const

protected

Checks phase queues and return true if all are empty.

Returns: True if all phase queues are empty, false otherwise

◆ callback()

template<typename Repeatable_task_type >

Task_result mysql::scheduler::Scheduler::callback	(	Task_schedule_ptr	schedule,
		Scheduler_clock::Time_point_t	task_delay,
		bool	task_error,
		std::shared_ptr< Repeatable_task_type >	repeatable_task,
		unsigned int	current_thread_id
	)

protected

Function used to notify that task ended its execution.

Parameters

schedule	Task schedule, containing current phase information
task_delay	Delay of the whole task w.r.t. scheduler clock
task_error	True if enqueued task returned an error, false otherwise
repeatable_task	Shared repeatable task state
current_thread_id	THP id of the currently executing thread

Returns: Task result

◆ callback_phase()

Task_result mysql::scheduler::Scheduler::callback_phase	(	Task_schedule_ptr	schedule,
		bool	task_error,
		unsigned int	phase_id
	)

protected

Function used to notify that task phase ended its execution.

Parameters

schedule	Task schedule
task_error	True if enqueued task returned an error, false otherwise
phase_id	Executed phase sequence number

Returns: Task result

◆ deinit()

void mysql::scheduler::Scheduler::deinit ( )

Ends the scheduler if stop was not yet requested.

◆ end_execution()

void mysql::scheduler::Scheduler::end_execution ( )

protected

end_execution

◆ enqueue()

template<typename FType , typename... Args>

bool mysql::scheduler::Scheduler::enqueue	(	Task_schedule_ptr	schedule,
		FType &&	task,
		Args &&...	args
	)

Enqueues a task.

Function adding task to the scheduler

Template Parameters

FType	Functor type
Args	Functor arguments parameter pack type

Parameters

schedule	Pointer to task schedule
task	Functor to execute
args	Functor arguments

Returns: True on success, false otherwise

◆ enqueue_after()

template<typename FType , typename... Args>

bool mysql::scheduler::Scheduler::enqueue_after	(	const Task_id &	predecessor,
		Task_schedule_ptr	schedule,
		FType &&	task,
		Args &&...	args
	)

Enqueues a task that should execute after a predecessor task finishes.

Function adding task to the scheduler

Template Parameters

FType	Functor type
Args	Functor arguments parameter pack type

Parameters

predecessor	Task id that should execute prior to the task
schedule	Pointer to task schedule
task	Functor to execute
args	Functor arguments

Returns: True on success, false otherwise

◆ enqueue_helper()

bool mysql::scheduler::Scheduler::enqueue_helper ( Scheduled_task && task )

protected

Enqueue helper.

Puts Scheduled task object into the task queue

Parameters

task	Scheduled task rvalue reference

Returns: True if enqueue succeeded

◆ enqueue_internal()

template<typename FType , typename... Args>

bool mysql::scheduler::Scheduler::enqueue_internal	(	Task_schedule_ptr	schedule,
		FType &&	task,
		Args &&...	args
	)

protected

Enqueues a task identified by the task_id.

Function adding task to the scheduler

Template Parameters

FType	Functor type
Args	Functor arguments parameter pack type

Parameters

schedule	Pointer to task schedule
task	Functor to execute
args	Functor arguments

Returns: Task identifier; True if enqueue succeeded, false otherwise

◆ enqueue_phase()

template<typename Repeatable_task_type >

bool mysql::scheduler::Scheduler::enqueue_phase	(	Task_schedule_ptr	schedule,
		Scheduler_clock::Time_point_t	task_delay,
		std::shared_ptr< Repeatable_task_type >	repeatable_task,
		unsigned int	current_thread_id,
		unsigned int	phase_id
	)

protected

Function that enqueues next task phase.

Parameters

schedule	Task schedule, containing current phase information
task_delay	Delay of the whole task w.r.t. scheduler clock
repeatable_task	Shared repeatable task state for this phase
current_thread_id	THP id of the currently executing thread
phase_id	Enqueued phase sequence number

◆ ensure_space()

bool mysql::scheduler::Scheduler::ensure_space ( )

Ensure space for the next task (eliminates possible wait in the enqueue)

Returns: True if space is available. False otherwise.

◆ get_phase_queue()

Scheduler::Task_queue_type & mysql::scheduler::Scheduler::get_phase_queue ( Scheduler_clock_ptr phase_clock )

protected

◆ get_phase_queue_lock()

Scheduler::Mutex_type & mysql::scheduler::Scheduler::get_phase_queue_lock ( Scheduler_clock_ptr phase_clock )

protected

◆ get_scheduled_tasks_count()

std::size_t mysql::scheduler::Scheduler::get_scheduled_tasks_count ( ) const

Obtain the number of scheduled, ongoing tasks.

Returns: the number of scheduled, ongoing tasks

◆ get_timeouts()

std::size_t mysql::scheduler::Scheduler::get_timeouts ( ) const

Access "timeouts" observability statistics - the number of times scheduler timed out while waiting for tasks to schedule.

◆ handle_error()

void mysql::scheduler::Scheduler::handle_error ( )

protected

Worker error handling function.

◆ is_error()

bool mysql::scheduler::Scheduler::is_error ( ) const

Internal function to check on whether error has been set.

◆ is_stop_requested()

bool mysql::scheduler::Scheduler::is_stop_requested ( ) const

protected

Internal function to check if immediate stop was requested, externally or due to an error.

Returns: True if scheduler needs to stop now, false otherwise

◆ is_task_phase_ready()

bool mysql::scheduler::Scheduler::is_task_phase_ready ( ) const

protected

Checks whether any phase of the task is ready for execution.

Returns: True if any task phase is ready for execution, false otherwise

◆ is_task_ready()

bool mysql::scheduler::Scheduler::is_task_ready ( ) const

protected

Helper function to check if the task at the top of the task queue is ready.

Returns: True in case a task is ready

◆ notify_scheduler()

void mysql::scheduler::Scheduler::notify_scheduler ( )

Function used to notify scheduler thread by the other thread (enqueueing thread / worker poll thread)

◆ register_phase()

bool mysql::scheduler::Scheduler::register_phase ( Scheduler_clock_ptr phase_clock )

Register task phase run according to the given clock.

Parameters

phase_clock Phase clock for the task phase

Returns: True if phase was registered. False otherwise

◆ request_unblock()

void mysql::scheduler::Scheduler::request_unblock ( )

This function requests unblocking of the scheduler.

After this call, the scheduler will try to unblock the workflow

◆ run_main_thread()

void mysql::scheduler::Scheduler::run_main_thread ( )

protected

Scheduler run function.

Function for the thread which schedules tasks for execution

◆ scheduler_clean_up()

void mysql::scheduler::Scheduler::scheduler_clean_up ( )

protected

Scheduler error handling function.

◆ stop_now()

void mysql::scheduler::Scheduler::stop_now ( )

Instruct the scheduler to stop now and withdraw all work.

◆ synchronize()

bool mysql::scheduler::Scheduler::synchronize	(	bool	force = `true`,
		bool	print_checkpoint = `false`
	)

This function waits for currently fired tasks to finish (blocking)

Parameters

force	If enabled, wait for tasks even in case of error or stop requested
print_checkpoint	Prints diagnostics during waiting

Return values

true	Successfully synchronized
false	Stopped while waiting

◆ synchronize_active()

void mysql::scheduler::Scheduler::synchronize_active	(	bool	print_checkpoint,
		std::size_t	expected,
		bool	force
	)

protected

Synchronizes the scheduler by actively waiting for finished tasks count.

Parameters

print_checkpoint	Prints diagnostics during waiting
expected	Expected scheduled task count after synchronization
force	When true, force synchronization regardless of errors / stop requests

◆ synchronize_active_partial()

void mysql::scheduler::Scheduler::synchronize_active_partial ( bool print_checkpoint )

protected

Actively waits for percent of tasks to finish.

This function is called to reduce contention if clock queue is full. Instead of syncing after one pop(), we are allowing the scheduler to process portion of tasks. To boost performance, we wait only for a percent of tasks to finish

Parameters

print_checkpoint Prints diagnostics during waiting

◆ synchronize_partial()

void mysql::scheduler::Scheduler::synchronize_partial ( bool print_checkpoint = false )

protected

Waits for percent of tasks to finish.

This function is called to reduce contention if clock queue is full. Instead of syncing after one pop(), we are allowing the scheduler to process portion of tasks. To boost performance, we wait only for a percent of tasks to finish. Partial waiting is available only for the active synchronization method, which is a default one

Parameters

print_checkpoint Prints diagnostics during waiting

◆ wait_for_scheduler_thread_to_stop()

void mysql::scheduler::Scheduler::wait_for_scheduler_thread_to_stop ( )

protected

Waits for scheduler thread to finish its work.

◆ wait_until_done()

void mysql::scheduler::Scheduler::wait_until_done ( )

protected

Member Data Documentation

◆ m_allowed_task_count

std::atomic<std::size_t> mysql::scheduler::Scheduler::m_allowed_task_count

private

Initial value:

{

std::numeric_limits<std::size_t>::max()}

mrs::database::inner::max

ValueType max(X &&first)

Definition: gtid.h:103

Maximum allowed number of tasks active in the scheduler.

Above this threshold, provider will block and wait (synchronize_partial)

◆ m_cv_end

concurrency::Condition_variable mysql::scheduler::Scheduler::m_cv_end

private

cv used by a thread requesting scheduler to finish its work

◆ m_cv_scheduler

concurrency::Condition_variable mysql::scheduler::Scheduler::m_cv_scheduler

private

Cv used by the scheduler main thread to wait on, when no task is available or tasks in m_task queue are not read to execute.

◆ m_deinitialized

std::atomic<bool> mysql::scheduler::Scheduler::m_deinitialized {false}

private

Ensures deinit() is executed only once.

◆ m_dependencies

Dependency_tracker_ptr mysql::scheduler::Scheduler::m_dependencies

private

Task dependencies, used mainly to implement dependencies between events in one transaction or between commit event and parent transaction last event (to disallow a transaction to enter a commit when a parent transaction, i.e.

commit order parent id, did not finish its execution

◆ m_instance_id

unsigned int mysql::scheduler::Scheduler::m_instance_id {0}

private

Instance id.

◆ m_is_error

std::atomic_flag mysql::scheduler::Scheduler::m_is_error = ATOMIC_FLAG_INIT

private

◆ m_mutex_end

Mutex_type mysql::scheduler::Scheduler::m_mutex_end

mutableprivate

Mutex used to finish execution of the Scheduler, protects m_scheduler_thread_active and it is used together with m_cv_end.

◆ m_mutex_notification

Mutex_type mysql::scheduler::Scheduler::m_mutex_notification

mutableprivate

Mutex protecting access to scheduler notifications.

◆ m_mutex_phases

Mutex_type mysql::scheduler::Scheduler::m_mutex_phases

mutableprivate

This mutex protect access to phase.

◆ m_mutex_tasks

Mutex_type mysql::scheduler::Scheduler::m_mutex_tasks

mutableprivate

Mutex protecting access to m_tasks, data structure populated by the enqueuing thread.

◆ m_notification

std::atomic<bool> mysql::scheduler::Scheduler::m_notification {false}

private

True if scheduler has been notified.

Used to release mutex before calling notify on cv, which would cause a thread to wake up and block immediately

Protected by m_mutex_scheduler

◆ m_notified_tasks

container::Integrals_lockfree_queue<uint64_t> mysql::scheduler::Scheduler::m_notified_tasks

private

Lock-free queue of task IDs that are ready for execution.

◆ m_psi

Scheduler_psi mysql::scheduler::Scheduler::m_psi

private

PSI parameters.

◆ m_scheduled_tasks_cnt

std::atomic<std::size_t> mysql::scheduler::Scheduler::m_scheduled_tasks_cnt {0}

private

The number of scheduled tasks.

◆ m_scheduler_active

std::atomic<bool> mysql::scheduler::Scheduler::m_scheduler_active {true}

private

Variable that checks whether scheduler should run (true) or end its execution (false)

◆ m_scheduler_clock

Scheduler_clock_ptr mysql::scheduler::Scheduler::m_scheduler_clock

private

Scheduler clock.

◆ m_scheduler_thread

Thread_type mysql::scheduler::Scheduler::m_scheduler_thread

private

Scheduler main thread.

◆ m_scheduler_thread_active

bool mysql::scheduler::Scheduler::m_scheduler_thread_active {true}

private

Variable indicating that scheduler thread finished its execution, protected with m_mutex_end.

◆ m_stat_monitor

Statistics_instance_monitor_ref mysql::scheduler::Scheduler::m_stat_monitor

private

Statistics monitoring object for the current instance.

◆ m_status

std::atomic<Scheduler_status> mysql::scheduler::Scheduler::m_status {Scheduler_status::idle}

private

Observability variables.

◆ m_stop_now

std::atomic<bool> mysql::scheduler::Scheduler::m_stop_now {false}

private

Variable that instructs scheduler to withdraw all work and stop.

◆ m_task_phases

std::unordered_map<Scheduler_clock_ptr, Task_queue_type> mysql::scheduler::Scheduler::m_task_phases

private

Tasks may be divided into phases, each phase works according to a defined clock, registered with "register_phase" function.

This map holds all registered phases: phase clock (key) and associated phase queue, in which task phases wait for their phase dependencies (defined by the clock) to finish. As an example, task may be divided into "apply" phase and "commit" phase. "commit" phase works with additional start-to-start commit order dependencies (register workers in order of their commit order).

◆ m_task_phases_locks

std::unordered_map<Scheduler_clock_ptr, Mutex_type> mysql::scheduler::Scheduler::m_task_phases_locks

private

◆ m_tasks

std::priority_queue<Scheduled_task> mysql::scheduler::Scheduler::m_tasks

private

This is a queue which holds task ready for scheduling.

The lower scheduled time for a task, the higher the task priority. This queue is used by 2 threads, task provider and scheduler main thread. We synchronize it with m_mutex_scheduler

◆ m_tasks_waiting_for_deps

std::unordered_map<Task_id, Scheduled_task> mysql::scheduler::Scheduler::m_tasks_waiting_for_deps

private

Internal map that keeps tasks waiting for dependencies defined in the Dependency Graph (distinct from time dependencies implemented in the Scheduler clock)

◆ m_thread_pool

Thread_pool_ptr mysql::scheduler::Scheduler::m_thread_pool

private

Thread pool with threads that execute tasks.

◆ m_timeouts

std::atomic<std::size_t> mysql::scheduler::Scheduler::m_timeouts {0}

private

◆ m_unblock_request

std::atomic<bool> mysql::scheduler::Scheduler::m_unblock_request {0}

private

Stores unblock requests from external threads, will allow N task to enter phase.

◆ m_wait_for_task_limit

bool mysql::scheduler::Scheduler::m_wait_for_task_limit {false}

private

Information on whether enqueueing thread is waiting for available task count limit.

We allow for dirty reads.

◆ sync_method

constexpr Sync_method mysql::scheduler::Scheduler::sync_method {Sync_method::active}

staticconstexpr

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

libs/mysql/scheduler/scheduler.h
libs/mysql/scheduler/scheduler.cpp
libs/mysql/scheduler/scheduler_impl.hpp

Public Types

Public Member Functions

Static Public Attributes

Protected Types

Protected Member Functions

Private Types

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Futures_list

◆ Mutex_type

◆ Scheduled_task_type

◆ Task_future

◆ Task_queue_type

◆ Task_return_type

◆ Thread_pool_ptr

◆ Thread_pool_type

◆ Thread_type

Constructor & Destructor Documentation

◆ ~Scheduler()

◆ Scheduler() [1/2]

◆ Scheduler() [2/2]

Member Function Documentation

◆ add_dependency()

◆ are_phase_queues_empty()

◆ callback()

◆ callback_phase()

◆ deinit()

◆ end_execution()

◆ enqueue()

◆ enqueue_after()

◆ enqueue_helper()

◆ enqueue_internal()

◆ enqueue_phase()

◆ ensure_space()

◆ get_phase_queue()

◆ get_phase_queue_lock()

◆ get_scheduled_tasks_count()

◆ get_timeouts()

◆ handle_error()

◆ is_error()

◆ is_stop_requested()

◆ is_task_phase_ready()

◆ is_task_ready()

◆ notify_scheduler()

◆ register_phase()

◆ request_unblock()

◆ run_main_thread()

◆ scheduler_clean_up()

◆ stop_now()

◆ synchronize()

◆ synchronize_active()

◆ synchronize_active_partial()

◆ synchronize_partial()

◆ wait_for_scheduler_thread_to_stop()

◆ wait_until_done()

Member Data Documentation

◆ m_allowed_task_count

◆ m_cv_end

◆ m_cv_scheduler

◆ m_deinitialized

◆ m_dependencies

◆ m_instance_id

◆ m_is_error

◆ m_mutex_end

◆ m_mutex_notification

◆ m_mutex_phases

◆ m_mutex_tasks

◆ m_notification

◆ m_notified_tasks

◆ m_psi

◆ m_scheduled_tasks_cnt

◆ m_scheduler_active

◆ m_scheduler_clock

◆ m_scheduler_thread

◆ m_scheduler_thread_active

◆ m_stat_monitor

◆ m_status

◆ m_stop_now

◆ m_task_phases