This template maintains the registry of tasks, with specific object types. More...

#include <task_registry.h>

Classes
struct	Entry

Public Types
using	Task_object = Task_object_type

using	Task_object_ptr = std::unique_ptr< Task_object >

using	Mt_key = concurrency::Mutex_key

using	Mutex = concurrency::Mutex

Public Member Functions
	Task_registry (Task_registry_psi psi_params={})

void	init (std::size_t capacity)

	Task_registry (std::size_t capacity, Task_registry_psi psi_params={})

void	deinit ()

	~Task_registry ()

template<typename T >
bool	apply (Task_id_type id, T &&func)
	Calls 'func' on a given task object. More...

template<typename T >
void	activate_and_apply (Task_id_type id, T &&func)
	Unconditionally activates and calls 'func' on a given task object. More...

bool	check_active (Task_id_type id)

template<typename T >
void	apply_on_active (T &&func)
	Calls 'func' on each registered task object. More...

bool	register_entry (Task_id_type id, Task_object &&obj)
	Function that registers a task, making it active. More...

bool	activate_entry (Task_id_type id)
	Function activates already registered entry. More...

bool	activate_or_wait (Task_id_type id)
	Function activates already registered entry, if entry is active it waits until its state changes to inactive. More...

const Task_object &	get_ref (Task_id_type id)
	Gets ref of internal object. More...

Task_object &	get (Task_id_type id)
	Unprotected access to task object. Firstly obtain the guard. More...

auto	scoped_lock (Task_id_type id)

Task_object &	lock (Task_id_type id)

void	unlock (Task_id_type id)

bool	deactivate_entry (Task_id_type id)
	Function that unregisters a task, making it inactive. More...

template<typename Functor >
bool	deactivate_entry (Task_id_type id, Functor &&func)
	Function that unregisters a task, making it inactive, with functor. More...

std::optional< Task_object >	get_and_deactivate_entry (Task_id_type id)
	Function that unregisters a task, making it inactive, returns handled object if deactivation succeeded. More...

Static Public Attributes
static constexpr std::size_t	cache_line_size

static constexpr std::size_t	default_capacity = 16384

Private Types
using	Entry_ptr = std::unique_ptr< Entry >

Private Member Functions
void	init_tasks ()

Entry_ptr &	get_entry (Task_id_type id)

Private Attributes
std::size_t	m_capacity {0}

std::vector< Entry_ptr, mysql::allocators::Allocator< Entry_ptr > >	m_tasks

bool	m_initialized {false}

Task_registry_psi	m_psi

Detailed Description

template<typename Task_id_type, typename Task_object_type>
class mysql::scheduler::Task_registry< Task_id_type, Task_object_type >

This template maintains the registry of tasks, with specific object types.

Those objects can be accessed simultaneously by different threads, as long as different threads access different task ids.

Member Typedef Documentation

◆ Entry_ptr

template<typename Task_id_type , typename Task_object_type >

using mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::Entry_ptr = std::unique_ptr<Entry>

private

◆ Mt_key

template<typename Task_id_type , typename Task_object_type >

using mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::Mt_key = concurrency::Mutex_key

◆ Mutex

template<typename Task_id_type , typename Task_object_type >

using mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::Mutex = concurrency::Mutex

◆ Task_object

template<typename Task_id_type , typename Task_object_type >

using mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::Task_object = Task_object_type

◆ Task_object_ptr

template<typename Task_id_type , typename Task_object_type >

using mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::Task_object_ptr = std::unique_ptr<Task_object>

Constructor & Destructor Documentation

◆ Task_registry() [1/2]

template<typename Task_id_type , typename Task_object_type >

mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::Task_registry ( Task_registry_psi psi_params = {} )

inline

◆ Task_registry() [2/2]

template<typename Task_id_type , typename Task_object_type >

mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::Task_registry	(	std::size_t	capacity,
		Task_registry_psi	psi_params = `{}`
	)

inline

◆ ~Task_registry()

template<typename Task_id_type , typename Task_object_type >

mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::~Task_registry ( )

inline

Member Function Documentation

◆ activate_and_apply()

template<typename Task_id_type , typename Task_object_type >

template<typename T >

void mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::activate_and_apply	(	Task_id_type	id,
		T &&	func
	)

inline

Unconditionally activates and calls 'func' on a given task object.

Parameters

id	Task id
func	function to be applied on a given registered task

◆ activate_entry()

template<typename Task_id_type , typename Task_object_type >

bool mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::activate_entry ( Task_id_type id )

inline

Function activates already registered entry.

◆ activate_or_wait()

template<typename Task_id_type , typename Task_object_type >

bool mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::activate_or_wait ( Task_id_type id )

inline

Function activates already registered entry, if entry is active it waits until its state changes to inactive.

◆ apply()

template<typename Task_id_type , typename Task_object_type >

template<typename T >

bool mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::apply	(	Task_id_type	id,
		T &&	func
	)

inline

Calls 'func' on a given task object.

Parameters

id	Task id
func	function to be applied on a given registered task

Returns: true in case task was active and apply succeeded, false otherwise

◆ apply_on_active()

template<typename Task_id_type , typename Task_object_type >

template<typename T >

void mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::apply_on_active ( T && func )

inline

Calls 'func' on each registered task object.

Don't call when a new task can be activated, also, this is ineffective, but we don't expect to call this

Parameters

func	function to be applied on each, active task

◆ check_active()

template<typename Task_id_type , typename Task_object_type >

bool mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::check_active ( Task_id_type id )

inline

◆ deactivate_entry() [1/2]

template<typename Task_id_type , typename Task_object_type >

bool mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::deactivate_entry ( Task_id_type id )

inline

Function that unregisters a task, making it inactive.

◆ deactivate_entry() [2/2]

template<typename Task_id_type , typename Task_object_type >

template<typename Functor >

bool mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::deactivate_entry	(	Task_id_type	id,
		Functor &&	func
	)

inline

Function that unregisters a task, making it inactive, with functor.

Parameters

id	Id of the task
func	Functor to call on the task object before deactivation, returns bool indicating whether to deactivate

◆ deinit()

template<typename Task_id_type , typename Task_object_type >

void mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::deinit ( )

inline

◆ get()

template<typename Task_id_type , typename Task_object_type >

Task_object & mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::get ( Task_id_type id )

inline

Unprotected access to task object. Firstly obtain the guard.

◆ get_and_deactivate_entry()

template<typename Task_id_type , typename Task_object_type >

std::optional< Task_object > mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::get_and_deactivate_entry ( Task_id_type id )

inline

Function that unregisters a task, making it inactive, returns handled object if deactivation succeeded.

Returns: Handled object if deactivation succeeded, empty object otherwise.

◆ get_entry()

template<typename Task_id_type , typename Task_object_type >

Entry_ptr & mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::get_entry ( Task_id_type id )

inlineprivate

◆ get_ref()

template<typename Task_id_type , typename Task_object_type >

const Task_object & mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::get_ref ( Task_id_type id )

inline

Gets ref of internal object.

Parameters

id Task id

Returns: copy of internal task object

◆ init()

template<typename Task_id_type , typename Task_object_type >

void mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::init ( std::size_t capacity )

inline

◆ init_tasks()

template<typename Task_id_type , typename Task_object_type >

void mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::init_tasks ( )

inlineprivate

◆ lock()

template<typename Task_id_type , typename Task_object_type >

Task_object & mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::lock ( Task_id_type id )

inline

◆ register_entry()

template<typename Task_id_type , typename Task_object_type >

bool mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::register_entry	(	Task_id_type	id,
		Task_object &&	obj
	)

inline

Function that registers a task, making it active.

◆ scoped_lock()

template<typename Task_id_type , typename Task_object_type >

auto mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::scoped_lock ( Task_id_type id )

inline

◆ unlock()

template<typename Task_id_type , typename Task_object_type >

void mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::unlock ( Task_id_type id )

inline

Member Data Documentation

◆ cache_line_size

template<typename Task_id_type , typename Task_object_type >

constexpr std::size_t mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::cache_line_size

staticconstexpr

Initial value:

=

mysql::concurrency::detail::hardware_destructive_interference_size

constexpr std::size_t hardware_destructive_interference_size

Definition: cache_line_size.h:42

◆ default_capacity

template<typename Task_id_type , typename Task_object_type >

constexpr std::size_t mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::default_capacity = 16384

staticconstexpr

◆ m_capacity

template<typename Task_id_type , typename Task_object_type >

std::size_t mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::m_capacity {0}

private

◆ m_initialized

template<typename Task_id_type , typename Task_object_type >

bool mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::m_initialized {false}

private

◆ m_psi

template<typename Task_id_type , typename Task_object_type >

Task_registry_psi mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::m_psi

private

◆ m_tasks

template<typename Task_id_type , typename Task_object_type >

std::vector<Entry_ptr, mysql::allocators::Allocator<Entry_ptr> > mysql::scheduler::Task_registry< Task_id_type, Task_object_type >::m_tasks

private

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

libs/mysql/scheduler/task_registry.h

Classes

Public Types

Public Member Functions

Static Public Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Entry_ptr

◆ Mt_key

◆ Mutex

◆ Task_object

◆ Task_object_ptr

Constructor & Destructor Documentation

◆ Task_registry() [1/2]

◆ Task_registry() [2/2]

◆ ~Task_registry()

Member Function Documentation

◆ activate_and_apply()

◆ activate_entry()

◆ activate_or_wait()

◆ apply()

◆ apply_on_active()

◆ check_active()

◆ deactivate_entry() [1/2]

◆ deactivate_entry() [2/2]

◆ deinit()

◆ get()

◆ get_and_deactivate_entry()

◆ get_entry()

◆ get_ref()

◆ init()

◆ init_tasks()

◆ lock()

◆ register_entry()

◆ scoped_lock()

◆ unlock()

Member Data Documentation

◆ cache_line_size

◆ default_capacity

◆ m_capacity

◆ m_initialized

◆ m_psi

◆ m_tasks