Namespace cubthread¶

Classes¶

Type	Name
class	callable_task <typename Context>
class	callable_task< void > <>
class	daemon
class	daemon_entry_manager
class	entry
class	entry_manager
class	lockfree_hashmap <class Key, class T>
class	looper
class	manager
class	system_worker_entry_manager
class	task <typename Context>
class	task< void > <>
struct	wait_duration <class D>
class	waiter
class	worker_pool
class	worker_pool_impl <Stats>
class	worker_pool_task_capper

Public Types¶

Type	Name
typedef std::chrono::system_clock::duration	delta_time
typedef callable_task< entry >	entry_callable_task
typedef task< entry >	entry_task
typedef std::function< void(bool &, delta_time &)>	period_function
typedef cubthread::worker_pool_impl< true >	stats_worker_pool_type
typedef task< void >	task_without_context
typedef wait_duration< std::chrono::seconds >	wait_seconds
typedef cubthread::worker_pool_impl< false >	worker_pool_type

Public Attributes¶

Type	Name
const std::size_t	ALLOC_TRACK_MAX_ITEMS = `32767`
const char *	ALLOC_TRACK_NAME = `"Virtual [Memory"](broker__monitor_8c.md#function-timeout)`
const char *	ALLOC_TRACK_RES_NAME = `"res\_ptr"`
const bool	Is_single_thread = `[false](broker__monitor_8c.md#function-timeout)`
const int	LOG_DAEMON_ALL = `0xFFFF0000`
const int	LOG_DAEMON_VACUUM = `0x10000`
const int	LOG_MANAGER = `0x1`
const int	LOG_MANAGER_ALL = `0xFF`
const int	LOG_WORKER_POOL_ALL = `0xFF00`
const int	LOG_WORKER_POOL_CONNECTIONS = `0x200`
const int	LOG_WORKER_POOL_INDEX_BUILDER = `0x800`
const int	LOG_WORKER_POOL_TRAN_WORKERS = `0x400`
const int	LOG_WORKER_POOL_VACUUM = `0x100`
const std::size_t	MAX_LOOPER_PERIODS = `3`
const unsigned	PGBUF_TRACK_MAX_AMOUNT = `16`
const std::size_t	PGBUF_TRACK_MAX_ITEMS = `1024`
const char *	PGBUF_TRACK_NAME = `"Page [Buffer"](broker__monitor_8c.md#function-timeout)`
const char *	PGBUF_TRACK_RES_NAME = `"pgptr"`
thread_local entry *	tl_Entry_p = `[NULL](freelistheap_8h.md#define-null)`

Public Static Attributes¶

Type	Name
const cubperf::statset_definition	Daemon_statistics = `/* multi line expression */`
const bool	ENABLE_TRACKERS = `/* multi line expression */`
bool	FORCE_THREAD_ALWAYS_ALIVE = `[false](broker__monitor_8c.md#function-timeout)`
const cubperf::statset_definition	Looper_statistics = `/* multi line expression */`
entry *	Main_entry_p = `[NULL](freelistheap_8h.md#define-null)`
manager *	Manager = `[NULL](freelistheap_8h.md#define-null)`
const cubperf::stat_id	STAT_AWAKEN_COUNT_AND_TIME = `4`
const cubperf::stat_id	STAT_LOCK_WAKEUP_COUNT = `0`
cubperf::stat_id	STAT_LOOPER_RESET_COUNT = `1`
const cubperf::stat_id	STAT_LOOPER_SLEEP_COUNT_AND_TIME = `0`
const cubperf::stat_id	STAT_LOOP_EXECUTE_COUNT_AND_TIME = `0`
const cubperf::stat_id	STAT_LOOP_PAUSE_TIME = `1`
const cubperf::stat_id	STAT_NO_SLEEP_COUNT = `3`
const cubperf::stat_id	STAT_SLEEP_COUNT = `1`
const cubperf::stat_id	STAT_TIMEOUT_COUNT = `2`
const char *	STAT_WAKEUP_CALL_COUNT_NAME = `"waiter\_wakeup\_count"`
const cubperf::statset_definition	Waiter_statistics = `/* multi line expression */`

Public Functions¶

Type	Name
void	check_not_single_thread (void)
void	clear_thread_local_entry (void)
void	condvar_wait (std::condition_variable & condvar, std::unique_lock< std::mutex > & lock, const wait_duration< D > & duration)
bool	condvar_wait (std::condition_variable & condvar, std::unique_lock< std::mutex > & lock, const wait_duration< D > & duration, P pred)
void	finalize (void)
entry &	get_entry (void)
manager *	get_manager (void)
std::size_t	get_max_thread_count (void)
lockfree::tran::system &	get_thread_entry_lftransys ()
void	initialize (entry *& my_entry)
int	initialize_thread_entries (bool with_lock_free)
bool	is_logging_configured (const int logging_flag)
bool	is_single_thread (void)
void	return_lock_free_transaction_entries (void)
void	set_thread_local_entry (entry & tl_entry)
std::size_t	system_core_count (void)
void	wp_call_func_throwing_system_error (const char * message, Func & func)
void	wp_handle_system_error (const char * message, const std::system_error & e)
bool	wp_is_thread_always_alive_forced ()
void	wp_set_force_thread_always_alive ()

Public Types Documentation¶

typedef delta_time¶

typedef std::chrono::system_clock::duration cubthread::delta_time;

typedef entry_callable_task¶

using cubthread::entry_callable_task = typedef callable_task<entry>;

typedef entry_task¶

using cubthread::entry_task = typedef task<entry>;

typedef period_function¶

typedef std::function<void (bool &, delta_time &)> cubthread::period_function;

typedef stats_worker_pool_type¶

using cubthread::stats_worker_pool_type = typedef cubthread::worker_pool_impl<true>;

typedef task_without_context¶

using cubthread::task_without_context = typedef task<void>;

typedef wait_seconds¶

using cubthread::wait_seconds = typedef wait_duration<std::chrono::seconds>;

typedef worker_pool_type¶

using cubthread::worker_pool_type = typedef cubthread::worker_pool_impl<false>;

Public Attributes Documentation¶

variable ALLOC_TRACK_MAX_ITEMS¶

const std::size_t cubthread::ALLOC_TRACK_MAX_ITEMS;

variable ALLOC_TRACK_NAME¶

const char* cubthread::ALLOC_TRACK_NAME;

variable ALLOC_TRACK_RES_NAME¶

const char* cubthread::ALLOC_TRACK_RES_NAME;

variable Is_single_thread¶

const bool cubthread::Is_single_thread;

variable LOG_DAEMON_ALL¶

const int cubthread::LOG_DAEMON_ALL;

variable LOG_DAEMON_VACUUM¶

const int cubthread::LOG_DAEMON_VACUUM;

variable LOG_MANAGER¶

const int cubthread::LOG_MANAGER;

variable LOG_MANAGER_ALL¶

const int cubthread::LOG_MANAGER_ALL;

variable LOG_WORKER_POOL_ALL¶

const int cubthread::LOG_WORKER_POOL_ALL;

variable LOG_WORKER_POOL_CONNECTIONS¶

const int cubthread::LOG_WORKER_POOL_CONNECTIONS;

variable LOG_WORKER_POOL_INDEX_BUILDER¶

const int cubthread::LOG_WORKER_POOL_INDEX_BUILDER;

variable LOG_WORKER_POOL_TRAN_WORKERS¶

const int cubthread::LOG_WORKER_POOL_TRAN_WORKERS;

variable LOG_WORKER_POOL_VACUUM¶

const int cubthread::LOG_WORKER_POOL_VACUUM;

variable MAX_LOOPER_PERIODS¶

const std::size_t cubthread::MAX_LOOPER_PERIODS;

variable PGBUF_TRACK_MAX_AMOUNT¶

const unsigned cubthread::PGBUF_TRACK_MAX_AMOUNT;

variable PGBUF_TRACK_MAX_ITEMS¶

const std::size_t cubthread::PGBUF_TRACK_MAX_ITEMS;

variable PGBUF_TRACK_NAME¶

const char* cubthread::PGBUF_TRACK_NAME;

variable PGBUF_TRACK_RES_NAME¶

const char* cubthread::PGBUF_TRACK_RES_NAME;

variable tl_Entry_p¶

thread_local entry* cubthread::tl_Entry_p;

Public Static Attributes Documentation¶

variable Daemon_statistics¶

const cubperf::statset_definition cubthread::Daemon_statistics;

variable ENABLE_TRACKERS¶

const bool cubthread::ENABLE_TRACKERS;

variable FORCE_THREAD_ALWAYS_ALIVE¶

bool cubthread::FORCE_THREAD_ALWAYS_ALIVE;

variable Looper_statistics¶

const cubperf::statset_definition cubthread::Looper_statistics;

variable Main_entry_p¶

entry* cubthread::Main_entry_p;

variable Manager¶

manager* cubthread::Manager;

variable STAT_AWAKEN_COUNT_AND_TIME¶

const cubperf::stat_id cubthread::STAT_AWAKEN_COUNT_AND_TIME;

variable STAT_LOCK_WAKEUP_COUNT¶

const cubperf::stat_id cubthread::STAT_LOCK_WAKEUP_COUNT;

variable STAT_LOOPER_RESET_COUNT¶

cubperf::stat_id cubthread::STAT_LOOPER_RESET_COUNT;

variable STAT_LOOPER_SLEEP_COUNT_AND_TIME¶

const cubperf::stat_id cubthread::STAT_LOOPER_SLEEP_COUNT_AND_TIME;

variable STAT_LOOP_EXECUTE_COUNT_AND_TIME¶

const cubperf::stat_id cubthread::STAT_LOOP_EXECUTE_COUNT_AND_TIME;

variable STAT_LOOP_PAUSE_TIME¶

const cubperf::stat_id cubthread::STAT_LOOP_PAUSE_TIME;

variable STAT_NO_SLEEP_COUNT¶

const cubperf::stat_id cubthread::STAT_NO_SLEEP_COUNT;

variable STAT_SLEEP_COUNT¶

const cubperf::stat_id cubthread::STAT_SLEEP_COUNT;

variable STAT_TIMEOUT_COUNT¶

const cubperf::stat_id cubthread::STAT_TIMEOUT_COUNT;

variable STAT_WAKEUP_CALL_COUNT_NAME¶

const char* cubthread::STAT_WAKEUP_CALL_COUNT_NAME;

variable Waiter_statistics¶

const cubperf::statset_definition cubthread::Waiter_statistics;

Public Functions Documentation¶

function check_not_single_thread¶

void cubthread::check_not_single_thread (
    void
)

function clear_thread_local_entry¶

void cubthread::clear_thread_local_entry (
    void
)

function condvar_wait¶

template<typename  D>
void cubthread::condvar_wait (
    std::condition_variable & condvar,
    std::unique_lock< std::mutex > & lock,
    const  wait_duration < D > & duration
)

function condvar_wait¶

template<typename  D, typename P>
bool cubthread::condvar_wait (
    std::condition_variable & condvar,
    std::unique_lock< std::mutex > & lock,
    const  wait_duration < D > & duration,
    P pred
)

function finalize¶

void cubthread::finalize (
    void
)

function get_entry¶

entry & cubthread::get_entry (
    void
)

function get_manager¶

manager * cubthread::get_manager (
    void
)

function get_max_thread_count¶

std::size_t cubthread::get_max_thread_count (
    void
)

function get_thread_entry_lftransys¶

lockfree::tran::system & cubthread::get_thread_entry_lftransys ()

function initialize¶

void cubthread::initialize (
    entry *& my_entry
)

function initialize_thread_entries¶

int cubthread::initialize_thread_entries (
    bool with_lock_free
)

function is_logging_configured¶

bool cubthread::is_logging_configured (
    const  int logging_flag
)

function is_single_thread¶

bool cubthread::is_single_thread (
    void
)

function return_lock_free_transaction_entries¶

void cubthread::return_lock_free_transaction_entries (
    void
)

function set_thread_local_entry¶

void cubthread::set_thread_local_entry (
    entry & tl_entry
)

function system_core_count¶

std::size_t cubthread::system_core_count (
    void
)

function wp_call_func_throwing_system_error¶

template<typename  Func>
void cubthread::wp_call_func_throwing_system_error (
    const  char * message,
    Func & func
)

function wp_handle_system_error¶

void cubthread::wp_handle_system_error (
    const  char * message,
    const std::system_error & e
)

function wp_is_thread_always_alive_forced¶

bool cubthread::wp_is_thread_always_alive_forced ()

function wp_set_force_thread_always_alive¶

void cubthread::wp_set_force_thread_always_alive ()

The documentation for this class was generated from the following file cubrid/src/base/memory_private_allocator.hpp