Skip navigation links

Recommended Servers for MySQL

The world's most popular open source database

Contact a MySQL Representative

Login | Register

• MySQL.com
• Downloads
• Developer Zone
• Partners & Solutions
• Customer Login

• DevZone
• Documentation
• Librarian
• Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs

 

 

 

• Get Started with MySQL
• Development with MySQL
• PHP
• Perl
• Python
• Ruby
• Java/JDBC
• C#/.NET

The world's most popular open source database

mysql/src/5.1-dbg/storage/innobase/sync/sync0sync.c File Reference

#include "sync0sync.h"
#include "sync0rw.h"
#include "buf0buf.h"
#include "srv0srv.h"
#include "buf0types.h"

Include dependency graph for sync0sync.c:

Go to the source code of this file.

Classes
struct	sync_thread_struct
struct	sync_level_struct
Defines
#define	SYNC_THREAD_N_LEVELS   10000
Typedefs
typedef sync_level_struct	sync_level_t
typedef sync_thread_struct	sync_thread_t
Functions
void	mutex_enter_noninline (mutex_t *mutex)
void	mutex_exit_noninline (mutex_t *mutex)
void	mutex_create_func (mutex_t *mutex, ulint level, const char *cfile_name, ulint cline, const char *cmutex_name)
void	mutex_free (mutex_t *mutex)
ulint	mutex_enter_nowait (mutex_t *mutex, const char *file_name __attribute__((unused)), ulint line __attribute__((unused)))
ibool	mutex_validate (mutex_t *mutex)
void	mutex_set_waiters (mutex_t *mutex, ulint n)
void	mutex_spin_wait (mutex_t *mutex, const char *file_name, ulint line)
void	mutex_signal_object (mutex_t *mutex)
static sync_thread_t *	sync_thread_level_arrays_get_nth (ulint n)
static sync_thread_t *	sync_thread_level_arrays_find_slot (void)
static sync_thread_t *	sync_thread_level_arrays_find_free (void)
static sync_level_t *	sync_thread_levels_get_nth (sync_level_t *arr, ulint n)
static ibool	sync_thread_levels_g (sync_level_t *arr, ulint limit)
static ibool	sync_thread_levels_contain (sync_level_t *arr, ulint level)
ibool	sync_thread_levels_empty_gen (ibool dict_mutex_allowed)
ibool	sync_thread_levels_empty (void)
void	sync_thread_add_level (void *latch, ulint level)
ibool	sync_thread_reset_level (void *latch)
void	sync_init (void)
void	sync_close (void)
void	sync_print_wait_info (FILE *file)
void	sync_print (FILE *file)
Variables
ulint	sync_dummy = 0
ulint	mutex_system_call_count = 0
ulint	mutex_spin_round_count = 0
ulint	mutex_spin_wait_count = 0
ulint	mutex_os_wait_count = 0
ulint	mutex_exit_count = 0
sync_array_t *	sync_primary_wait_array
ibool	sync_initialized = FALSE
sync_thread_t *	sync_thread_level_arrays
mutex_t	sync_thread_mutex
ut_list_base_node_t	mutex_list
mutex_t	mutex_list_mutex
ibool	sync_order_checks_on = FALSE
mutex_t	dummy_mutex_for_fence

---

Define Documentation

#define SYNC_THREAD_N_LEVELS   10000

Definition at line 163 of file sync0sync.c.

Referenced by sync_thread_add_level(), sync_thread_levels_contain(), sync_thread_levels_empty_gen(), sync_thread_levels_g(), sync_thread_levels_get_nth(), and sync_thread_reset_level().

---

Typedef Documentation

typedef struct sync_level_struct sync_level_t

Definition at line 133 of file sync0sync.c.

typedef struct sync_thread_struct sync_thread_t

Definition at line 134 of file sync0sync.c.

---

Function Documentation

void mutex_create_func	(	mutex_t *	mutex,
		ulint	level,
		const char *	cfile_name,
		ulint	cline,
		const char *	cmutex_name
	)

Definition at line 202 of file sync0sync.c.

References list(), mutex, mutex_enter, mutex_exit(), mutex_list, mutex_list_mutex, MUTEX_MAGIC_N, mutex_set_waiters(), os_fast_mutex_init(), sync_thread_mutex, ut_a, ut_ad, UT_LIST_ADD_FIRST, UT_LIST_GET_FIRST, and UT_LIST_GET_LEN.

                                             : pointer to memory */
        ulint           level,          /* in: level */
        const char*     cfile_name,     /* in: file name where created */
  ulint cline,  /* in: file line where created */
  const char* cmutex_name)  /* in: mutex name */
{
#if defined(_WIN32) && defined(UNIV_CAN_USE_X86_ASSEMBLER)
        mutex_reset_lock_word(mutex);
#else
        os_fast_mutex_init(&(mutex->os_fast_mutex));
        mutex->lock_word = 0;
#endif
        mutex_set_waiters(mutex, 0);
        mutex->magic_n = MUTEX_MAGIC_N;
#ifdef UNIV_SYNC_DEBUG
        mutex->line = 0;
        mutex->file_name = "not yet reserved";
#endif /* UNIV_SYNC_DEBUG */
        mutex->level = level;
        mutex->cfile_name = cfile_name;
        mutex->cline = cline;
#ifndef UNIV_HOTBACKUP
        mutex->cmutex_name=       cmutex_name;
        mutex->count_using=       0;
        mutex->mutex_type=        0;
        mutex->lspent_time=       0;
        mutex->lmax_spent_time=     0;
        mutex->count_spin_loop= 0;
        mutex->count_spin_rounds=   0;
        mutex->count_os_wait=     0;
        mutex->count_os_yield=  0;
#endif /* !UNIV_HOTBACKUP */

        /* Check that lock_word is aligned; this is important on Intel */
        ut_ad(((ulint)(&(mutex->lock_word))) % 4 == 0);

        /* NOTE! The very first mutexes are not put to the mutex list */

        if ((mutex == &mutex_list_mutex) || (mutex == &sync_thread_mutex)) {

                return;
        }

        mutex_enter(&mutex_list_mutex);

        if (UT_LIST_GET_LEN(mutex_list) > 0) {
                ut_a(UT_LIST_GET_FIRST(mutex_list)->magic_n == MUTEX_MAGIC_N);
        }

        UT_LIST_ADD_FIRST(list, mutex_list, mutex);

        mutex_exit(&mutex_list_mutex);
}

Here is the call graph for this function:

void mutex_enter_noninline

(

mutex_t *

mutex

)

Definition at line 177 of file sync0sync.c.

References mutex, and mutex_enter.

                                     : mutex */
{
        mutex_enter(mutex);
}

ulint mutex_enter_nowait	(	mutex_t *	mutex,
		const char *file_name	__attribute__((unused)),
		ulint line	__attribute__((unused))
	)

Definition at line 307 of file sync0sync.c.

References line, mutex, mutex_validate(), and ut_ad.

                                              : 0 if succeed, 1 if not */
        mutex_t*        mutex,          /* in: pointer to mutex */
        const char*     file_name __attribute__((unused)),
                                        /* in: file name where mutex
                                        requested */
        ulint           line __attribute__((unused)))
                                        /* in: line where requested */
{
        ut_ad(mutex_validate(mutex));

        if (!mutex_test_and_set(mutex)) {

#ifdef UNIV_SYNC_DEBUG
                mutex_set_debug_info(mutex, file_name, line);
#endif

                return(0);      /* Succeeded! */
        }

        return(1);
}

Here is the call graph for this function:

void mutex_exit_noninline

(

mutex_t *

mutex

)

Definition at line 188 of file sync0sync.c.

References mutex, and mutex_exit().

                                     : mutex */
{
        mutex_exit(mutex);
}

Here is the call graph for this function:

void mutex_free

(

mutex_t *

mutex

)

Definition at line 264 of file sync0sync.c.

References list(), mutex, mutex_enter, mutex_exit(), mutex_get_lock_word(), mutex_list, mutex_list_mutex, MUTEX_MAGIC_N, mutex_validate(), os_fast_mutex_free(), sync_thread_mutex, ut_a, UT_LIST_GET_NEXT, UT_LIST_GET_PREV, and UT_LIST_REMOVE.

Referenced by dict_mem_table_free(), ib_wqueue_free(), innobase_shutdown_for_mysql(), rw_lock_free(), sync_array_free(), sync_close(), and trx_free().

                                     : mutex */
{
#ifdef UNIV_DEBUG
        ut_a(mutex_validate(mutex));
#endif /* UNIV_DEBUG */
        ut_a(mutex_get_lock_word(mutex) == 0);
        ut_a(mutex_get_waiters(mutex) == 0);

        if (mutex != &mutex_list_mutex && mutex != &sync_thread_mutex) {

                mutex_enter(&mutex_list_mutex);

                if (UT_LIST_GET_PREV(list, mutex)) {
                        ut_a(UT_LIST_GET_PREV(list, mutex)->magic_n
                                                        == MUTEX_MAGIC_N);
                }
                if (UT_LIST_GET_NEXT(list, mutex)) {
                        ut_a(UT_LIST_GET_NEXT(list, mutex)->magic_n
                                                        == MUTEX_MAGIC_N);
                }

                UT_LIST_REMOVE(list, mutex_list, mutex);

                mutex_exit(&mutex_list_mutex);
        }

#if !defined(_WIN32) || !defined(UNIV_CAN_USE_X86_ASSEMBLER)
        os_fast_mutex_free(&(mutex->os_fast_mutex));
#endif
        /* If we free the mutex protecting the mutex list (freeing is
        not necessary), we have to reset the magic number AFTER removing
        it from the list. */

        mutex->magic_n = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void mutex_set_waiters	(	mutex_t *	mutex,
		ulint	n
	)

Definition at line 349 of file sync0sync.c.

References mutex, and ut_ad.

Referenced by mutex_create_func(), mutex_signal_object(), and mutex_spin_wait().

                                     : mutex */
        ulint           n)      /* in: value to set */
{
volatile ulint* ptr;            /* declared volatile to ensure that
                                the value is stored to memory */
        ut_ad(mutex);

        ptr = &(mutex->waiters);

        *ptr = n;               /* Here we assume that the write of a single
                                word in memory is atomic */
}

Here is the caller graph for this function:

void mutex_signal_object

(

mutex_t *

mutex

)

Definition at line 549 of file sync0sync.c.

References mutex, mutex_set_waiters(), sync_array_signal_object(), and sync_primary_wait_array.

                                     : mutex */
{
        mutex_set_waiters(mutex, 0);

        /* The memory order of resetting the waiters field and
        signaling the object is important. See LEMMA 1 above. */

        sync_array_signal_object(sync_primary_wait_array, mutex);
}

Here is the call graph for this function:

void mutex_spin_wait	(	mutex_t *	mutex,
		const char *	file_name,
		ulint	line
	)

Definition at line 370 of file sync0sync.c.

References index(), mutex, mutex_get_lock_word(), mutex_os_wait_count, mutex_set_waiters(), mutex_spin_round_count, mutex_spin_wait_count, mutex_system_call_count, os_thread_get_curr_id(), os_thread_pf(), os_thread_yield(), sec, srv_spin_wait_delay, sync_array_free_cell_protected(), sync_array_reserve_cell(), sync_array_wait_event(), SYNC_MUTEX, sync_primary_wait_array, SYNC_SPIN_ROUNDS, timed_mutexes, ut_ad, ut_delay(), ut_rnd_interval(), and ut_usectime().

                                             : pointer to mutex */
        const char*     file_name,      /* in: file name where mutex
                                        requested */
        ulint           line)           /* in: line where requested */
{
        ulint      index; /* index of the reserved wait cell */
        ulint      i;     /* spin round count */
#ifndef UNIV_HOTBACKUP
        ib_longlong lstart_time = 0, lfinish_time; /* for timing os_wait */
        ulint ltime_diff;
        ulint sec;
        ulint ms;
        uint timer_started = 0;
#endif /* !UNIV_HOTBACKUP */
        ut_ad(mutex);

mutex_loop:

        i = 0;

        /* Spin waiting for the lock word to become zero. Note that we do
        not have to assume that the read access to the lock word is atomic,
        as the actual locking is always committed with atomic test-and-set.
        In reality, however, all processors probably have an atomic read of
        a memory word. */

spin_loop:
#ifndef UNIV_HOTBACKUP
        mutex_spin_wait_count++;
        mutex->count_spin_loop++;
#endif /* !UNIV_HOTBACKUP */

        while (mutex_get_lock_word(mutex) != 0 && i < SYNC_SPIN_ROUNDS) {
                if (srv_spin_wait_delay) {
                        ut_delay(ut_rnd_interval(0, srv_spin_wait_delay));
                }

                i++;
        }

        if (i == SYNC_SPIN_ROUNDS) {
#ifndef UNIV_HOTBACKUP
                mutex->count_os_yield++;
                if (timed_mutexes == 1 && timer_started==0) {
                        ut_usectime(&sec, &ms);
                        lstart_time= (ib_longlong)sec * 1000000 + ms;
                        timer_started = 1;
                }
#endif /* !UNIV_HOTBACKUP */
                os_thread_yield();
        }

#ifdef UNIV_SRV_PRINT_LATCH_WAITS
        fprintf(stderr,
                "Thread %lu spin wait mutex at %p cfile %s cline %lu rnds %lu\n",
                (ulong) os_thread_pf(os_thread_get_curr_id()), (void*) mutex,
                mutex->cfile_name, (ulong) mutex->cline, (ulong) i);
#endif

        mutex_spin_round_count += i;

#ifndef UNIV_HOTBACKUP
        mutex->count_spin_rounds += i;
#endif /* !UNIV_HOTBACKUP */

        if (mutex_test_and_set(mutex) == 0) {
                /* Succeeded! */

#ifdef UNIV_SYNC_DEBUG
                mutex_set_debug_info(mutex, file_name, line);
#endif

                goto finish_timing;
        }

        /* We may end up with a situation where lock_word is 0 but the OS
        fast mutex is still reserved. On FreeBSD the OS does not seem to
        schedule a thread which is constantly calling pthread_mutex_trylock
        (in mutex_test_and_set implementation). Then we could end up
        spinning here indefinitely. The following 'i++' stops this infinite
        spin. */

        i++;

        if (i < SYNC_SPIN_ROUNDS) {
                goto spin_loop;
        }

        sync_array_reserve_cell(sync_primary_wait_array, mutex,
                SYNC_MUTEX, file_name, line, &index);

        mutex_system_call_count++;

        /* The memory order of the array reservation and the change in the
        waiters field is important: when we suspend a thread, we first
        reserve the cell and then set waiters field to 1. When threads are
        released in mutex_exit, the waiters field is first set to zero and
        then the event is set to the signaled state. */

        mutex_set_waiters(mutex, 1);

        /* Try to reserve still a few times */
        for (i = 0; i < 4; i++) {
                if (mutex_test_and_set(mutex) == 0) {
                        /* Succeeded! Free the reserved wait cell */

                        sync_array_free_cell_protected(sync_primary_wait_array,
                                index);

#ifdef UNIV_SYNC_DEBUG
                        mutex_set_debug_info(mutex, file_name, line);
#endif

#ifdef UNIV_SRV_PRINT_LATCH_WAITS
                        fprintf(stderr, "Thread %lu spin wait succeeds at 2:"
                                " mutex at %p\n",
                                (ulong) os_thread_pf(os_thread_get_curr_id()),
                                (void*) mutex);
#endif

                        goto finish_timing;

                        /* Note that in this case we leave the waiters field
                        set to 1. We cannot reset it to zero, as we do not
                        know if there are other waiters. */
                }
        }

        /* Now we know that there has been some thread holding the mutex
        after the change in the wait array and the waiters field was made.
        Now there is no risk of infinite wait on the event. */

#ifdef UNIV_SRV_PRINT_LATCH_WAITS
        fprintf(stderr,
                "Thread %lu OS wait mutex at %p cfile %s cline %lu rnds %lu\n",
                (ulong) os_thread_pf(os_thread_get_curr_id()), (void*) mutex,
                mutex->cfile_name, (ulong) mutex->cline, (ulong) i);
#endif

        mutex_system_call_count++;
        mutex_os_wait_count++;

#ifndef UNIV_HOTBACKUP
        mutex->count_os_wait++;
        /* !!!!! Sometimes os_wait can be called without os_thread_yield */

        if (timed_mutexes == 1 && timer_started==0) {
                ut_usectime(&sec, &ms);
                lstart_time= (ib_longlong)sec * 1000000 + ms;
                timer_started = 1;
        }
#endif /* !UNIV_HOTBACKUP */

        sync_array_wait_event(sync_primary_wait_array, index);
        goto mutex_loop;

finish_timing:
#ifndef UNIV_HOTBACKUP
        if (timed_mutexes == 1 && timer_started==1) {
                ut_usectime(&sec, &ms);
                lfinish_time= (ib_longlong)sec * 1000000 + ms;

                ltime_diff= (ulint) (lfinish_time - lstart_time);
                mutex->lspent_time += ltime_diff;

                if (mutex->lmax_spent_time < ltime_diff) {
                        mutex->lmax_spent_time= ltime_diff;
                }
        }
#endif /* !UNIV_HOTBACKUP */
        return;
}

Here is the call graph for this function:

ibool mutex_validate

(

mutex_t *

mutex

)

Definition at line 335 of file sync0sync.c.

References mutex, MUTEX_MAGIC_N, TRUE, and ut_a.

Referenced by mutex_enter_nowait(), and mutex_free().

{
        ut_a(mutex);
        ut_a(mutex->magic_n == MUTEX_MAGIC_N);

        return(TRUE);
}

Here is the caller graph for this function:

void sync_close

(

void

)

Definition at line 1306 of file sync0sync.c.

References mutex, mutex_free(), mutex_list, mutex_list_mutex, sync_array_free(), sync_primary_wait_array, sync_thread_mutex, and UT_LIST_GET_FIRST.

Referenced by innobase_shutdown_for_mysql().

{
        mutex_t*        mutex;

        sync_array_free(sync_primary_wait_array);

        mutex = UT_LIST_GET_FIRST(mutex_list);

        while (mutex) {
                mutex_free(mutex);
                mutex = UT_LIST_GET_FIRST(mutex_list);
        }

        mutex_free(&mutex_list_mutex);
        mutex_free(&sync_thread_mutex);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void sync_init

(

void

)

Definition at line 1254 of file sync0sync.c.

References FALSE, sync_thread_struct::levels, mutex_create, mutex_list, mutex_list_mutex, NULL, os_event_create(), OS_THREAD_MAX_N, rw_lock_list, rw_lock_list_mutex, sync_array_create(), SYNC_ARRAY_OS_MUTEX, sync_initialized, SYNC_NO_ORDER_CHECK, sync_primary_wait_array, sync_thread_level_arrays, sync_thread_level_arrays_get_nth(), sync_thread_mutex, TRUE, ut_a, UT_LIST_INIT, and ut_malloc().

Referenced by srv_general_init().

{
        sync_thread_t*  thread_slot;
        ulint           i;

        ut_a(sync_initialized == FALSE);

        sync_initialized = TRUE;

        /* Create the primary system wait array which is protected by an OS
        mutex */

        sync_primary_wait_array = sync_array_create(OS_THREAD_MAX_N,
                SYNC_ARRAY_OS_MUTEX);

        /* Create the thread latch level array where the latch levels
        are stored for each OS thread */

        sync_thread_level_arrays = ut_malloc(OS_THREAD_MAX_N
                                                * sizeof(sync_thread_t));
        for (i = 0; i < OS_THREAD_MAX_N; i++) {

                thread_slot = sync_thread_level_arrays_get_nth(i);
                thread_slot->levels = NULL;
        }

        /* Init the mutex list and create the mutex to protect it. */

        UT_LIST_INIT(mutex_list);
        mutex_create(&mutex_list_mutex, SYNC_NO_ORDER_CHECK);

        mutex_create(&sync_thread_mutex, SYNC_NO_ORDER_CHECK);

        /* Init the rw-lock list and create the mutex to protect it. */

        UT_LIST_INIT(rw_lock_list);
        mutex_create(&rw_lock_list_mutex, SYNC_NO_ORDER_CHECK);

#ifdef UNIV_SYNC_DEBUG
        mutex_create(&rw_lock_debug_mutex, SYNC_NO_ORDER_CHECK);

        rw_lock_debug_event = os_event_create(NULL);
        rw_lock_debug_waiters = FALSE;
#endif /* UNIV_SYNC_DEBUG */
}

Here is the call graph for this function:

Here is the caller graph for this function:

void sync_print

(

FILE *

file

)

Definition at line 1353 of file sync0sync.c.

References sync_array_print_info(), sync_primary_wait_array, and sync_print_wait_info().

Referenced by srv_printf_innodb_monitor().

                                     : file where to print */
{
#ifdef UNIV_SYNC_DEBUG
        mutex_list_print_info();

        rw_lock_list_print_info();
#endif /* UNIV_SYNC_DEBUG */

        sync_array_print_info(file, sync_primary_wait_array);

        sync_print_wait_info(file);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void sync_print_wait_info

(

FILE *

file

)

Definition at line 1328 of file sync0sync.c.

References mutex_exit_count, mutex_os_wait_count, mutex_spin_round_count, mutex_spin_wait_count, rw_s_exit_count, rw_s_os_wait_count, rw_s_spin_wait_count, rw_x_exit_count, rw_x_os_wait_count, and rw_x_spin_wait_count.

Referenced by sync_print().

                                     : file where to print */
{
#ifdef UNIV_SYNC_DEBUG
        fprintf(stderr, "Mutex exits %lu, rws exits %lu, rwx exits %lu\n",
                mutex_exit_count, rw_s_exit_count, rw_x_exit_count);
#endif

        fprintf(file,
"Mutex spin waits %lu, rounds %lu, OS waits %lu\n"
"RW-shared spins %lu, OS waits %lu; RW-excl spins %lu, OS waits %lu\n",
                        (ulong) mutex_spin_wait_count,
                        (ulong) mutex_spin_round_count,
                        (ulong) mutex_os_wait_count,
                        (ulong) rw_s_spin_wait_count,
                        (ulong) rw_s_os_wait_count,
                        (ulong) rw_x_spin_wait_count,
                        (ulong) rw_x_os_wait_count);
}

Here is the caller graph for this function:

void sync_thread_add_level	(	void *	latch,
		ulint	level
	)

Definition at line 967 of file sync0sync.c.

References sync_thread_struct::id, sync_level_struct::latch, sync_level_struct::level, sync_thread_struct::levels, mutex_enter, mutex_list_mutex, NULL, os_thread_get_curr_id(), rw_lock_list_mutex, SYNC_ANY_LATCH, SYNC_BUF_BLOCK, SYNC_BUF_POOL, SYNC_DICT, SYNC_DICT_AUTOINC_MUTEX, SYNC_DICT_HEADER, SYNC_DICT_OPERATION, SYNC_DOUBLEWRITE, SYNC_EXTERN_STORAGE, SYNC_FSP, SYNC_FSP_PAGE, SYNC_IBUF_BITMAP, SYNC_IBUF_BITMAP_MUTEX, SYNC_IBUF_HEADER, SYNC_IBUF_MUTEX, SYNC_IBUF_PESS_INSERT_MUTEX, SYNC_INDEX_TREE, SYNC_KERNEL, SYNC_LEVEL_VARYING, SYNC_LOG, SYNC_MEM_HASH, SYNC_MEM_POOL, SYNC_NO_ORDER_CHECK, sync_order_checks_on, SYNC_PURGE_LATCH, SYNC_PURGE_SYS, SYNC_REC_LOCK, SYNC_RECV, SYNC_RSEG, SYNC_RSEG_HEADER, SYNC_RSEG_HEADER_NEW, SYNC_SEARCH_SYS, SYNC_THR_LOCAL, sync_thread_level_arrays_find_free(), sync_thread_level_arrays_find_slot(), sync_thread_levels_contain(), sync_thread_levels_g(), sync_thread_levels_get_nth(), sync_thread_mutex, SYNC_THREAD_N_LEVELS, SYNC_TREE_NODE, SYNC_TREE_NODE_FROM_HASH, SYNC_TREE_NODE_NEW, SYNC_TRX_LOCK_HEAP, SYNC_TRX_SYS_HEADER, SYNC_TRX_UNDO, SYNC_TRX_UNDO_PAGE, SYNC_WORK_QUEUE, ut_a, ut_error, and ut_malloc().

                             : pointer to a mutex or an rw-lock */
        ulint   level)  /* in: level in the latching order; if
                        SYNC_LEVEL_VARYING, nothing is done */
{
        sync_level_t*   array;
        sync_level_t*   slot;
        sync_thread_t*  thread_slot;
        ulint           i;

        if (!sync_order_checks_on) {

                return;
        }

        if ((latch == (void*)&sync_thread_mutex)
                || (latch == (void*)&mutex_list_mutex)
#ifdef UNIV_SYNC_DEBUG
                || (latch == (void*)&rw_lock_debug_mutex)
#endif /* UNIV_SYNC_DEBUG */
                || (latch == (void*)&rw_lock_list_mutex)) {

                return;
        }

        if (level == SYNC_LEVEL_VARYING) {

                return;
        }

        mutex_enter(&sync_thread_mutex);

        thread_slot = sync_thread_level_arrays_find_slot();

        if (thread_slot == NULL) {
                /* We have to allocate the level array for a new thread */
                array = ut_malloc(sizeof(sync_level_t) * SYNC_THREAD_N_LEVELS);

                thread_slot = sync_thread_level_arrays_find_free();

                thread_slot->id = os_thread_get_curr_id();
                thread_slot->levels = array;

                for (i = 0; i < SYNC_THREAD_N_LEVELS; i++) {

                        slot = sync_thread_levels_get_nth(array, i);

                        slot->latch = NULL;
                }
        }

        array = thread_slot->levels;

        /* NOTE that there is a problem with _NODE and _LEAF levels: if the
        B-tree height changes, then a leaf can change to an internal node
        or the other way around. We do not know at present if this can cause
        unnecessary assertion failures below. */

        switch (level) {
        case SYNC_NO_ORDER_CHECK:
        case SYNC_EXTERN_STORAGE:
        case SYNC_TREE_NODE_FROM_HASH:
                /* Do no order checking */
                break;
        case SYNC_MEM_POOL:
                ut_a(sync_thread_levels_g(array, SYNC_MEM_POOL));
                break;
        case SYNC_MEM_HASH:
                ut_a(sync_thread_levels_g(array, SYNC_MEM_HASH));
                break;
        case SYNC_RECV:
                ut_a(sync_thread_levels_g(array, SYNC_RECV));
                break;
        case SYNC_WORK_QUEUE:
                ut_a(sync_thread_levels_g(array, SYNC_WORK_QUEUE));
                break;
        case SYNC_LOG:
                ut_a(sync_thread_levels_g(array, SYNC_LOG));
                break;
        case SYNC_THR_LOCAL:
                ut_a(sync_thread_levels_g(array, SYNC_THR_LOCAL));
                break;
        case SYNC_ANY_LATCH:
                ut_a(sync_thread_levels_g(array, SYNC_ANY_LATCH));
                break;
        case SYNC_TRX_SYS_HEADER:
                ut_a(sync_thread_levels_g(array, SYNC_TRX_SYS_HEADER));
                break;
        case SYNC_DOUBLEWRITE:
                ut_a(sync_thread_levels_g(array, SYNC_DOUBLEWRITE));
                break;
        case SYNC_BUF_BLOCK:
                ut_a((sync_thread_levels_contain(array, SYNC_BUF_POOL)
                                && sync_thread_levels_g(array, SYNC_BUF_BLOCK - 1))
                        || sync_thread_levels_g(array, SYNC_BUF_BLOCK));
                break;
        case SYNC_BUF_POOL:
                ut_a(sync_thread_levels_g(array, SYNC_BUF_POOL));
                break;
        case SYNC_SEARCH_SYS:
                ut_a(sync_thread_levels_g(array, SYNC_SEARCH_SYS));
                break;
        case SYNC_TRX_LOCK_HEAP:
                ut_a(sync_thread_levels_g(array, SYNC_TRX_LOCK_HEAP));
                break;
        case SYNC_REC_LOCK:
                ut_a((sync_thread_levels_contain(array, SYNC_KERNEL)
                                && sync_thread_levels_g(array, SYNC_REC_LOCK - 1))
                        || sync_thread_levels_g(array, SYNC_REC_LOCK));
                break;
        case SYNC_KERNEL:
                ut_a(sync_thread_levels_g(array, SYNC_KERNEL));
                break;
        case SYNC_IBUF_BITMAP:
                ut_a((sync_thread_levels_contain(array, SYNC_IBUF_BITMAP_MUTEX)
                                && sync_thread_levels_g(array, SYNC_IBUF_BITMAP - 1))
                        || sync_thread_levels_g(array, SYNC_IBUF_BITMAP));
                break;
        case SYNC_IBUF_BITMAP_MUTEX:
                ut_a(sync_thread_levels_g(array, SYNC_IBUF_BITMAP_MUTEX));
                break;
        case SYNC_FSP_PAGE:
                ut_a(sync_thread_levels_contain(array, SYNC_FSP));
                break;
        case SYNC_FSP:
                ut_a(sync_thread_levels_contain(array, SYNC_FSP)
                        || sync_thread_levels_g(array, SYNC_FSP));
                break;
        case SYNC_TRX_UNDO_PAGE:
                ut_a(sync_thread_levels_contain(array, SYNC_TRX_UNDO)
                        || sync_thread_levels_contain(array, SYNC_RSEG)
                        || sync_thread_levels_contain(array, SYNC_PURGE_SYS)
                        || sync_thread_levels_g(array, SYNC_TRX_UNDO_PAGE));
                break;
        case SYNC_RSEG_HEADER:
                ut_a(sync_thread_levels_contain(array, SYNC_RSEG));
                break;
        case SYNC_RSEG_HEADER_NEW:
                ut_a(sync_thread_levels_contain(array, SYNC_KERNEL)
                        && sync_thread_levels_contain(array, SYNC_FSP_PAGE));
                break;
        case SYNC_RSEG:
                ut_a(sync_thread_levels_g(array, SYNC_RSEG));
                break;
        case SYNC_TRX_UNDO:
                ut_a(sync_thread_levels_g(array, SYNC_TRX_UNDO));
                break;
        case SYNC_PURGE_LATCH:
                ut_a(sync_thread_levels_g(array, SYNC_PURGE_LATCH));
                break;
        case SYNC_PURGE_SYS:
                ut_a(sync_thread_levels_g(array, SYNC_PURGE_SYS));
                break;
        case SYNC_TREE_NODE:
                ut_a(sync_thread_levels_contain(array, SYNC_INDEX_TREE)
                        || sync_thread_levels_g(array, SYNC_TREE_NODE - 1));
                break;
        case SYNC_TREE_NODE_NEW:
                ut_a(sync_thread_levels_contain(array, SYNC_FSP_PAGE)
                        || sync_thread_levels_contain(array, SYNC_IBUF_MUTEX));
                break;
        case SYNC_INDEX_TREE:
                ut_a((sync_thread_levels_contain(array, SYNC_IBUF_MUTEX)
                        && sync_thread_levels_contain(array, SYNC_FSP)
                        && sync_thread_levels_g(array, SYNC_FSP_PAGE - 1))
                        || sync_thread_levels_g(array, SYNC_TREE_NODE - 1));
                break;
        case SYNC_IBUF_MUTEX:
                ut_a(sync_thread_levels_g(array, SYNC_FSP_PAGE - 1));
                break;
        case SYNC_IBUF_PESS_INSERT_MUTEX:
                ut_a(sync_thread_levels_g(array, SYNC_FSP - 1)
                        && !sync_thread_levels_contain(array, SYNC_IBUF_MUTEX));
                break;
        case SYNC_IBUF_HEADER:
                ut_a(sync_thread_levels_g(array, SYNC_FSP - 1)
                        && !sync_thread_levels_contain(array, SYNC_IBUF_MUTEX)
                        && !sync_thread_levels_contain(array,
                                SYNC_IBUF_PESS_INSERT_MUTEX));
                break;
        case SYNC_DICT_AUTOINC_MUTEX:
                ut_a(sync_thread_levels_g(array, SYNC_DICT_AUTOINC_MUTEX));
                break;
        case SYNC_DICT_OPERATION:
                ut_a(sync_thread_levels_g(array, SYNC_DICT_OPERATION));
                break;
        case SYNC_DICT_HEADER:
                ut_a(sync_thread_levels_g(array, SYNC_DICT_HEADER));
                break;
        case SYNC_DICT:
#ifdef UNIV_DEBUG
                ut_a(buf_debug_prints
                        || sync_thread_levels_g(array, SYNC_DICT));
#else /* UNIV_DEBUG */
                ut_a(sync_thread_levels_g(array, SYNC_DICT));
#endif /* UNIV_DEBUG */
                break;
        default:
                ut_error;
        }

        for (i = 0; i < SYNC_THREAD_N_LEVELS; i++) {

                slot = sync_thread_levels_get_nth(array, i);

                if (slot->latch == NULL) {
                        slot->latch = latch;
                        slot->level = level;

                        break;
                }
        }

        ut_a(i < SYNC_THREAD_N_LEVELS);

        mutex_exit(&sync_thread_mutex);
}

Here is the call graph for this function:

static sync_thread_t* sync_thread_level_arrays_find_free

(

void

)

[static]

Definition at line 758 of file sync0sync.c.

References sync_thread_struct::levels, NULL, OS_THREAD_MAX_N, and sync_thread_level_arrays_get_nth().

Referenced by sync_thread_add_level().

                              : pointer to thread slot */

{
        sync_thread_t*  slot;
        ulint           i;

        for (i = 0; i < OS_THREAD_MAX_N; i++) {

                slot = sync_thread_level_arrays_get_nth(i);

                if (slot->levels == NULL) {

                        return(slot);
                }
        }

        return(NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static sync_thread_t* sync_thread_level_arrays_find_slot

(

void

)

[static]

Definition at line 730 of file sync0sync.c.

References sync_thread_struct::id, id, sync_thread_struct::levels, os_thread_eq(), os_thread_get_curr_id(), OS_THREAD_MAX_N, and sync_thread_level_arrays_get_nth().

Referenced by sync_thread_add_level(), sync_thread_levels_empty_gen(), and sync_thread_reset_level().

                              : pointer to thread slot, NULL if not found */

{
        sync_thread_t*  slot;
        os_thread_id_t  id;
        ulint           i;

        id = os_thread_get_curr_id();

        for (i = 0; i < OS_THREAD_MAX_N; i++) {

                slot = sync_thread_level_arrays_get_nth(i);

                if (slot->levels && os_thread_eq(slot->id, id)) {

                        return(slot);
                }
        }

        return(NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static sync_thread_t* sync_thread_level_arrays_get_nth

(

ulint

n

)

[static]

Definition at line 716 of file sync0sync.c.

References OS_THREAD_MAX_N, sync_thread_level_arrays, and ut_ad.

Referenced by sync_init(), sync_thread_level_arrays_find_free(), and sync_thread_level_arrays_find_slot().

                              : pointer to thread slot */
        ulint   n)      /* in: slot number */
{
        ut_ad(n < OS_THREAD_MAX_N);

        return(sync_thread_level_arrays + n);
}

Here is the caller graph for this function:

static ibool sync_thread_levels_contain	(	sync_level_t *	arr,
		ulint	level
	)			[static]

Definition at line 869 of file sync0sync.c.

References sync_level_struct::latch, sync_level_struct::level, NULL, sync_thread_levels_get_nth(), SYNC_THREAD_N_LEVELS, and TRUE.

Referenced by sync_thread_add_level().

                                      : TRUE if stored */
        sync_level_t*   arr,    /* in: pointer to level array for an OS
                                thread */
        ulint           level)  /* in: level */
{
        sync_level_t*   slot;
        ulint           i;

        for (i = 0; i < SYNC_THREAD_N_LEVELS; i++) {

                slot = sync_thread_levels_get_nth(arr, i);

                if (slot->latch != NULL) {
                        if (slot->level == level) {

                                return(TRUE);
                        }
                }
        }

        return(FALSE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ibool sync_thread_levels_empty

(

void

)

Definition at line 954 of file sync0sync.c.

References FALSE, and sync_thread_levels_empty_gen().

                              : TRUE if empty */
{
        return(sync_thread_levels_empty_gen(FALSE));
}

Here is the call graph for this function:

ibool sync_thread_levels_empty_gen

(

ibool

dict_mutex_allowed

)

Definition at line 898 of file sync0sync.c.

References FALSE, sync_level_struct::latch, sync_level_struct::level, sync_thread_struct::levels, mutex_enter, mutex_exit(), NULL, SYNC_DICT, SYNC_DICT_OPERATION, sync_order_checks_on, sync_thread_level_arrays_find_slot(), sync_thread_levels_get_nth(), sync_thread_mutex, SYNC_THREAD_N_LEVELS, TRUE, and ut_error.

Referenced by buf_flush_batch(), row_sel(), and sync_thread_levels_empty().

                                              : TRUE if empty except the
                                        exceptions specified below */
        ibool   dict_mutex_allowed)     /* in: TRUE if dictionary mutex is
                                        allowed to be owned by the thread,
                                        also purge_is_running mutex is
                                        allowed */
{
        sync_level_t*   arr;
        sync_thread_t*  thread_slot;
        sync_level_t*   slot;
        ulint           i;

        if (!sync_order_checks_on) {

                return(TRUE);
        }

        mutex_enter(&sync_thread_mutex);

        thread_slot = sync_thread_level_arrays_find_slot();

        if (thread_slot == NULL) {

                mutex_exit(&sync_thread_mutex);

                return(TRUE);
        }

        arr = thread_slot->levels;

        for (i = 0; i < SYNC_THREAD_N_LEVELS; i++) {

                slot = sync_thread_levels_get_nth(arr, i);

                if (slot->latch != NULL && (!dict_mutex_allowed ||
                                (slot->level != SYNC_DICT
                                && slot->level != SYNC_DICT_OPERATION))) {

                        mutex_exit(&sync_thread_mutex);
                        ut_error;

                        return(FALSE);
                }
        }

        mutex_exit(&sync_thread_mutex);

        return(TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static ibool sync_thread_levels_g	(	sync_level_t *	arr,
		ulint	limit
	)			[static]

Definition at line 800 of file sync0sync.c.

References FALSE, sync_level_struct::latch, sync_level_struct::level, lock, mutex, mutex_get_lock_word(), MUTEX_MAGIC_N, NULL, os_thread_pf(), sync_thread_levels_get_nth(), and SYNC_THREAD_N_LEVELS.

Referenced by sync_thread_add_level().

                                      : TRUE if all greater */
        sync_level_t*   arr,    /* in: pointer to level array for an OS
                                thread */
        ulint           limit)  /* in: level limit */
{
        sync_level_t*   slot;
        rw_lock_t*      lock;
        mutex_t*        mutex;
        ulint           i;

        for (i = 0; i < SYNC_THREAD_N_LEVELS; i++) {

                slot = sync_thread_levels_get_nth(arr, i);

                if (slot->latch != NULL) {
                        if (slot->level <= limit) {

                                lock = slot->latch;
                                mutex = slot->latch;

                                fprintf(stderr,
        "InnoDB error: sync levels should be > %lu but a level is %lu\n",
                                (ulong) limit, (ulong) slot->level);

                                if (mutex->magic_n == MUTEX_MAGIC_N) {
                                        fprintf(stderr,
                                                "Mutex created at %s %lu\n",
                                                mutex->cfile_name,
                                                (ulong) mutex->cline);

                                        if (mutex_get_lock_word(mutex) != 0) {
#ifdef UNIV_SYNC_DEBUG
                                                const char*     file_name;
                                                ulint           line;
                                                os_thread_id_t  thread_id;

                                                mutex_get_debug_info(mutex,
                                                &file_name, &line, &thread_id);

                                                fprintf(stderr,
                "InnoDB: Locked mutex: addr %p thread %ld file %s line %ld\n",
                (void*) mutex, os_thread_pf(thread_id), file_name, (ulong) line);
#else /* UNIV_SYNC_DEBUG */
                                                fprintf(stderr,
                "InnoDB: Locked mutex: addr %p\n", (void*) mutex);
#endif /* UNIV_SYNC_DEBUG */
                                        } else {
                                                fputs("Not locked\n", stderr);
                                        }
                                } else {
#ifdef UNIV_SYNC_DEBUG
                                        rw_lock_print(lock);
#endif /* UNIV_SYNC_DEBUG */
                                }

                                return(FALSE);
                        }
                }
        }

        return(TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static sync_level_t* sync_thread_levels_get_nth	(	sync_level_t *	arr,
		ulint	n
	)			[static]

Definition at line 783 of file sync0sync.c.

References SYNC_THREAD_N_LEVELS, and ut_ad.

Referenced by sync_thread_add_level(), sync_thread_levels_contain(), sync_thread_levels_empty_gen(), sync_thread_levels_g(), and sync_thread_reset_level().

                                      : pointer to level slot */
        sync_level_t*   arr,    /* in: pointer to level array for an OS
                                thread */
        ulint           n)      /* in: slot number */
{
        ut_ad(n < SYNC_THREAD_N_LEVELS);

        return(arr + n);
}

Here is the caller graph for this function:

ibool sync_thread_reset_level

(

void *

latch

)

Definition at line 1190 of file sync0sync.c.

References FALSE, sync_level_struct::latch, sync_thread_struct::levels, mutex_enter, mutex_exit(), mutex_list_mutex, NULL, rw_lock_list_mutex, sync_order_checks_on, sync_thread_level_arrays_find_slot(), sync_thread_levels_get_nth(), sync_thread_mutex, SYNC_THREAD_N_LEVELS, TRUE, and ut_error.

                              : TRUE if found from the array; it is an error
                        if the latch is not found */
        void*   latch)  /* in: pointer to a mutex or an rw-lock */
{
        sync_level_t*   array;
        sync_level_t*   slot;
        sync_thread_t*  thread_slot;
        ulint           i;

        if (!sync_order_checks_on) {

                return(FALSE);
        }

        if ((latch == (void*)&sync_thread_mutex)
                || (latch == (void*)&mutex_list_mutex)
#ifdef UNIV_SYNC_DEBUG
                || (latch == (void*)&rw_lock_debug_mutex)
#endif /* UNIV_SYNC_DEBUG */
                || (latch == (void*)&rw_lock_list_mutex)) {

                return(FALSE);
        }

        mutex_enter(&sync_thread_mutex);

        thread_slot = sync_thread_level_arrays_find_slot();

        if (thread_slot == NULL) {

                ut_error;

                mutex_exit(&sync_thread_mutex);
                return(FALSE);
        }

        array = thread_slot->levels;

        for (i = 0; i < SYNC_THREAD_N_LEVELS; i++) {

                slot = sync_thread_levels_get_nth(array, i);

                if (slot->latch == latch) {
                        slot->latch = NULL;

                        mutex_exit(&sync_thread_mutex);

                        return(TRUE);
                }
        }

        ut_error;

        mutex_exit(&sync_thread_mutex);

        return(FALSE);
}

Here is the call graph for this function:

---

Variable Documentation

mutex_t dummy_mutex_for_fence

Definition at line 154 of file sync0sync.c.

ulint mutex_exit_count = 0

Definition at line 123 of file sync0sync.c.

Referenced by sync_print_wait_info().

ut_list_base_node_t mutex_list

Definition at line 145 of file sync0sync.c.

Referenced by mutex_create_func(), mutex_free(), sync_close(), and sync_init().

mutex_t mutex_list_mutex

Definition at line 148 of file sync0sync.c.

Referenced by mutex_create_func(), mutex_free(), sync_close(), sync_init(), sync_thread_add_level(), and sync_thread_reset_level().

ulint mutex_os_wait_count = 0

Definition at line 122 of file sync0sync.c.

Referenced by mutex_spin_wait(), and sync_print_wait_info().

ulint mutex_spin_round_count = 0

Definition at line 120 of file sync0sync.c.

Referenced by mutex_spin_wait(), and sync_print_wait_info().

ulint mutex_spin_wait_count = 0

Definition at line 121 of file sync0sync.c.

Referenced by mutex_spin_wait(), and sync_print_wait_info().

ulint mutex_system_call_count = 0

Definition at line 116 of file sync0sync.c.

Referenced by mutex_spin_wait().

ulint sync_dummy = 0

Definition at line 111 of file sync0sync.c.

ibool sync_initialized = FALSE

Definition at line 130 of file sync0sync.c.

Referenced by sync_init().

ibool sync_order_checks_on = FALSE

Definition at line 151 of file sync0sync.c.

Referenced by innobase_start_or_create_for_mysql(), sync_thread_add_level(), sync_thread_levels_empty_gen(), and sync_thread_reset_level().

sync_array_t* sync_primary_wait_array

Definition at line 127 of file sync0sync.c.

Referenced by mutex_signal_object(), mutex_spin_wait(), rw_lock_s_lock_spin(), rw_lock_x_lock_func(), sync_arr_wake_threads_if_sema_free(), sync_array_print_long_waits(), sync_close(), sync_init(), and sync_print().

sync_thread_t* sync_thread_level_arrays

Definition at line 139 of file sync0sync.c.

Referenced by sync_init(), and sync_thread_level_arrays_get_nth().

mutex_t sync_thread_mutex

Definition at line 142 of file sync0sync.c.

Referenced by mutex_create_func(), mutex_free(), sync_close(), sync_init(), sync_thread_add_level(), sync_thread_levels_empty_gen(), and sync_thread_reset_level().

---

• Products
• MySQL Enterprise
• MySQL Cluster
• MySQL Embedded (OEM/ISV)
• MySQL Data Warehouse
• MySQL Backup & Recovery
• MySQL Workbench
• MySQL Connectors
• Online Shop

• Downloads
• MySQL Community Server
• MySQL Enterprise
• MySQL Proxy
• MySQL Cluster
• MySQL Workbench
• GUI Tools
• Connectors
• Archives
• Snapshots
• Mirrors

• Developer Zone
• Documentation
• Librarian
• Developer Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs
• MySQL Meetups
• Guilds
• Lists

• About
• About MySQL
• Contact Us
• Legal
• Privacy Policy
• Job Opportunities
• Site Map

© 1995-2008 MySQL AB, 2008- Sun Microsystems, Inc.