Commit 04a5f335 authored by unknown's avatar unknown
Browse files

WL#3337 (Event scheduler new architecture) 

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
parent 53267eda

sql/event_queue.cc

+23 −94
Original line number Diff line number Diff line
@@ -907,7 +907,7 @@ Event_queue::cond_wait(THD *thd, struct timespec *abstime, const char* msg, 
    do but we need to obey cond_wait()

  */

  thd->exit_cond("");

  LOCK_QUEUE_DATA();

  lock_data(func, line);



  DBUG_VOID_RETURN;

}
@@ -918,102 +918,31 @@ Event_queue::cond_wait(THD *thd, struct timespec *abstime, const char* msg, 


  SYNOPSIS

    Event_queue::dump_internal_status()

      thd  Thread



  RETURN VALUE

    FALSE  OK

    TRUE   Error

*/



bool

Event_queue::dump_internal_status(THD *thd)

void

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 */

  protocol->prepare_for_resend();

  protocol->store(STRING_WITH_LEN("queue element count"), scs);

  int_string.set((longlong) queue.elements, scs);

  protocol->store(&int_string);

  ret= protocol->write();



  /* queue_data_locked */

  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);

  /* element count */

  puts("");

  puts("Event queue status:");

  printf("Element count   : %u\n", queue.elements);

  printf("Data locked     : %s\n", mutex_queue_data_locked? "YES":"NO");

  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);



  DBUG_VOID_RETURN;

}

sql/event_queue.h

+3 −2
Original line number Diff line number Diff line
@@ -61,8 +61,9 @@ class Event_queue 


  bool

  get_top_for_execution_if_time(THD *thd, Event_job_data **job_data);

  bool

  dump_internal_status(THD *thd);



  void

  dump_internal_status();



  int

  load_events_from_db(THD *thd);

sql/event_scheduler.cc

+16 −96
Original line number Diff line number Diff line
@@ -38,6 +38,7 @@ extern pthread_attr_t connection_attrib; 
static

const LEX_STRING scheduler_states_names[] =

{

  { C_STRING_WITH_LEN("UNINITIALIZED") },

  { C_STRING_WITH_LEN("INITIALIZED") },

  { C_STRING_WITH_LEN("RUNNING") },

  { C_STRING_WITH_LEN("STOPPING") }
@@ -757,106 +758,25 @@ Event_scheduler::cond_wait(THD *thd, struct timespec *abstime, const char* msg, 


  SYNOPSIS

    Event_scheduler::dump_internal_status()

      thd  Thread



  RETURN VALUE

    FALSE  OK

    TRUE   Error

*/



bool

Event_scheduler::dump_internal_status(THD *thd)

void

Event_scheduler::dump_internal_status()

{

  int ret= 0;

  DBUG_ENTER("Event_scheduler::dump_internal_status");



#ifndef DBUG_OFF

  CHARSET_INFO *scs= system_charset_info;

  Protocol *protocol= thd->protocol;

  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);



  do

  {

    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;

  puts("");

  puts("Event scheduler status:");

  printf("State      : %s\n", scheduler_states_names[state].str);

  printf("Thread id  : %lu\n", scheduler_thd? scheduler_thd->thread_id : 0);

  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);

  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");



    /* 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);

  DBUG_VOID_RETURN;

}

sql/event_scheduler.h

+2 −2
Original line number Diff line number Diff line
@@ -65,8 +65,8 @@ class Event_scheduler 
  bool

  is_running();



  bool

  dump_internal_status(THD *thd);

  void

  dump_internal_status();



private:

  uint

sql/events.cc

+8 −20
Original line number Diff line number Diff line
@@ -744,32 +744,20 @@ Events::destroy_mutexes() 


  SYNOPSIS

    Events::dump_internal_status()

      thd  Thread



  RETURN VALUE

    FALSE  OK

    TRUE   Error

*/



bool

Events::dump_internal_status(THD *thd)

void

Events::dump_internal_status()

{

  DBUG_ENTER("Events::dump_internal_status");

  Protocol *protocol= thd->protocol;

  List<Item> field_list;

  puts("\n\n\nEvents status:");

  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));

  field_list.push_back(new Item_empty_string("Value",20));

  if (protocol->send_fields(&field_list, Protocol::SEND_NUM_ROWS |

                                         Protocol::SEND_EOF))

    DBUG_RETURN(TRUE);

  scheduler->dump_internal_status();

  event_queue->dump_internal_status();



  if (scheduler->dump_internal_status(thd) ||

      event_queue->dump_internal_status(thd))

    DBUG_RETURN(TRUE);



  send_eof(thd);

  DBUG_RETURN(FALSE);

  DBUG_VOID_RETURN;

}