2009-05-27 15:15:59 +05:30
|
|
|
/*****************************************************************************
|
|
|
|
|
|
2012-08-01 17:27:34 +03:00
|
|
|
Copyright (c) 1995, 2009, Oracle and/or its affiliates. All Rights Reserved.
|
2009-05-27 15:15:59 +05:30
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify it under
|
|
|
|
|
the terms of the GNU General Public License as published by the Free Software
|
|
|
|
|
Foundation; version 2 of the License.
|
|
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful, but WITHOUT
|
|
|
|
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
|
|
|
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License along with
|
2012-08-01 17:27:34 +03:00
|
|
|
this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
|
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA
|
2009-05-27 15:15:59 +05:30
|
|
|
|
|
|
|
|
*****************************************************************************/
|
|
|
|
|
|
|
|
|
|
/**************************************************//**
|
|
|
|
|
@file include/sync0arr.h
|
|
|
|
|
The wait array used in synchronization primitives
|
|
|
|
|
|
|
|
|
|
Created 9/5/1995 Heikki Tuuri
|
|
|
|
|
*******************************************************/
|
|
|
|
|
|
|
|
|
|
#ifndef sync0arr_h
|
|
|
|
|
#define sync0arr_h
|
|
|
|
|
|
|
|
|
|
#include "univ.i"
|
|
|
|
|
#include "ut0lst.h"
|
|
|
|
|
#include "ut0mem.h"
|
|
|
|
|
#include "os0thread.h"
|
|
|
|
|
|
|
|
|
|
/** Synchronization wait array cell */
|
2013-03-26 00:03:13 +02:00
|
|
|
struct sync_cell_t;
|
2009-05-27 15:15:59 +05:30
|
|
|
/** Synchronization wait array */
|
2013-03-26 00:03:13 +02:00
|
|
|
struct sync_array_t;
|
2009-05-27 15:15:59 +05:30
|
|
|
|
|
|
|
|
/******************************************************************//**
|
|
|
|
|
Reserves a wait array cell for waiting for an object.
|
|
|
|
|
The event of the cell is reset to nonsignalled state. */
|
|
|
|
|
UNIV_INTERN
|
|
|
|
|
void
|
|
|
|
|
sync_array_reserve_cell(
|
|
|
|
|
/*====================*/
|
|
|
|
|
sync_array_t* arr, /*!< in: wait array */
|
|
|
|
|
void* object, /*!< in: pointer to the object to wait for */
|
|
|
|
|
ulint type, /*!< in: lock request type */
|
|
|
|
|
const char* file, /*!< in: file where requested */
|
|
|
|
|
ulint line, /*!< in: line where requested */
|
|
|
|
|
ulint* index); /*!< out: index of the reserved cell */
|
|
|
|
|
/******************************************************************//**
|
|
|
|
|
This function should be called when a thread starts to wait on
|
|
|
|
|
a wait array cell. In the debug version this function checks
|
|
|
|
|
if the wait for a semaphore will result in a deadlock, in which
|
|
|
|
|
case prints info and asserts. */
|
|
|
|
|
UNIV_INTERN
|
|
|
|
|
void
|
|
|
|
|
sync_array_wait_event(
|
|
|
|
|
/*==================*/
|
|
|
|
|
sync_array_t* arr, /*!< in: wait array */
|
|
|
|
|
ulint index); /*!< in: index of the reserved cell */
|
|
|
|
|
/******************************************************************//**
|
|
|
|
|
Frees the cell. NOTE! sync_array_wait_event frees the cell
|
|
|
|
|
automatically! */
|
|
|
|
|
UNIV_INTERN
|
|
|
|
|
void
|
|
|
|
|
sync_array_free_cell(
|
|
|
|
|
/*=================*/
|
|
|
|
|
sync_array_t* arr, /*!< in: wait array */
|
|
|
|
|
ulint index); /*!< in: index of the cell in array */
|
|
|
|
|
/**********************************************************************//**
|
|
|
|
|
Note that one of the wait objects was signalled. */
|
|
|
|
|
UNIV_INTERN
|
|
|
|
|
void
|
2012-08-01 17:27:34 +03:00
|
|
|
sync_array_object_signalled(void);
|
|
|
|
|
/*=============================*/
|
|
|
|
|
|
2009-05-27 15:15:59 +05:30
|
|
|
/**********************************************************************//**
|
|
|
|
|
If the wakeup algorithm does not work perfectly at semaphore relases,
|
|
|
|
|
this function will do the waking (see the comment in mutex_exit). This
|
|
|
|
|
function should be called about every 1 second in the server. */
|
|
|
|
|
UNIV_INTERN
|
|
|
|
|
void
|
|
|
|
|
sync_arr_wake_threads_if_sema_free(void);
|
|
|
|
|
/*====================================*/
|
|
|
|
|
/**********************************************************************//**
|
|
|
|
|
Prints warnings of long semaphore waits to stderr.
|
|
|
|
|
@return TRUE if fatal semaphore wait threshold was exceeded */
|
|
|
|
|
UNIV_INTERN
|
|
|
|
|
ibool
|
Bug#11877216 InnoDB too eager to commit suicide on a busy server
sync_array_print_long_waits(): Return the longest waiting thread ID
and the longest waited-for lock. Only if those remain unchanged
between calls in srv_error_monitor_thread(), increment
fatal_cnt. Otherwise, reset fatal_cnt.
Background: There is a built-in watchdog in InnoDB whose purpose is to
kill the server when some thread is stuck waiting for a mutex or
rw-lock. Before this fix, the logic was flawed.
The function sync_array_print_long_waits() returns TRUE if it finds a
lock wait that exceeds 10 minutes (srv_fatal_semaphore_wait_threshold).
The function srv_error_monitor_thread() will kill the server if this
happens 10 times in a row (fatal_cnt reaches 10), checked every 30
seconds. This is wrong, because this situation does not mean that the
server is hung. If the server is very busy for a little over 15
minutes, it will be killed.
Consider this example. Thread T1 is waiting for mutex M. Some time
later, threads T2..Tn start waiting for the same mutex M. If T1 keeps
waiting for 600 seconds, fatal_cnt will be incremented to 1. So far,
so good. Now, if M is granted to T1, the server was obviously not
stuck. But, T2..Tn keeps waiting, and their wait time will be longer
than 600 seconds. If 5 minutes later, some Tn has still been waiting
for more than 10 minutes for the mutex M, the server can be killed,
even though it is not stuck.
rb:622 approved by Jimmy Yang
2011-03-30 14:25:58 +03:00
|
|
|
sync_array_print_long_waits(
|
|
|
|
|
/*========================*/
|
2011-03-30 14:52:26 +03:00
|
|
|
os_thread_id_t* waiter, /*!< out: longest waiting thread */
|
|
|
|
|
const void** sema) /*!< out: longest-waited-for semaphore */
|
Bug#11877216 InnoDB too eager to commit suicide on a busy server
sync_array_print_long_waits(): Return the longest waiting thread ID
and the longest waited-for lock. Only if those remain unchanged
between calls in srv_error_monitor_thread(), increment
fatal_cnt. Otherwise, reset fatal_cnt.
Background: There is a built-in watchdog in InnoDB whose purpose is to
kill the server when some thread is stuck waiting for a mutex or
rw-lock. Before this fix, the logic was flawed.
The function sync_array_print_long_waits() returns TRUE if it finds a
lock wait that exceeds 10 minutes (srv_fatal_semaphore_wait_threshold).
The function srv_error_monitor_thread() will kill the server if this
happens 10 times in a row (fatal_cnt reaches 10), checked every 30
seconds. This is wrong, because this situation does not mean that the
server is hung. If the server is very busy for a little over 15
minutes, it will be killed.
Consider this example. Thread T1 is waiting for mutex M. Some time
later, threads T2..Tn start waiting for the same mutex M. If T1 keeps
waiting for 600 seconds, fatal_cnt will be incremented to 1. So far,
so good. Now, if M is granted to T1, the server was obviously not
stuck. But, T2..Tn keeps waiting, and their wait time will be longer
than 600 seconds. If 5 minutes later, some Tn has still been waiting
for more than 10 minutes for the mutex M, the server can be killed,
even though it is not stuck.
rb:622 approved by Jimmy Yang
2011-03-30 14:25:58 +03:00
|
|
|
__attribute__((nonnull));
|
2009-05-27 15:15:59 +05:30
|
|
|
/********************************************************************//**
|
|
|
|
|
Validates the integrity of the wait array. Checks
|
|
|
|
|
that the number of reserved cells equals the count variable. */
|
|
|
|
|
UNIV_INTERN
|
|
|
|
|
void
|
|
|
|
|
sync_array_validate(
|
|
|
|
|
/*================*/
|
|
|
|
|
sync_array_t* arr); /*!< in: sync wait array */
|
|
|
|
|
/**********************************************************************//**
|
|
|
|
|
Prints info of the wait array. */
|
|
|
|
|
UNIV_INTERN
|
|
|
|
|
void
|
2012-08-01 17:27:34 +03:00
|
|
|
sync_array_print(
|
|
|
|
|
/*=============*/
|
|
|
|
|
FILE* file); /*!< in: file where to print */
|
|
|
|
|
|
|
|
|
|
/**********************************************************************//**
|
|
|
|
|
Create the primary system wait array(s), they are protected by an OS mutex */
|
|
|
|
|
UNIV_INTERN
|
|
|
|
|
void
|
|
|
|
|
sync_array_init(
|
|
|
|
|
/*============*/
|
|
|
|
|
ulint n_threads); /*!< in: Number of slots to create */
|
|
|
|
|
/**********************************************************************//**
|
|
|
|
|
Close sync array wait sub-system. */
|
|
|
|
|
UNIV_INTERN
|
|
|
|
|
void
|
|
|
|
|
sync_array_close(void);
|
2009-05-27 15:15:59 +05:30
|
|
|
/*==================*/
|
|
|
|
|
|
2012-08-01 17:27:34 +03:00
|
|
|
/**********************************************************************//**
|
|
|
|
|
Get an instance of the sync wait array. */
|
|
|
|
|
UNIV_INTERN
|
|
|
|
|
sync_array_t*
|
|
|
|
|
sync_array_get(void);
|
|
|
|
|
/*================*/
|
2009-05-27 15:15:59 +05:30
|
|
|
|
|
|
|
|
#ifndef UNIV_NONINL
|
|
|
|
|
#include "sync0arr.ic"
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#endif
|