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/sync0arr.c File Reference

#include "sync0arr.h"
#include "sync0sync.h"
#include "sync0rw.h"
#include "os0sync.h"
#include "os0file.h"
#include "srv0srv.h"

Include dependency graph for sync0arr.c:

Go to the source code of this file.

Classes
struct	sync_cell_struct
struct	sync_array_struct
Functions
static sync_cell_t *	sync_array_get_nth_cell (sync_array_t *arr, ulint n)
static void	sync_array_enter (sync_array_t *arr)
static void	sync_array_exit (sync_array_t *arr)
sync_array_t *	sync_array_create (ulint n_cells, ulint protection)
void	sync_array_free (sync_array_t *arr)
void	sync_array_validate (sync_array_t *arr)
void	sync_array_reserve_cell (sync_array_t *arr, void *object, ulint type, const char *file, ulint line, ulint *index)
static void	sync_array_free_cell (sync_array_t *arr, ulint index)
void	sync_array_free_cell_protected (sync_array_t *arr, ulint index)
void	sync_array_wait_event (sync_array_t *arr, ulint index)
static void	sync_array_cell_print (FILE *file, sync_cell_t *cell)
static ibool	sync_arr_cell_can_wake_up (sync_cell_t *cell)
void	sync_array_signal_object (sync_array_t *arr, void *object)
void	sync_arr_wake_threads_if_sema_free (void)
ibool	sync_array_print_long_waits (void)
static void	sync_array_output_info (FILE *file, sync_array_t *arr)
void	sync_array_print_info (FILE *file, sync_array_t *arr)

---

Function Documentation

static ibool sync_arr_cell_can_wake_up

(

sync_cell_t *

cell

)

[static]

Definition at line 796 of file sync0arr.c.

References FALSE, lock, mutex, mutex_get_lock_word(), os_thread_eq(), sync_cell_struct::request_type, RW_LOCK_EX, rw_lock_get_reader_count(), rw_lock_get_writer(), RW_LOCK_NOT_LOCKED, RW_LOCK_SHARED, RW_LOCK_WAIT_EX, SYNC_MUTEX, sync_cell_struct::thread, TRUE, and sync_cell_struct::wait_object.

Referenced by sync_arr_wake_threads_if_sema_free().

                                     : cell to search */
{
        mutex_t*        mutex;
        rw_lock_t*      lock;

        if (cell->request_type == SYNC_MUTEX) {

                mutex = cell->wait_object;

                if (mutex_get_lock_word(mutex) == 0) {

                        return(TRUE);
                }

        } else if (cell->request_type == RW_LOCK_EX) {

                lock = cell->wait_object;

                if (rw_lock_get_reader_count(lock) == 0
                        && rw_lock_get_writer(lock) == RW_LOCK_NOT_LOCKED) {

                        return(TRUE);
                }

                if (rw_lock_get_reader_count(lock) == 0
                        && rw_lock_get_writer(lock) == RW_LOCK_WAIT_EX
                        && os_thread_eq(lock->writer_thread, cell->thread)) {

                        return(TRUE);
                }

        } else if (cell->request_type == RW_LOCK_SHARED) {
                lock = cell->wait_object;

                if (rw_lock_get_writer(lock) == RW_LOCK_NOT_LOCKED) {

                        return(TRUE);
                }
        }

        return(FALSE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void sync_arr_wake_threads_if_sema_free

(

void

)

Definition at line 948 of file sync0arr.c.

References count, sync_cell_struct::event, sync_cell_struct::event_set, sync_array_struct::n_reserved, os_event_set(), sync_cell_struct::state, sync_arr_cell_can_wake_up(), sync_array_enter(), sync_array_exit(), sync_array_get_nth_cell(), sync_primary_wait_array, TRUE, and ut_a.

Referenced by srv_lock_timeout_and_monitor_thread().

{
        sync_array_t*   arr     = sync_primary_wait_array;
        sync_cell_t*    cell;
        ulint           count;
        ulint           i;
        ulint           res_count;

        sync_array_enter(arr);

        i = 0;
        count = 0;

        /* We need to store this to a local variable because it is modified
        inside the loop */

        res_count = arr->n_reserved;

        while (count < res_count) {

                cell = sync_array_get_nth_cell(arr, i);

                if (cell->state == SC_RESERVED) {

                        count++;

                        if (sync_arr_cell_can_wake_up(cell)) {
                                cell->state = SC_WAKING_UP;
                                cell->event_set = TRUE;
                                os_event_set(cell->event);

                                ut_a(arr->n_reserved > 0);
                                arr->n_reserved--;
                        }
                }

                i++;
        }

        sync_array_exit(arr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sync_array_cell_print	(	FILE *	file,
		sync_cell_t *	cell
	)			[static]

Definition at line 489 of file sync0arr.c.

References rw_lock_struct::cfile_name, sync_cell_struct::event_set, sync_cell_struct::file, sync_cell_struct::line, mutex, NULL, sync_cell_struct::old_wait_mutex, sync_cell_struct::old_wait_rw_lock, os_thread_pf(), sync_cell_struct::request_type, sync_cell_struct::reservation_time, RW_LOCK_EX, RW_LOCK_NOT_LOCKED, RW_LOCK_SHARED, sync_cell_struct::state, SYNC_MUTEX, sync_cell_struct::thread, and ut_error.

Referenced by sync_array_output_info(), and sync_array_print_long_waits().

                                     : file where to print */
        sync_cell_t*    cell)   /* in: sync cell */
{
        mutex_t*        mutex;
        rw_lock_t*      rwlock;
        ulint           type;

        type = cell->request_type;

        fprintf(file,
"--Thread %lu has waited at %s line %lu for %.2f seconds the semaphore:\n",
                (ulong) os_thread_pf(cell->thread), cell->file,
                (ulong) cell->line,
                difftime(time(NULL), cell->reservation_time));
        fprintf(file, "Wait array cell state %lu\n", (ulong)cell->state);

        /* If the memory area pointed to by old_wait_mutex /
        old_wait_rw_lock has been freed, this can crash. */

        if (cell->state != SC_RESERVED) {
                /* If cell has this state, then even if we are holding the sync
                array mutex, the wait object may get freed meanwhile. Do not
                print the wait object then. */

        } else if (type == SYNC_MUTEX) {
                /* We use old_wait_mutex in case the cell has already
                been freed meanwhile */
                mutex = cell->old_wait_mutex;

                fprintf(file,
                        "Mutex at %p created file %s line %lu, lock var %lu\n"
#ifdef UNIV_SYNC_DEBUG
                        "Last time reserved in file %s line %lu, "
#endif /* UNIV_SYNC_DEBUG */
                        "waiters flag %lu\n",
                        (void*) mutex, mutex->cfile_name, (ulong) mutex->cline,
                        (ulong) mutex->lock_word,
#ifdef UNIV_SYNC_DEBUG
                        mutex->file_name, (ulong) mutex->line,
#endif /* UNIV_SYNC_DEBUG */
                        (ulong) mutex->waiters);

        } else if (type == RW_LOCK_EX || type == RW_LOCK_SHARED) {

                fputs(type == RW_LOCK_EX ? "X-lock on" : "S-lock on", file);

                rwlock = cell->old_wait_rw_lock;

                fprintf(file,
                        " RW-latch at %p created in file %s line %lu\n",
                        (void*) rwlock, rwlock->cfile_name,
                        (ulong) rwlock->cline);
                if (rwlock->writer != RW_LOCK_NOT_LOCKED) {
                        fprintf(file,
                        "a writer (thread id %lu) has reserved it in mode %s",
                                (ulong) os_thread_pf(rwlock->writer_thread),
                                rwlock->writer == RW_LOCK_EX
                                ? " exclusive\n"
                                : " wait exclusive\n");
                }

                fprintf(file,
                        "number of readers %lu, waiters flag %lu\n"
                        "Last time read locked in file %s line %lu\n"
                        "Last time write locked in file %s line %lu\n",
                        (ulong) rwlock->reader_count,
                        (ulong) rwlock->waiters,
                        rwlock->last_s_file_name,
                        (ulong) rwlock->last_s_line,
                        rwlock->last_x_file_name,
                        (ulong) rwlock->last_x_line);
        } else {
                ut_error;
        }

        if (cell->event_set) {
                fputs("wait is ending\n", file);
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

sync_array_t* sync_array_create	(	ulint	n_cells,
		ulint	protection
	)

Definition at line 184 of file sync0arr.c.

References sync_array_struct::array, sync_cell_struct::event, sync_cell_struct::event_set, FALSE, sync_array_struct::mutex, mutex_create, sync_array_struct::n_cells, sync_array_struct::n_reserved, NULL, os_event_create(), sync_array_struct::os_mutex, os_mutex_create(), sync_array_struct::protection, sync_array_struct::res_count, sync_array_struct::sg_count, sync_cell_struct::state, sync_array_get_nth_cell(), SYNC_ARRAY_MUTEX, SYNC_ARRAY_OS_MUTEX, SYNC_NO_ORDER_CHECK, ut_a, ut_error, ut_malloc(), and sync_cell_struct::wait_object.

Referenced by sync_init().

                                           : created wait array */
        ulint   n_cells,        /* in: number of cells in the array
                                to create */
        ulint   protection)     /* in: either SYNC_ARRAY_OS_MUTEX or
                                SYNC_ARRAY_MUTEX: determines the type
                                of mutex protecting the data structure */
{
        sync_array_t*   arr;
        sync_cell_t*    cell_array;
        sync_cell_t*    cell;
        ulint           i;

        ut_a(n_cells > 0);

        /* Allocate memory for the data structures */
        arr = ut_malloc(sizeof(sync_array_t));

        cell_array = ut_malloc(sizeof(sync_cell_t) * n_cells);

        arr->n_cells = n_cells;
        arr->n_reserved = 0;
        arr->array = cell_array;
        arr->protection = protection;
        arr->sg_count = 0;
        arr->res_count = 0;

        /* Then create the mutex to protect the wait array complex */
        if (protection == SYNC_ARRAY_OS_MUTEX) {
                arr->os_mutex = os_mutex_create(NULL);
        } else if (protection == SYNC_ARRAY_MUTEX) {
                mutex_create(&arr->mutex, SYNC_NO_ORDER_CHECK);
        } else {
                ut_error;
        }

        for (i = 0; i < n_cells; i++) {
                cell = sync_array_get_nth_cell(arr, i);
                cell->state = SC_FREE;
                cell->wait_object = NULL;

                /* Create an operating system event semaphore with no name */
                cell->event = os_event_create(NULL);
                cell->event_set = FALSE; /* it is created in reset state */
        }

        return(arr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sync_array_enter

(

sync_array_t *

arr

)

[static]

Definition at line 140 of file sync0arr.c.

References sync_array_struct::mutex, mutex_enter, sync_array_struct::os_mutex, os_mutex_enter(), sync_array_struct::protection, SYNC_ARRAY_MUTEX, SYNC_ARRAY_OS_MUTEX, and ut_error.

Referenced by sync_arr_wake_threads_if_sema_free(), sync_array_free_cell_protected(), sync_array_print_info(), sync_array_reserve_cell(), sync_array_signal_object(), sync_array_validate(), and sync_array_wait_event().

                                     : sync wait array */
{
        ulint   protection;

        protection = arr->protection;

        if (protection == SYNC_ARRAY_OS_MUTEX) {
                os_mutex_enter(arr->os_mutex);
        } else if (protection == SYNC_ARRAY_MUTEX) {
                mutex_enter(&(arr->mutex));
        } else {
                ut_error;
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sync_array_exit

(

sync_array_t *

arr

)

[static]

Definition at line 161 of file sync0arr.c.

References sync_array_struct::mutex, mutex_exit(), sync_array_struct::os_mutex, os_mutex_exit(), sync_array_struct::protection, SYNC_ARRAY_MUTEX, SYNC_ARRAY_OS_MUTEX, and ut_error.

Referenced by sync_arr_wake_threads_if_sema_free(), sync_array_free_cell_protected(), sync_array_print_info(), sync_array_reserve_cell(), sync_array_signal_object(), and sync_array_wait_event().

                                     : sync wait array */
{
        ulint   protection;

        protection = arr->protection;

        if (protection == SYNC_ARRAY_OS_MUTEX) {
                os_mutex_exit(arr->os_mutex);
        } else if (protection == SYNC_ARRAY_MUTEX) {
                mutex_exit(&(arr->mutex));
        } else {
                ut_error;
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void sync_array_free

(

sync_array_t *

arr

)

Definition at line 238 of file sync0arr.c.

References sync_array_struct::array, sync_cell_struct::event, sync_array_struct::mutex, mutex_free(), sync_array_struct::n_cells, sync_array_struct::n_reserved, os_event_free(), sync_array_struct::os_mutex, os_mutex_free(), sync_array_struct::protection, sync_array_get_nth_cell(), SYNC_ARRAY_MUTEX, SYNC_ARRAY_OS_MUTEX, sync_array_validate(), ut_a, ut_error, and ut_free().

Referenced by sync_close().

                                          : sync wait array */
{
        ulint           i;
        sync_cell_t*    cell;
        ulint           protection;

        ut_a(arr->n_reserved == 0);

        sync_array_validate(arr);

        for (i = 0; i < arr->n_cells; i++) {
                cell = sync_array_get_nth_cell(arr, i);
                os_event_free(cell->event);
        }

        protection = arr->protection;

        /* Release the mutex protecting the wait array complex */

        if (protection == SYNC_ARRAY_OS_MUTEX) {
                os_mutex_free(arr->os_mutex);
        } else if (protection == SYNC_ARRAY_MUTEX) {
                mutex_free(&(arr->mutex));
        } else {
                ut_error;
        }

        ut_free(arr->array);
        ut_free(arr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sync_array_free_cell	(	sync_array_t *	arr,
		ulint	index
	)			[static]

Definition at line 376 of file sync0arr.c.

References NULL, sync_cell_struct::state, sync_array_get_nth_cell(), ut_a, and sync_cell_struct::wait_object.

Referenced by sync_array_wait_event().

                                     : wait array */
        ulint           index)  /* in: index of the cell in array */
{
        sync_cell_t*    cell;

        cell = sync_array_get_nth_cell(arr, index);

        ut_a(cell->state == SC_WAKING_UP);
        ut_a(cell->wait_object != NULL);

        cell->state = SC_FREE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void sync_array_free_cell_protected	(	sync_array_t *	arr,
		ulint	index
	)

Definition at line 396 of file sync0arr.c.

References sync_cell_struct::event, sync_array_struct::n_reserved, NULL, os_event_wait(), sync_cell_struct::state, sync_array_enter(), sync_array_exit(), sync_array_get_nth_cell(), ut_a, and sync_cell_struct::wait_object.

Referenced by mutex_spin_wait().

                                     : wait array */
        ulint           index)  /* in: index of the cell in array */
{
        sync_cell_t*    cell;

        sync_array_enter(arr);

        cell = sync_array_get_nth_cell(arr, index);

        ut_a(cell->state != SC_FREE);
        ut_a(cell->wait_object != NULL);

        /* We only need to decrement n_reserved if it has not already been
        done by sync_array_signal_object. */
        if (cell->state == SC_RESERVED) {
                ut_a(arr->n_reserved > 0);
                arr->n_reserved--;
        } else if (cell->state == SC_WAKING_UP) {
                /* This is tricky; if we don't wait for the event to be
                signaled, signal_object can set the state of a cell to
                SC_WAKING_UP, mutex_spin_wait can call this and set the
                state to SC_FREE, and then signal_object gets around to
                calling os_set_event for the cell but since it's already
                been freed things break horribly. */

                sync_array_exit(arr);
                os_event_wait(cell->event);
                sync_array_enter(arr);
        }

        cell->state = SC_FREE;

        sync_array_exit(arr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static sync_cell_t* sync_array_get_nth_cell	(	sync_array_t *	arr,
		ulint	n
	)			[static]

Definition at line 124 of file sync0arr.c.

References sync_array_struct::array, and ut_a.

Referenced by sync_arr_wake_threads_if_sema_free(), sync_array_create(), sync_array_free(), sync_array_free_cell(), sync_array_free_cell_protected(), sync_array_output_info(), sync_array_print_long_waits(), sync_array_reserve_cell(), sync_array_signal_object(), sync_array_validate(), and sync_array_wait_event().

                                      : cell */
        sync_array_t*   arr,    /* in: sync array */
        ulint           n)      /* in: index */
{
        ut_a(arr);
        ut_a(n < arr->n_cells);

        return(arr->array + n);
}

Here is the caller graph for this function:

static void sync_array_output_info	(	FILE *	file,
		sync_array_t *	arr
	)			[static]

Definition at line 1058 of file sync0arr.c.

References sync_array_struct::n_cells, sync_array_struct::res_count, sync_array_struct::sg_count, sync_cell_struct::state, sync_array_cell_print(), and sync_array_get_nth_cell().

Referenced by sync_array_print_info().

                                     : file where to print */
        sync_array_t*   arr)    /* in: wait array; NOTE! caller must own the
                                mutex */
{
        sync_cell_t*    cell;
        ulint           i;

        fprintf(file,
        "OS WAIT ARRAY INFO: reservation count %ld, signal count %ld\n",
                                                (long) arr->res_count,
                                                (long) arr->sg_count);
        for (i = 0; i < arr->n_cells; i++) {

                cell = sync_array_get_nth_cell(arr, i);

                if (cell->state != SC_FREE) {
                        sync_array_cell_print(file, cell);
                }
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void sync_array_print_info	(	FILE *	file,
		sync_array_t *	arr
	)

Definition at line 1085 of file sync0arr.c.

References sync_array_enter(), sync_array_exit(), and sync_array_output_info().

Referenced by sync_print().

                                     : file where to print */
        sync_array_t*   arr)    /* in: wait array */
{
        sync_array_enter(arr);

        sync_array_output_info(file, arr);

        sync_array_exit(arr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ibool sync_array_print_long_waits

(

void

)

Definition at line 995 of file sync0arr.c.

References FALSE, yaSSL::fatal, sync_array_struct::n_cells, NULL, sync_cell_struct::reservation_time, srv_fatal_semaphore_wait_threshold, sync_cell_struct::state, sync_array_cell_print(), sync_array_get_nth_cell(), sync_primary_wait_array, and TRUE.

Referenced by srv_error_monitor_thread().

                              : TRUE if fatal semaphore wait threshold
                        was exceeded */
{
        sync_cell_t*    cell;
        ibool           old_val;
        ibool           noticed = FALSE;
        ulint           i;
        ulint           fatal_timeout = srv_fatal_semaphore_wait_threshold;
        ibool           fatal = FALSE;

        for (i = 0; i < sync_primary_wait_array->n_cells; i++) {

                cell = sync_array_get_nth_cell(sync_primary_wait_array, i);

                if ((cell->state != SC_FREE)
                        && difftime(time(NULL), cell->reservation_time) > 240) {
                        fputs("InnoDB: Warning: a long semaphore wait:\n",
                                stderr);
                        sync_array_cell_print(stderr, cell);
                        noticed = TRUE;
                }

                if ((cell->state != SC_FREE)
                        && difftime(time(NULL), cell->reservation_time)
                        > fatal_timeout) {
                        fatal = TRUE;
                }
        }

        if (noticed) {
                fprintf(stderr,
"InnoDB: ###### Starts InnoDB Monitor for 30 secs to print diagnostic info:\n");
                old_val = srv_print_innodb_monitor;

                /* If some crucial semaphore is reserved, then also the InnoDB
                Monitor can hang, and we do not get diagnostics. Since in
                many cases an InnoDB hang is caused by a pwrite() or a pread()
                call hanging inside the operating system, let us print right
                now the values of pending calls of these. */

                fprintf(stderr,
"InnoDB: Pending preads %lu, pwrites %lu\n", (ulong)os_file_n_pending_preads,
                                (ulong)os_file_n_pending_pwrites);

                srv_print_innodb_monitor = TRUE;
                os_event_set(srv_lock_timeout_thread_event);

                os_thread_sleep(30000000);

                srv_print_innodb_monitor = old_val;
                fprintf(stderr,
"InnoDB: ###### Diagnostic info printed to the standard error stream\n");
        }

        return(fatal);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void sync_array_reserve_cell	(	sync_array_t *	arr,
		void *	object,
		ulint	type,
		const char *	file,
		ulint	line,
		ulint *	index
	)

Definition at line 304 of file sync0arr.c.

References sync_cell_struct::event, sync_cell_struct::event_set, FALSE, sync_cell_struct::file, sync_cell_struct::line, sync_array_struct::n_cells, sync_array_struct::n_reserved, NULL, sync_cell_struct::old_wait_mutex, sync_cell_struct::old_wait_rw_lock, os_event_reset(), os_thread_get_curr_id(), sync_cell_struct::request_type, sync_array_struct::res_count, sync_cell_struct::reservation_time, sync_cell_struct::state, sync_array_enter(), sync_array_exit(), sync_array_get_nth_cell(), SYNC_MUTEX, sync_cell_struct::thread, ut_a, sync_cell_struct::wait_object, and sync_cell_struct::waiting.

Referenced by mutex_spin_wait(), rw_lock_s_lock_spin(), and rw_lock_x_lock_func().

                                     : 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 */
{
        sync_cell_t*    cell;
        ulint           i;

        ut_a(object);
        ut_a(index);

        sync_array_enter(arr);

        arr->res_count++;

        /* Reserve a new cell. */
        for (i = 0; i < arr->n_cells; i++) {
                cell = sync_array_get_nth_cell(arr, i);

                if (cell->state == SC_FREE) {

                        /* We do not check cell->event_set because it is
                        set outside the protection of the sync array mutex
                        and we had a bug regarding it, and since resetting
                        an event when it is not needed does no harm it is
                        safer always to do it. */

                        cell->event_set = FALSE;
                        os_event_reset(cell->event);

                        cell->state = SC_RESERVED;
                        cell->reservation_time = time(NULL);
                        cell->thread = os_thread_get_curr_id();

                        cell->wait_object = object;

                        if (type == SYNC_MUTEX) {
                                cell->old_wait_mutex = object;
                        } else {
                                cell->old_wait_rw_lock = object;
                        }

                        cell->request_type = type;
                        cell->waiting = FALSE;

                        cell->file = file;
                        cell->line = line;

                        arr->n_reserved++;

                        *index = i;

                        sync_array_exit(arr);

                        return;
                }
        }

        ut_error; /* No free cell found */

        return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void sync_array_signal_object	(	sync_array_t *	arr,
		void *	object
	)

Definition at line 848 of file sync0arr.c.

References count, sync_cell_struct::event, sync_cell_struct::event_set, free, malloc, memcpy, sync_array_struct::n_reserved, os_event_set(), sync_array_struct::sg_count, sync_cell_struct::state, sync_array_enter(), sync_array_exit(), sync_array_get_nth_cell(), TRUE, ut_a, and sync_cell_struct::wait_object.

Referenced by mutex_signal_object().

                                     : wait array */
        void*           object) /* in: wait object */
{
        sync_cell_t*    cell;
        ulint           count;
        ulint           i;
        ulint           res_count;

        /* We store the addresses of cells we need to signal and signal
        them only after we have released the sync array's mutex (for
        performance reasons). cell_count is the number of such cells, and
        cell_ptr points to the first one. If there are less than
        UT_ARR_SIZE(cells) of them, cell_ptr == &cells[0], otherwise
        cell_ptr points to malloc'd memory that we must free. */

        sync_cell_t*    cells[100];
        sync_cell_t**   cell_ptr = &cells[0];
        ulint           cell_count = 0;
        ulint           cell_max_count = UT_ARR_SIZE(cells);

        ut_a(100 == cell_max_count);

        sync_array_enter(arr);

        arr->sg_count++;

        i = 0;
        count = 0;

        /* We need to store this to a local variable because it is modified
        inside the loop */
        res_count = arr->n_reserved;

        while (count < res_count) {

                cell = sync_array_get_nth_cell(arr, i);

                if (cell->state == SC_RESERVED) {

                        count++;
                        if (cell->wait_object == object) {
                                cell->state = SC_WAKING_UP;

                                ut_a(arr->n_reserved > 0);
                                arr->n_reserved--;

                                if (cell_count == cell_max_count) {
                                        sync_cell_t** old_cell_ptr = cell_ptr;
                                        size_t old_size, new_size;

                                        old_size = cell_max_count *
                                                sizeof(sync_cell_t*);
                                        cell_max_count *= 2;
                                        new_size = cell_max_count *
                                                sizeof(sync_cell_t*);

                                        cell_ptr = malloc(new_size);
                                        ut_a(cell_ptr);
                                        memcpy(cell_ptr, old_cell_ptr,
                                                old_size);

                                        if (old_cell_ptr != &cells[0]) {
                                                free(old_cell_ptr);
                                        }
                                }

                                cell_ptr[cell_count] = cell;
                                cell_count++;
                        }
                }

                i++;
        }

        sync_array_exit(arr);

        for (i = 0; i < cell_count; i++) {
                cell = cell_ptr[i];

                cell->event_set = TRUE;
                os_event_set(cell->event);
        }

        if (cell_ptr != &cells[0]) {
                free(cell_ptr);
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void sync_array_validate

(

sync_array_t *

arr

)

Definition at line 276 of file sync0arr.c.

References count, sync_array_struct::n_cells, sync_cell_struct::state, sync_array_enter(), and sync_array_get_nth_cell().

Referenced by sync_array_free().

                                     : sync wait array */
{
        ulint           i;
        sync_cell_t*    cell;
        ulint           count           = 0;

        sync_array_enter(arr);

        for (i = 0; i < arr->n_cells; i++) {
                cell = sync_array_get_nth_cell(arr, i);

                if (cell->state == SC_RESERVED) {
                        count++;
                }
        }

        ut_a(count == arr->n_reserved);

        sync_array_exit(arr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void sync_array_wait_event	(	sync_array_t *	arr,
		ulint	index
	)

Definition at line 440 of file sync0arr.c.

References sync_cell_struct::event, os_event_wait(), os_thread_get_curr_id(), sync_cell_struct::state, sync_array_enter(), sync_array_exit(), sync_array_free_cell(), sync_array_get_nth_cell(), sync_cell_struct::thread, TRUE, ut_a, ut_ad, ut_error, sync_cell_struct::wait_object, and sync_cell_struct::waiting.

Referenced by mutex_spin_wait(), rw_lock_s_lock_spin(), and rw_lock_x_lock_func().

                                     : wait array */
        ulint           index)  /* in: index of the reserved cell */
{
        sync_cell_t*    cell;
        os_event_t      event;

        ut_a(arr);

        cell = sync_array_get_nth_cell(arr, index);

        ut_a((cell->state == SC_RESERVED) || (cell->state == SC_WAKING_UP));
        ut_a(cell->wait_object);
        ut_a(!cell->waiting);
        ut_ad(os_thread_get_curr_id() == cell->thread);

        event = cell->event;
        cell->waiting = TRUE;

#ifdef UNIV_SYNC_DEBUG

        /* We use simple enter to the mutex below, because if
        we cannot acquire it at once, mutex_enter would call
        recursively sync_array routines, leading to trouble.
        rw_lock_debug_mutex freezes the debug lists. */

        sync_array_enter(arr);
        rw_lock_debug_mutex_enter();

        if (TRUE == sync_array_detect_deadlock(arr, cell, cell, 0)) {

                fputs("########################################\n", stderr);
                ut_error;
        }

        rw_lock_debug_mutex_exit();
        sync_array_exit(arr);
#endif
        os_event_wait(event);

        sync_array_free_cell(arr, index);
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

• 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 MySQL
• Contact Us
• Legal
• Privacy Policy
• Job Opportunities
• Site Map

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