database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-07-29 05:21:33 +03:00
Code Activity

WL#3337 (Event scheduler new architecture)

Browse Source 
Remove SHOW SCHEDULER STATUS command and migrate the
information output to `mysqladmin debug` (COM_DEBUG)

SHOW SCHEDULER STATUS was introduced in 5.1.11, provided
some debug information about event scheduler internals and
was enabled only in debug builds.


sql/event_queue.cc:
  Remove SHOW SCHEDULER STATUS. Reporting still will be
  there but through COM_DEBUG (mysqladmin debug)
sql/event_queue.h:
  dump_internal_status cannot return an error, therefore it
  should be void.
sql/event_scheduler.cc:
  Remove SHOW SCHEDULER STATUS. Reporting still will be
  there but through COM_DEBUG (mysqladmin debug)
sql/event_scheduler.h:
  dump_internal_status cannot return an error, therefore it
  should be void.
sql/events.cc:
  Change from outputting the internal data from
  the wire to the standard output. SHOW SCHEDULER STATUS was
  removed.
sql/events.h:
  dump_internal_status() cannot return an error, therefore
  it should be void
sql/lex.h:
  remove SCHEDULER as recognized word. This is part
  of removing SHOW SCHEDULER STATUS
sql/sp_head.cc:
  SQLCOM_SHOW_SCHEDULER_STATUS has been removed
sql/sql_lex.h:
  SQLCOM_SHOW_SCHEDULER_STATUS has been removed
sql/sql_parse.cc:
  SQLCOM_SHOW_SCHEDULER_STATUS has been removed
sql/sql_test.cc:
  Dump Events' internal information on COM_DEBUG
sql/sql_yacc.yy:
  SQLCOM_SHOW_SCHEDULER_STATUS has been removed
This commit is contained in:
unknown
2006-09-12 12:26:12 +02:00
parent 53267edaf6
commit 04a5f335d3
12 changed files with 57 additions and 236 deletions
Download Patch File Download Diff File Expand all files Collapse all files

115
sql/event_queue.cc
View File

@ -907,7 +907,7 @@ Event_queue::cond_wait(THD *thd, struct timespec *abstime, const char* msg,
do but we need to obey cond_wait() do but we need to obey cond_wait()
*/ */
thd->exit_cond(""); thd->exit_cond("");
LOCK_QUEUE_DATA(); lock_data(func, line);
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
@ -918,102 +918,31 @@ Event_queue::cond_wait(THD *thd, struct timespec *abstime, const char* msg,
SYNOPSIS SYNOPSIS
Event_queue::dump_internal_status() Event_queue::dump_internal_status()
thd Thread
RETURN VALUE
FALSE OK
TRUE Error
*/ */
bool void
Event_queue::dump_internal_status(THD *thd) Event_queue::dump_internal_status()
{ {
DBUG_ENTER("Event_queue::dump_internal_status"); DBUG_ENTER("Event_queue::dump_internal_status");
#ifndef DBUG_OFF
CHARSET_INFO *scs= system_charset_info;
Protocol *protocol= thd->protocol;
List<Item> field_list;
int ret;
char tmp_buff[5*STRING_BUFFER_USUAL_SIZE];
char int_buff[STRING_BUFFER_USUAL_SIZE];
String tmp_string(tmp_buff, sizeof(tmp_buff), scs);
String int_string(int_buff, sizeof(int_buff), scs);
tmp_string.length(0);
int_string.length(0);
/* workers_count */ /* element count */
protocol->prepare_for_resend(); puts("");
protocol->store(STRING_WITH_LEN("queue element count"), scs); puts("Event queue status:");
int_string.set((longlong) queue.elements, scs); printf("Element count : %u\n", queue.elements);
protocol->store(&int_string); printf("Data locked : %s\n", mutex_queue_data_locked? "YES":"NO");
ret= protocol->write(); printf("Attempting lock : %s\n", mutex_queue_data_attempting_lock? "YES":"NO");
printf("LLA : %s:%u\n", mutex_last_locked_in_func,
mutex_last_locked_at_line);
printf("LUA : %s:%u\n", mutex_last_unlocked_in_func,
mutex_last_unlocked_at_line);
if (mutex_last_attempted_lock_at_line)
printf("Last lock attempt at: %s:%u\n", mutex_last_attempted_lock_in_func,
mutex_last_attempted_lock_at_line);
printf("WOC : %s\n", waiting_on_cond? "YES":"NO");
printf("Next activation : %04d-%02d-%02d %02d:%02d:%02d\n",
next_activation_at.year, next_activation_at.month,
next_activation_at.day, next_activation_at.hour,
next_activation_at.minute, next_activation_at.second);
/* queue_data_locked */ DBUG_VOID_RETURN;
protocol->prepare_for_resend();
protocol->store(STRING_WITH_LEN("queue data locked"), scs);
int_string.set((longlong) mutex_queue_data_locked, scs);
protocol->store(&int_string);
ret= protocol->write();
/* queue_data_attempting_lock */
protocol->prepare_for_resend();
protocol->store(STRING_WITH_LEN("queue data attempting lock"), scs);
int_string.set((longlong) mutex_queue_data_attempting_lock, scs);
protocol->store(&int_string);
ret= protocol->write();
/* last locked at*/
protocol->prepare_for_resend();
protocol->store(STRING_WITH_LEN("queue last locked at"), scs);
tmp_string.length(scs->cset->snprintf(scs, (char*) tmp_string.ptr(),
tmp_string.alloced_length(), "%s::%d",
mutex_last_locked_in_func,
mutex_last_locked_at_line));
protocol->store(&tmp_string);
ret= protocol->write();
/* last unlocked at*/
protocol->prepare_for_resend();
protocol->store(STRING_WITH_LEN("queue last unlocked at"), scs);
tmp_string.length(scs->cset->snprintf(scs, (char*) tmp_string.ptr(),
tmp_string.alloced_length(), "%s::%d",
mutex_last_unlocked_in_func,
mutex_last_unlocked_at_line));
protocol->store(&tmp_string);
ret= protocol->write();
/* last attempted lock at*/
protocol->prepare_for_resend();
protocol->store(STRING_WITH_LEN("queue last attempted lock at"), scs);
tmp_string.length(scs->cset->snprintf(scs, (char*) tmp_string.ptr(),
tmp_string.alloced_length(), "%s::%d",
mutex_last_attempted_lock_in_func,
mutex_last_attempted_lock_at_line));
protocol->store(&tmp_string);
ret= protocol->write();
/* waiting on */
protocol->prepare_for_resend();
protocol->store(STRING_WITH_LEN("queue waiting on condition"), scs);
int_string.set((longlong) waiting_on_cond, scs);
protocol->store(&int_string);
ret= protocol->write();
protocol->prepare_for_resend();
protocol->store(STRING_WITH_LEN("next activation at"), scs);
tmp_string.length(scs->cset->snprintf(scs, (char*) tmp_string.ptr(),
tmp_string.alloced_length(),
"%4d-%02d-%02d %02d:%02d:%02d",
next_activation_at.year,
next_activation_at.month,
next_activation_at.day,
next_activation_at.hour,
next_activation_at.minute,
next_activation_at.second
));
protocol->store(&tmp_string);
ret= protocol->write();
#endif
DBUG_RETURN(FALSE);
} }

5
sql/event_queue.h
View File

@ -61,8 +61,9 @@ public:
bool bool
get_top_for_execution_if_time(THD *thd, Event_job_data **job_data); get_top_for_execution_if_time(THD *thd, Event_job_data **job_data);
bool
dump_internal_status(THD *thd); void
dump_internal_status();
int int
load_events_from_db(THD *thd); load_events_from_db(THD *thd);

112
sql/event_scheduler.cc
View File

@ -38,6 +38,7 @@ extern pthread_attr_t connection_attrib;
static static
const LEX_STRING scheduler_states_names[] = const LEX_STRING scheduler_states_names[] =
{ {
{ C_STRING_WITH_LEN("UNINITIALIZED") },
{ C_STRING_WITH_LEN("INITIALIZED") }, { C_STRING_WITH_LEN("INITIALIZED") },
{ C_STRING_WITH_LEN("RUNNING") }, { C_STRING_WITH_LEN("RUNNING") },
{ C_STRING_WITH_LEN("STOPPING") } { C_STRING_WITH_LEN("STOPPING") }
@ -757,106 +758,25 @@ Event_scheduler::cond_wait(THD *thd, struct timespec *abstime, const char* msg,
SYNOPSIS SYNOPSIS
Event_scheduler::dump_internal_status() Event_scheduler::dump_internal_status()
thd Thread
RETURN VALUE
FALSE OK
TRUE Error
*/ */
bool void
Event_scheduler::dump_internal_status(THD *thd) Event_scheduler::dump_internal_status()
{ {
int ret= 0;
DBUG_ENTER("Event_scheduler::dump_internal_status"); DBUG_ENTER("Event_scheduler::dump_internal_status");
#ifndef DBUG_OFF puts("");
CHARSET_INFO *scs= system_charset_info; puts("Event scheduler status:");
Protocol *protocol= thd->protocol; printf("State : %s\n", scheduler_states_names[state].str);
char tmp_buff[5*STRING_BUFFER_USUAL_SIZE]; printf("Thread id : %lu\n", scheduler_thd? scheduler_thd->thread_id : 0);
char int_buff[STRING_BUFFER_USUAL_SIZE]; printf("LLA : %s:%u\n", mutex_last_locked_in_func,
String tmp_string(tmp_buff, sizeof(tmp_buff), scs); mutex_last_locked_at_line);
String int_string(int_buff, sizeof(int_buff), scs); printf("LUA : %s:%u\n", mutex_last_unlocked_in_func,
tmp_string.length(0); mutex_last_unlocked_at_line);
int_string.length(0); printf("WOC : %s\n", waiting_on_cond? "YES":"NO");
printf("Workers : %u\n", workers_count());
printf("Executed : %llu\n", started_events);
printf("Data locked: %s\n", mutex_scheduler_data_locked ? "YES":"NO");
do DBUG_VOID_RETURN;
{
protocol->prepare_for_resend();
protocol->store(STRING_WITH_LEN("scheduler state"), scs);
protocol->store(scheduler_states_names[state].str,
scheduler_states_names[state].length, scs);
if ((ret= protocol->write()))
break;
/* thread_id */
protocol->prepare_for_resend();
protocol->store(STRING_WITH_LEN("thread_id"), scs);
if (thread_id)
{
int_string.set((longlong) scheduler_thd->thread_id, scs);
protocol->store(&int_string);
}
else
protocol->store_null();
if ((ret= protocol->write()))
break;
/* last locked at*/
protocol->prepare_for_resend();
protocol->store(STRING_WITH_LEN("scheduler last locked at"), scs);
tmp_string.length(scs->cset->snprintf(scs, (char*) tmp_string.ptr(),
tmp_string.alloced_length(), "%s::%d",
mutex_last_locked_in_func,
mutex_last_locked_at_line));
protocol->store(&tmp_string);
if ((ret= protocol->write()))
break;
/* last unlocked at*/
protocol->prepare_for_resend();
protocol->store(STRING_WITH_LEN("scheduler last unlocked at"), scs);
tmp_string.length(scs->cset->snprintf(scs, (char*) tmp_string.ptr(),
tmp_string.alloced_length(), "%s::%d",
mutex_last_unlocked_in_func,
mutex_last_unlocked_at_line));
protocol->store(&tmp_string);
if ((ret= protocol->write()))
break;
/* waiting on */
protocol->prepare_for_resend();
protocol->store(STRING_WITH_LEN("scheduler waiting on condition"), scs);
int_string.set((longlong) waiting_on_cond, scs);
protocol->store(&int_string);
if ((ret= protocol->write()))
break;
/* workers_count */
protocol->prepare_for_resend();
protocol->store(STRING_WITH_LEN("scheduler workers count"), scs);
int_string.set((longlong) workers_count(), scs);
protocol->store(&int_string);
if ((ret= protocol->write()))
break;
/* workers_count */
protocol->prepare_for_resend();
protocol->store(STRING_WITH_LEN("scheduler executed events"), scs);
int_string.set((longlong) started_events, scs);
protocol->store(&int_string);
if ((ret= protocol->write()))
break;
/* scheduler_data_locked */
protocol->prepare_for_resend();
protocol->store(STRING_WITH_LEN("scheduler data locked"), scs);
int_string.set((longlong) mutex_scheduler_data_locked, scs);
protocol->store(&int_string);
ret= protocol->write();
} while (0);
#endif
DBUG_RETURN(ret);
} }

4
sql/event_scheduler.h
View File

@ -65,8 +65,8 @@ public:
bool bool
is_running(); is_running();
bool void
dump_internal_status(THD *thd); dump_internal_status();
private: private:
uint uint

28
sql/events.cc
View File

@ -744,32 +744,20 @@ Events::destroy_mutexes()
SYNOPSIS SYNOPSIS
Events::dump_internal_status() Events::dump_internal_status()
thd Thread
RETURN VALUE
FALSE OK
TRUE Error
*/ */
bool void
Events::dump_internal_status(THD *thd) Events::dump_internal_status()
{ {
DBUG_ENTER("Events::dump_internal_status"); DBUG_ENTER("Events::dump_internal_status");
Protocol *protocol= thd->protocol; puts("\n\n\nEvents status:");
List<Item> field_list; puts("LLA = Last Locked At LUA = Last Unlocked At");
puts("WOC = Waiting On Condition DL = Data Locked");
field_list.push_back(new Item_empty_string("Name", 30)); scheduler->dump_internal_status();
field_list.push_back(new Item_empty_string("Value",20)); event_queue->dump_internal_status();
if (protocol->send_fields(&field_list, Protocol::SEND_NUM_ROWS |
Protocol::SEND_EOF))
DBUG_RETURN(TRUE);
if (scheduler->dump_internal_status(thd) || DBUG_VOID_RETURN;
event_queue->dump_internal_status(thd))
DBUG_RETURN(TRUE);
send_eof(thd);
DBUG_RETURN(FALSE);
} }

4
sql/events.h
View File

@ -112,8 +112,8 @@ public:
static int static int
fill_schema_events(THD *thd, TABLE_LIST *tables, COND * /* cond */); fill_schema_events(THD *thd, TABLE_LIST *tables, COND * /* cond */);
bool void
dump_internal_status(THD *thd); dump_internal_status();
private: private:
bool bool

1
sql/lex.h
View File

@ -452,7 +452,6 @@ static SYMBOL symbols[] = {
{ "RTREE", SYM(RTREE_SYM)}, { "RTREE", SYM(RTREE_SYM)},
{ "SAVEPOINT", SYM(SAVEPOINT_SYM)}, { "SAVEPOINT", SYM(SAVEPOINT_SYM)},
{ "SCHEDULE", SYM(SCHEDULE_SYM)}, { "SCHEDULE", SYM(SCHEDULE_SYM)},
{ "SCHEDULER", SYM(SCHEDULER_SYM)},
{ "SCHEMA", SYM(DATABASE)}, { "SCHEMA", SYM(DATABASE)},
{ "SCHEMAS", SYM(DATABASES)}, { "SCHEMAS", SYM(DATABASES)},
{ "SECOND", SYM(SECOND_SYM)}, { "SECOND", SYM(SECOND_SYM)},

1
sql/sp_head.cc
View File

@ -196,7 +196,6 @@ sp_get_flags_for_command(LEX *lex)
case SQLCOM_SHOW_PRIVILEGES: case SQLCOM_SHOW_PRIVILEGES:
case SQLCOM_SHOW_PROCESSLIST: case SQLCOM_SHOW_PROCESSLIST:
case SQLCOM_SHOW_PROC_CODE: case SQLCOM_SHOW_PROC_CODE:
case SQLCOM_SHOW_SCHEDULER_STATUS:
case SQLCOM_SHOW_SLAVE_HOSTS: case SQLCOM_SHOW_SLAVE_HOSTS:
case SQLCOM_SHOW_SLAVE_STAT: case SQLCOM_SHOW_SLAVE_STAT:
case SQLCOM_SHOW_STATUS: case SQLCOM_SHOW_STATUS:

1
sql/sql_lex.h
View File

@ -113,7 +113,6 @@ enum enum_sql_command {
SQLCOM_SHOW_CONTRIBUTORS, SQLCOM_SHOW_CONTRIBUTORS,
SQLCOM_CREATE_EVENT, SQLCOM_ALTER_EVENT, SQLCOM_DROP_EVENT, SQLCOM_CREATE_EVENT, SQLCOM_ALTER_EVENT, SQLCOM_DROP_EVENT,
SQLCOM_SHOW_CREATE_EVENT, SQLCOM_SHOW_EVENTS, SQLCOM_SHOW_CREATE_EVENT, SQLCOM_SHOW_EVENTS,
SQLCOM_SHOW_SCHEDULER_STATUS,
/* This should be the last !!! */ /* This should be the last !!! */

7
sql/sql_parse.cc
View File

@ -3960,13 +3960,6 @@ end_with_restore_list:
} }
break; break;
} }
#ifndef DBUG_OFF
case SQLCOM_SHOW_SCHEDULER_STATUS:
{
res= Events::get_instance()->dump_internal_status(thd);
break;
}
#endif
case SQLCOM_CREATE_FUNCTION: // UDF function case SQLCOM_CREATE_FUNCTION: // UDF function
{ {
if (check_access(thd,INSERT_ACL,"mysql",0,1,0,0)) if (check_access(thd,INSERT_ACL,"mysql",0,1,0,0))

4
sql/sql_test.cc
View File

@ -28,6 +28,8 @@
#include <sys/malloc.h> #include <sys/malloc.h>
#endif #endif
#include "events.h"
static const char *lock_descriptions[] = static const char *lock_descriptions[] =
{ {
"No lock", "No lock",
@ -532,5 +534,7 @@ Estimated memory (with thread stack): %ld\n",
(int) info.keepcost, (int) info.keepcost,
(long) (thread_count * thread_stack + info.hblkhd + info.arena)); (long) (thread_count * thread_stack + info.hblkhd + info.arena));
#endif #endif
Events::get_instance()->dump_internal_status();
puts(""); puts("");
} }

11
sql/sql_yacc.yy
View File

@ -590,7 +590,6 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
%token RTREE_SYM %token RTREE_SYM
%token SAVEPOINT_SYM %token SAVEPOINT_SYM
%token SCHEDULE_SYM %token SCHEDULE_SYM
%token SCHEDULER_SYM
%token SECOND_MICROSECOND_SYM %token SECOND_MICROSECOND_SYM
%token SECOND_SYM %token SECOND_SYM
%token SECURITY_SYM %token SECURITY_SYM
@ -8112,15 +8111,6 @@ show_param:
if (prepare_schema_table(YYTHD, lex, 0, SCH_EVENTS)) if (prepare_schema_table(YYTHD, lex, 0, SCH_EVENTS))
YYABORT; YYABORT;
} }
| SCHEDULER_SYM STATUS_SYM
{
#ifndef DBUG_OFF
Lex->sql_command= SQLCOM_SHOW_SCHEDULER_STATUS;
#else
yyerror(ER(ER_SYNTAX_ERROR));
YYABORT;
#endif
}
| TABLE_SYM STATUS_SYM opt_db wild_and_where | TABLE_SYM STATUS_SYM opt_db wild_and_where
{ {
LEX *lex= Lex; LEX *lex= Lex;
@ -9503,7 +9493,6 @@ keyword_sp:
| ROW_SYM {} | ROW_SYM {}
| RTREE_SYM {} | RTREE_SYM {}
| SCHEDULE_SYM {} | SCHEDULE_SYM {}
| SCHEDULER_SYM {}
| SECOND_SYM {} | SECOND_SYM {}
| SERIAL_SYM {} | SERIAL_SYM {}
| SERIALIZABLE_SYM {} | SERIALIZABLE_SYM {}