ulong activation_count = 0; /* max(hit_limit, execute) */

ulong hit_limit = 0; /* hits before kill query */

ulong execute = 0; /* executes before self-clear */

ulong timeout = 0; /* wait_for timeout */

String signal; /* signal to emit */

String wait_for; /* signal to wait for */

String sync_point; /* sync point name */

bool need_sort = false; /* if new action, array needs sort */

bool clear_event = false; /* do not clear signal if false */

st_debug_sync_action *ds_action; /* array of actions */

uint ds_active; /* # active actions */

uint ds_allocated; /* # allocated actions */

ulonglong dsp_hits; /* statistics */

ulonglong dsp_executed; /* statistics */

ulonglong dsp_max_active; /* statistics */

/*

char ds_proc_info[80]; /* proc_info string */

signal_event_set ds_signal_set; /* list of signals signalled */

mysql_cond_t ds_cond; /* condition variable */

mysql_mutex_t ds_mutex; /* mutex variable */

ulonglong dsp_hits; /* statistics */

ulonglong dsp_executed; /* statistics */

ulonglong dsp_max_active; /* statistics */

st_debug_sync_globals() : dsp_hits(0), dsp_executed(0), dsp_max_active(0) {}

private:

// Not implemented:

st_debug_sync_globals(const st_debug_sync_globals &);

st_debug_sync_globals &operator=(const st_debug_sync_globals &);

size_t name_len) {

if (unlikely(opt_debug_sync_timeout))

debug_sync(current_thd, sync_point_name, name_len);

const char *category = "sql";

int count;

count = static_cast<int>(array_elements(all_debug_sync_mutexes));

mysql_mutex_register(category, all_debug_sync_mutexes, count);

count = static_cast<int>(array_elements(all_debug_sync_conds));

mysql_cond_register(category, all_debug_sync_conds, count);

count = static_cast<int>(array_elements(all_debug_sync_memory));

mysql_memory_register(category, all_debug_sync_memory, count);

DBUG_TRACE;

#ifdef HAVE_PSI_INTERFACE

init_debug_sync_psi_keys();

#endif

if (opt_debug_sync_timeout) {

int rc;

/* Initialize the global variables. */

if ((rc = mysql_cond_init(key_debug_sync_globals_ds_cond,

&debug_sync_global.ds_cond)) ||

(rc =

mysql_mutex_init(key_debug_sync_globals_ds_mutex,

&debug_sync_global.ds_mutex, MY_MUTEX_INIT_FAST)))

return rc; /* purecov: inspected */

/* Set the call back pointer in C files. */

debug_sync_C_callback_ptr = debug_sync_C_callback;

}

return 0;

DBUG_TRACE;

/* End the facility only if it had been initialized. */

if (debug_sync_C_callback_ptr) {

/* Clear the call back pointer in C files. */

debug_sync_C_callback_ptr = nullptr;

/* Destroy the global variables. */

debug_sync_global.ds_signal_set.clear();

mysql_cond_destroy(&debug_sync_global.ds_cond);

mysql_mutex_destroy(&debug_sync_global.ds_mutex);

/* Print statistics. */

{

char llbuff[22];

LogErr(INFORMATION_LEVEL, ER_DEBUG_SYNC_HIT,

llstr(debug_sync_global.dsp_hits, llbuff));

LogErr(INFORMATION_LEVEL, ER_DEBUG_SYNC_EXECUTED,

llstr(debug_sync_global.dsp_executed, llbuff));

LogErr(INFORMATION_LEVEL, ER_DEBUG_SYNC_THREAD_MAX,

llstr(debug_sync_global.dsp_max_active, llbuff));

}

}

DBUG_TRACE;

opt_debug_sync_timeout = 0;

DBUG_PRINT("debug_sync",

("Debug Sync Facility disabled due to lack of memory."));

LogErr(ERROR_LEVEL, ER_DEBUG_SYNC_OOM);

DBUG_TRACE;

assert(thd);

if (opt_debug_sync_timeout) {

thd->debug_sync_control = (st_debug_sync_control *)my_malloc(

key_debug_THD_debug_sync_control, sizeof(st_debug_sync_control),

MYF(MY_WME | MY_ZEROFILL));

if (!thd->debug_sync_control) {

/*

debug_sync_emergency_disable(); /* purecov: tested */

}

}

DBUG_TRACE;

assert(thd);

st_debug_sync_control *ds_control = thd->debug_sync_control;

if (ds_control != nullptr) {

if (ds_control->ds_action) {

st_debug_sync_action *action = ds_control->ds_action;

st_debug_sync_action *action_end = action + ds_control->ds_allocated;

for (; action < action_end; action++) {

action->signal.mem_claim(claim);

action->wait_for.mem_claim(claim);

action->sync_point.mem_claim(claim);

}

my_claim(ds_control->ds_action, claim);

}

my_claim(ds_control, claim);

}

DBUG_TRACE;

assert(thd);

if (thd->debug_sync_control) {

st_debug_sync_control *ds_control = thd->debug_sync_control;

/*

DEBUG_SYNC(thd, "thread_end");

if (ds_control->ds_action) {

st_debug_sync_action *action = ds_control->ds_action;

st_debug_sync_action *action_end = action + ds_control->ds_allocated;

for (; action < action_end; action++) {

action->signal.mem_free();

action->wait_for.mem_free();

action->sync_point.mem_free();

}

my_free(ds_control->ds_action);

}

/* Statistics. */

mysql_mutex_lock(&debug_sync_global.ds_mutex);

debug_sync_global.dsp_hits += ds_control->dsp_hits;

debug_sync_global.dsp_executed += ds_control->dsp_executed;

if (debug_sync_global.dsp_max_active < ds_control->dsp_max_active)

debug_sync_global.dsp_max_active = ds_control->dsp_max_active;

mysql_mutex_unlock(&debug_sync_global.ds_mutex);

my_free(ds_control);

thd->debug_sync_control = nullptr;

}

st_debug_sync_action *action) {

char *wtxt = result;

char *wend = wtxt + size - 1; /* Allow emergency '\0'. */

assert(result);

assert(action);

/* If an execute count is present, signal or wait_for are needed too. */

assert(!action->execute || action->signal.length() ||

action->wait_for.length());

if (action->execute) {

if (action->signal.length()) {

wtxt = debug_sync_bmove_len(wtxt, wend, STRING_WITH_LEN("SIGNAL "));

wtxt = debug_sync_bmove_len(wtxt, wend, action->signal.ptr(),

action->signal.length());

}

if (action->wait_for.length()) {

if ((wtxt == result) && (wtxt < wend)) *(wtxt++) = ' ';

wtxt = debug_sync_bmove_len(wtxt, wend, STRING_WITH_LEN(" WAIT_FOR "));

wtxt = debug_sync_bmove_len(wtxt, wend, action->wait_for.ptr(),

action->wait_for.length());

if (action->timeout != opt_debug_sync_timeout) {

wtxt += snprintf(wtxt, wend - wtxt, " TIMEOUT %lu", action->timeout);

}

}

if (action->execute != 1) {

wtxt += snprintf(wtxt, wend - wtxt, " EXECUTE %lu", action->execute);

}

}

if (action->hit_limit) {

wtxt += snprintf(wtxt, wend - wtxt, "%sHIT_LIMIT %lu",

(wtxt == result) ? "" : " ", action->hit_limit);

}

/*

*wtxt = '\0';

st_debug_sync_control *ds_control = thd->debug_sync_control;

uint idx;

DBUG_TRACE;

assert(thd);

if (!ds_control) return;

for (idx = 0; idx < ds_control->ds_active; idx++) {

const char *dsp_name = ds_control->ds_action[idx].sync_point.c_ptr();

char action_string[256];

debug_sync_action_string(action_string, sizeof(action_string),

ds_control->ds_action + idx);

DBUG_PRINT("debug_sync_list", ("%s %s", dsp_name, action_string));

}

st_debug_sync_control *ds_control = thd->debug_sync_control;

DBUG_TRACE;

assert(thd);

assert(ds_control);

/* Remove all actions of this thread. */

ds_control->ds_active = 0;

/* Clear the signals. */

mysql_mutex_lock(&debug_sync_global.ds_mutex);

debug_sync_global.ds_signal_set.clear();

mysql_mutex_unlock(&debug_sync_global.ds_mutex);

st_debug_sync_action *action) {

uint dsp_idx = static_cast<uint>(action - ds_control->ds_action);

DBUG_TRACE;

assert(ds_control);

assert(current_thd == nullptr ||

ds_control == current_thd->debug_sync_control);

assert(action);

assert(dsp_idx < ds_control->ds_active);

/* Decrement the number of currently active actions. */

ds_control->ds_active--;

/*

if (ds_control->ds_active > dsp_idx) {

/*

st_debug_sync_action save_action = std::move(*action);

/* Move actions down. */

st_debug_sync_action *dest_action = ds_control->ds_action + dsp_idx;

st_debug_sync_action *src_action = ds_control->ds_action + dsp_idx + 1;

uint num_actions = ds_control->ds_active - dsp_idx;

std::move(src_action, src_action + num_actions, dest_action);

/*

dest_action = ds_control->ds_action + ds_control->ds_active;

*dest_action = std::move(save_action);

}