1
/******************************************************
2
Mutex, the basic synchronization primitive
6
Created 9/5/1995 Heikki Tuuri
7
*******************************************************/
13
#include "sync0types.h"
16
#include "os0thread.h"
20
#ifndef UNIV_HOTBACKUP
21
extern my_bool timed_mutexes;
22
#endif /* UNIV_HOTBACKUP */
24
/**********************************************************************
25
Initializes the synchronization data structures. */
30
/**********************************************************************
31
Frees the resources in synchronization data structures. */
36
/**********************************************************************
37
Creates, or rather, initializes a mutex object to a specified memory
38
location (which must be appropriately aligned). The mutex is initialized
39
in the reset state. Explicit freeing of the mutex with mutex_free is
40
necessary only if the memory block containing it is freed. */
43
# ifdef UNIV_SYNC_DEBUG
44
# define mutex_create(M, level) \
45
mutex_create_func((M), #M, (level), __FILE__, __LINE__)
47
# define mutex_create(M, level) \
48
mutex_create_func((M), #M, __FILE__, __LINE__)
51
# define mutex_create(M, level) \
52
mutex_create_func((M), __FILE__, __LINE__)
55
/**********************************************************************
56
Creates, or rather, initializes a mutex object in a specified memory
57
location (which must be appropriately aligned). The mutex is initialized
58
in the reset state. Explicit freeing of the mutex with mutex_free is
59
necessary only if the memory block containing it is freed. */
64
mutex_t* mutex, /* in: pointer to memory */
66
const char* cmutex_name, /* in: mutex name */
67
# ifdef UNIV_SYNC_DEBUG
68
ulint level, /* in: level */
69
# endif /* UNIV_SYNC_DEBUG */
70
#endif /* UNIV_DEBUG */
71
const char* cfile_name, /* in: file name where created */
72
ulint cline); /* in: file line where created */
73
/**********************************************************************
74
Calling this function is obligatory only if the memory buffer containing
75
the mutex is freed. Removes a mutex object from the mutex list. The mutex
76
is checked to be in the reset state. */
78
#undef mutex_free /* Fix for MacOS X */
82
mutex_t* mutex); /* in: mutex */
83
/******************************************************************
84
NOTE! The following macro should be used in mutex locking, not the
85
corresponding function. */
87
#define mutex_enter(M) mutex_enter_func((M), __FILE__, __LINE__)
88
/**********************************************************************
89
A noninlined function that reserves a mutex. In ha_innodb.cc we have disabled
90
inlining of InnoDB functions, and no inlined functions should be called from
91
there. That is why we need to duplicate the inlined function here. */
94
mutex_enter_noninline(
95
/*==================*/
96
mutex_t* mutex); /* in: mutex */
97
/******************************************************************
98
NOTE! The following macro should be used in mutex locking, not the
99
corresponding function. */
101
/* NOTE! currently same as mutex_enter! */
103
#define mutex_enter_fast(M) mutex_enter_func((M), __FILE__, __LINE__)
104
#define mutex_enter_fast_func mutex_enter_func;
105
/**********************************************************************
106
NOTE! Use the corresponding macro in the header file, not this function
107
directly. Locks a mutex for the current thread. If the mutex is reserved
108
the function spins a preset time (controlled by SYNC_SPIN_ROUNDS) waiting
109
for the mutex before suspending the thread. */
114
mutex_t* mutex, /* in: pointer to mutex */
115
const char* file_name, /* in: file name where locked */
116
ulint line); /* in: line where locked */
117
/******************************************************************
118
NOTE! The following macro should be used in mutex locking, not the
119
corresponding function. */
121
#define mutex_enter_nowait(M) \
122
mutex_enter_nowait_func((M), __FILE__, __LINE__)
123
/************************************************************************
124
NOTE! Use the corresponding macro in the header file, not this function
125
directly. Tries to lock the mutex for the current thread. If the lock is not
126
acquired immediately, returns with return value 1. */
129
mutex_enter_nowait_func(
130
/*====================*/
131
/* out: 0 if succeed, 1 if not */
132
mutex_t* mutex, /* in: pointer to mutex */
133
const char* file_name, /* in: file name where mutex
135
ulint line); /* in: line where requested */
136
/**********************************************************************
137
Unlocks a mutex owned by the current thread. */
142
mutex_t* mutex); /* in: pointer to mutex */
143
/**********************************************************************
147
mutex_exit_noninline(
148
/*=================*/
149
mutex_t* mutex); /* in: mutex */
150
/**********************************************************************
151
Returns TRUE if no mutex or rw-lock is currently locked.
152
Works only in the debug version. */
155
sync_all_freed(void);
157
/*#####################################################################
158
FUNCTION PROTOTYPES FOR DEBUGGING */
159
/***********************************************************************
160
Prints wait info of the sync system. */
163
sync_print_wait_info(
164
/*=================*/
165
FILE* file); /* in: file where to print */
166
/***********************************************************************
167
Prints info of the sync system. */
172
FILE* file); /* in: file where to print */
174
/**********************************************************************
175
Checks that the mutex has been initialized. */
180
const mutex_t* mutex);
181
/**********************************************************************
182
Checks that the current thread owns the mutex. Works only
183
in the debug version. */
188
/* out: TRUE if owns */
189
const mutex_t* mutex); /* in: mutex */
190
#endif /* UNIV_DEBUG */
191
#ifdef UNIV_SYNC_DEBUG
192
/**********************************************************************
193
Adds a latch and its level in the thread level array. Allocates the memory
194
for the array if called first time for this OS thread. Makes the checks
195
against other latch levels stored in the array for this thread. */
198
sync_thread_add_level(
199
/*==================*/
200
void* latch, /* in: pointer to a mutex or an rw-lock */
201
ulint level); /* in: level in the latching order; if
202
SYNC_LEVEL_VARYING, nothing is done */
203
/**********************************************************************
204
Removes a latch from the thread level array if it is found there. */
207
sync_thread_reset_level(
208
/*====================*/
209
/* out: TRUE if found from the array; it is no error
210
if the latch is not found, as we presently are not
211
able to determine the level for every latch
212
reservation the program does */
213
void* latch); /* in: pointer to a mutex or an rw-lock */
214
/**********************************************************************
215
Checks that the level array for the current thread is empty. */
218
sync_thread_levels_empty(void);
219
/*==========================*/
220
/* out: TRUE if empty */
221
/**********************************************************************
222
Checks that the level array for the current thread is empty. */
225
sync_thread_levels_empty_gen(
226
/*=========================*/
227
/* out: TRUE if empty except the
228
exceptions specified below */
229
ibool dict_mutex_allowed); /* in: TRUE if dictionary mutex is
230
allowed to be owned by the thread,
231
also purge_is_running mutex is
233
/**********************************************************************
234
Gets the debug information for a reserved mutex. */
237
mutex_get_debug_info(
238
/*=================*/
239
mutex_t* mutex, /* in: mutex */
240
const char** file_name, /* out: file where requested */
241
ulint* line, /* out: line where requested */
242
os_thread_id_t* thread_id); /* out: id of the thread which owns
244
/**********************************************************************
245
Counts currently reserved mutexes. Works only in the debug version. */
248
mutex_n_reserved(void);
249
/*==================*/
250
#endif /* UNIV_SYNC_DEBUG */
251
/**********************************************************************
252
NOT to be used outside this module except in debugging! Gets the value
258
const mutex_t* mutex); /* in: mutex */
259
#ifdef UNIV_SYNC_DEBUG
260
/**********************************************************************
261
NOT to be used outside this module except in debugging! Gets the waiters
267
/* out: value to set */
268
const mutex_t* mutex); /* in: mutex */
269
#endif /* UNIV_SYNC_DEBUG */
272
LATCHING ORDER WITHIN THE DATABASE
273
==================================
275
The mutex or latch in the central memory object, for instance, a rollback
276
segment object, must be acquired before acquiring the latch or latches to
277
the corresponding file data structure. In the latching order below, these
278
file page object latches are placed immediately below the corresponding
279
central memory object latch or mutex.
281
Synchronization object Notes
282
---------------------- -----
284
Dictionary mutex If we have a pointer to a dictionary
285
| object, e.g., a table, it can be
286
| accessed without reserving the
287
| dictionary mutex. We must have a
288
| reservation, a memoryfix, to the
289
| appropriate table object in this case,
290
| and the table must be explicitly
296
Secondary index tree latch The tree latch protects also all
297
| the B-tree non-leaf pages. These
298
V can be read with the page only
299
Secondary index non-leaf bufferfixed to save CPU time,
300
| no s-latch is needed on the page.
301
| Modification of a page requires an
302
| x-latch on the page, however. If a
303
| thread owns an x-latch to the tree,
304
| it is allowed to latch non-leaf pages
305
| even after it has acquired the fsp
308
Secondary index leaf The latch on the secondary index leaf
309
| can be kept while accessing the
310
| clustered index, to save CPU time.
312
Clustered index tree latch To increase concurrency, the tree
313
| latch is usually released when the
314
| leaf page latch has been acquired.
316
Clustered index non-leaf
322
Transaction system header
325
Transaction undo mutex The undo log entry must be written
326
| before any index page is modified.
327
| Transaction undo mutex is for the undo
328
| logs the analogue of the tree latch
329
| for a B-tree. If a thread has the
330
| trx undo mutex reserved, it is allowed
331
| to latch the undo log pages in any
332
| order, and also after it has acquired
335
Rollback segment mutex The rollback segment mutex must be
336
| reserved, if, e.g., a new page must
337
| be added to an undo log. The rollback
338
| segment and the undo logs in its
339
| history list can be seen as an
340
| analogue of a B-tree, and the latches
341
| reserved similarly, using a version of
342
| lock-coupling. If an undo log must be
343
| extended by a page when inserting an
344
| undo log record, this corresponds to
345
| a pessimistic insert in a B-tree.
347
Rollback segment header
353
Undo log pages If a thread owns the trx undo mutex,
354
| or for a log in the history list, the
355
| rseg mutex, it is allowed to latch
356
| undo log pages in any order, and even
357
| after it has acquired the fsp latch.
358
| If a thread does not have the
359
| appropriate mutex, it is allowed to
360
| latch only a single undo log page in
361
| a mini-transaction.
363
File space management latch If a mini-transaction must allocate
364
| several file pages, it can do that,
365
| because it keeps the x-latch to the
366
| file space management in its memo.
371
Kernel mutex If a kernel operation needs a file
372
| page allocation, it must reserve the
373
| fsp x-latch before acquiring the kernel
389
/* Latching order levels */
391
/* User transaction locks are higher than any of the latch levels below:
392
no latches are allowed when a thread goes to wait for a normal table
394
#define SYNC_USER_TRX_LOCK 9999
395
#define SYNC_NO_ORDER_CHECK 3000 /* this can be used to suppress
396
latching order checking */
397
#define SYNC_LEVEL_VARYING 2000 /* Level is varying. Only used with
398
buffer pool page locks, which do not
399
have a fixed level, but instead have
400
their level set after the page is
402
ibuf_bitmap_get_map_page(). */
403
#define SYNC_DICT_OPERATION 1001 /* table create, drop, etc. reserve
404
this in X-mode, implicit or backround
405
operations purge, rollback, foreign
406
key checks reserve this in S-mode */
407
#define SYNC_DICT 1000
408
#define SYNC_DICT_AUTOINC_MUTEX 999
409
#define SYNC_DICT_HEADER 995
410
#define SYNC_IBUF_HEADER 914
411
#define SYNC_IBUF_PESS_INSERT_MUTEX 912
412
#define SYNC_IBUF_MUTEX 910 /* ibuf mutex is really below
413
SYNC_FSP_PAGE: we assign a value this
414
high only to make the program to pass
416
/*-------------------------------*/
417
#define SYNC_INDEX_TREE 900
418
#define SYNC_TREE_NODE_NEW 892
419
#define SYNC_TREE_NODE_FROM_HASH 891
420
#define SYNC_TREE_NODE 890
421
#define SYNC_PURGE_SYS 810
422
#define SYNC_PURGE_LATCH 800
423
#define SYNC_TRX_UNDO 700
424
#define SYNC_RSEG 600
425
#define SYNC_RSEG_HEADER_NEW 591
426
#define SYNC_RSEG_HEADER 590
427
#define SYNC_TRX_UNDO_PAGE 570
428
#define SYNC_EXTERN_STORAGE 500
430
#define SYNC_FSP_PAGE 395
431
/*------------------------------------- Insert buffer headers */
432
/*------------------------------------- ibuf_mutex */
433
/*------------------------------------- Insert buffer tree */
434
#define SYNC_IBUF_BITMAP_MUTEX 351
435
#define SYNC_IBUF_BITMAP 350
436
/*------------------------------------- MySQL query cache mutex */
437
/*------------------------------------- MySQL binlog mutex */
438
/*-------------------------------*/
439
#define SYNC_KERNEL 300
440
#define SYNC_REC_LOCK 299
441
#define SYNC_TRX_LOCK_HEAP 298
442
#define SYNC_TRX_SYS_HEADER 290
444
#define SYNC_RECV 168
445
#define SYNC_WORK_QUEUE 161
446
#define SYNC_SEARCH_SYS 160 /* NOTE that if we have a memory
447
heap that can be extended to the
448
buffer pool, its logical level is
449
SYNC_SEARCH_SYS, as memory allocation
450
can call routines there! Otherwise
451
the level is SYNC_MEM_HASH. */
452
#define SYNC_BUF_POOL 150
453
#define SYNC_BUF_BLOCK 149
454
#define SYNC_DOUBLEWRITE 140
455
#define SYNC_ANY_LATCH 135
456
#define SYNC_THR_LOCAL 133
457
#define SYNC_MEM_HASH 131
458
#define SYNC_MEM_POOL 130
460
/* Codes used to designate lock operations */
461
#define RW_LOCK_NOT_LOCKED 350
462
#define RW_LOCK_EX 351
463
#define RW_LOCK_EXCLUSIVE 351
464
#define RW_LOCK_SHARED 352
465
#define RW_LOCK_WAIT_EX 353
466
#define SYNC_MUTEX 354
468
/* NOTE! The structure appears here only for the compiler to know its size.
469
Do not use its fields directly! The structure used in the spin lock
470
implementation of a mutual exclusion semaphore. */
472
struct mutex_struct {
473
ulint lock_word; /* This ulint is the target of the atomic
474
test-and-set instruction in Win32 */
475
#if !defined(_WIN32) || !defined(UNIV_CAN_USE_X86_ASSEMBLER)
477
os_fast_mutex; /* In other systems we use this OS mutex
478
in place of lock_word */
480
ulint waiters; /* This ulint is set to 1 if there are (or
481
may be) threads waiting in the global wait
482
array for this mutex to be released.
483
Otherwise, this is 0. */
484
UT_LIST_NODE_T(mutex_t) list; /* All allocated mutexes are put into
485
a list. Pointers to the next and prev. */
486
#ifdef UNIV_SYNC_DEBUG
487
const char* file_name; /* File where the mutex was locked */
488
ulint line; /* Line where the mutex was locked */
489
ulint level; /* Level in the global latching order */
490
#endif /* UNIV_SYNC_DEBUG */
491
const char* cfile_name;/* File name where mutex created */
492
ulint cline; /* Line where created */
494
os_thread_id_t thread_id; /* The thread id of the thread
495
which locked the mutex. */
497
# define MUTEX_MAGIC_N (ulint)979585
498
#endif /* UNIV_DEBUG */
499
#ifndef UNIV_HOTBACKUP
500
ulong count_os_wait; /* count of os_wait */
502
ulong count_using; /* count of times mutex used */
503
ulong count_spin_loop; /* count of spin loops */
504
ulong count_spin_rounds; /* count of spin rounds */
505
ulong count_os_yield; /* count of os_wait */
506
ulonglong lspent_time; /* mutex os_wait timer msec */
507
ulonglong lmax_spent_time; /* mutex os_wait timer msec */
508
const char* cmutex_name;/* mutex name */
509
ulint mutex_type;/* 0 - usual mutex 1 - rw_lock mutex */
510
# endif /* UNIV_DEBUG */
511
#endif /* !UNIV_HOTBACKUP */
514
/* The global array of wait cells for implementation of the databases own
515
mutexes and read-write locks. Appears here for debugging purposes only! */
517
extern sync_array_t* sync_primary_wait_array;
519
/* Constant determining how long spin wait is continued before suspending
520
the thread. A value 600 rounds on a 1995 100 MHz Pentium seems to correspond
521
to 20 microseconds. */
523
#define SYNC_SPIN_ROUNDS srv_n_spin_wait_rounds
525
/* The number of system calls made in this module. Intended for performance
528
extern ulint mutex_system_call_count;
529
extern ulint mutex_exit_count;
531
#ifdef UNIV_SYNC_DEBUG
532
/* Latching order checks start when this is set TRUE */
533
extern ibool sync_order_checks_on;
534
#endif /* UNIV_SYNC_DEBUG */
536
/* This variable is set to TRUE when sync_init is called */
537
extern ibool sync_initialized;
539
/* Global list of database mutexes (not OS mutexes) created. */
540
typedef UT_LIST_BASE_NODE_T(mutex_t) ut_list_base_node_t;
541
extern ut_list_base_node_t mutex_list;
543
/* Mutex protecting the mutex_list variable */
544
extern mutex_t mutex_list_mutex;
548
#include "sync0sync.ic"
added
removed
storage/innobase/include/sync0sync.h
