← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/sync/sync0sync.c

  • Committer: Stewart Smith
  • Date: 2010-11-03 03:27:09 UTC
  • mto: (1902.1.1 build) (1910.1.2 build)
  • mto: This revision was merged to the branch mainline in revision 1903.
  • Revision ID: stewart@flamingspork.com-20101103032709-oyvfrc6eb8fzj0mr
fix docs warning: docs/unlock.rst:2: (WARNING/2) Title underline too short.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/sync/sync0sync.c
18
18
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
19
19
 
20
20
You should have received a copy of the GNU General Public License along with
21
 
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
22
 
Place, Suite 330, Boston, MA 02111-1307 USA
 
21
this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
 
22
St, Fifth Floor, Boston, MA 02110-1301 USA
23
23
 
24
24
*****************************************************************************/
25
25
 
39
39
#include "buf0buf.h"
40
40
#include "srv0srv.h"
41
41
#include "buf0types.h"
 
42
#include "os0sync.h" /* for HAVE_ATOMIC_BUILTINS */
42
43
 
43
44
/*
44
45
        REASONS FOR IMPLEMENTING THE SPIN LOCK MUTEX
849
850
/*=================*/
850
851
        sync_level_t*   arr,    /*!< in: pointer to level array for an OS
851
852
                                thread */
852
 
        ulint           limit)  /*!< in: level limit */
 
853
        ulint           limit,  /*!< in: level limit */
 
854
        ulint           warn)   /*!< in: TRUE=display a diagnostic message */
853
855
{
854
856
        sync_level_t*   slot;
855
857
        rw_lock_t*      lock;
863
865
                if (slot->latch != NULL) {
864
866
                        if (slot->level <= limit) {
865
867
 
 
868
                                if (!warn) {
 
869
 
 
870
                                        return(FALSE);
 
871
                                }
 
872
 
866
873
                                lock = slot->latch;
867
874
                                mutex = slot->latch;
868
875
 
1100
1107
        case SYNC_DICT_HEADER:
1101
1108
        case SYNC_TRX_I_S_RWLOCK:
1102
1109
        case SYNC_TRX_I_S_LAST_READ:
1103
 
                if (!sync_thread_levels_g(array, level)) {
 
1110
                if (!sync_thread_levels_g(array, level, TRUE)) {
1104
1111
                        fprintf(stderr,
1105
1112
                                "InnoDB: sync_thread_levels_g(array, %lu)"
1106
1113
                                " does not hold!\n", level);
1111
1118
                /* Either the thread must own the buffer pool mutex
1112
1119
                (buf_pool_mutex), or it is allowed to latch only ONE
1113
1120
                buffer block (block->mutex or buf_pool_zip_mutex). */
1114
 
                if (!sync_thread_levels_g(array, level)) {
1115
 
                        ut_a(sync_thread_levels_g(array, level - 1));
 
1121
                if (!sync_thread_levels_g(array, level, FALSE)) {
 
1122
                        ut_a(sync_thread_levels_g(array, level - 1, TRUE));
1116
1123
                        ut_a(sync_thread_levels_contain(array, SYNC_BUF_POOL));
1117
1124
                }
1118
1125
                break;
1119
1126
        case SYNC_REC_LOCK:
1120
 
                ut_a((sync_thread_levels_contain(array, SYNC_KERNEL)
1121
 
                      && sync_thread_levels_g(array, SYNC_REC_LOCK - 1))
1122
 
                     || sync_thread_levels_g(array, SYNC_REC_LOCK));
 
1127
                if (sync_thread_levels_contain(array, SYNC_KERNEL)) {
 
1128
                        ut_a(sync_thread_levels_g(array, SYNC_REC_LOCK - 1,
 
1129
                                                  TRUE));
 
1130
                } else {
 
1131
                        ut_a(sync_thread_levels_g(array, SYNC_REC_LOCK, TRUE));
 
1132
                }
1123
1133
                break;
1124
1134
        case SYNC_IBUF_BITMAP:
1125
1135
                /* Either the thread must own the master mutex to all
1126
1136
                the bitmap pages, or it is allowed to latch only ONE
1127
1137
                bitmap page. */
1128
 
                ut_a((sync_thread_levels_contain(array, SYNC_IBUF_BITMAP_MUTEX)
1129
 
                      && sync_thread_levels_g(array, SYNC_IBUF_BITMAP - 1))
1130
 
                     || sync_thread_levels_g(array, SYNC_IBUF_BITMAP));
 
1138
                if (sync_thread_levels_contain(array,
 
1139
                                               SYNC_IBUF_BITMAP_MUTEX)) {
 
1140
                        ut_a(sync_thread_levels_g(array, SYNC_IBUF_BITMAP - 1,
 
1141
                                                  TRUE));
 
1142
                } else {
 
1143
                        ut_a(sync_thread_levels_g(array, SYNC_IBUF_BITMAP,
 
1144
                                                  TRUE));
 
1145
                }
1131
1146
                break;
1132
1147
        case SYNC_FSP_PAGE:
1133
1148
                ut_a(sync_thread_levels_contain(array, SYNC_FSP));
1134
1149
                break;
1135
1150
        case SYNC_FSP:
1136
1151
                ut_a(sync_thread_levels_contain(array, SYNC_FSP)
1137
 
                     || sync_thread_levels_g(array, SYNC_FSP));
 
1152
                     || sync_thread_levels_g(array, SYNC_FSP, TRUE));
1138
1153
                break;
1139
1154
        case SYNC_TRX_UNDO_PAGE:
1140
1155
                ut_a(sync_thread_levels_contain(array, SYNC_TRX_UNDO)
1141
1156
                     || sync_thread_levels_contain(array, SYNC_RSEG)
1142
1157
                     || sync_thread_levels_contain(array, SYNC_PURGE_SYS)
1143
 
                     || sync_thread_levels_g(array, SYNC_TRX_UNDO_PAGE));
 
1158
                     || sync_thread_levels_g(array, SYNC_TRX_UNDO_PAGE, TRUE));
1144
1159
                break;
1145
1160
        case SYNC_RSEG_HEADER:
1146
1161
                ut_a(sync_thread_levels_contain(array, SYNC_RSEG));
1152
1167
        case SYNC_TREE_NODE:
1153
1168
                ut_a(sync_thread_levels_contain(array, SYNC_INDEX_TREE)
1154
1169
                     || sync_thread_levels_contain(array, SYNC_DICT_OPERATION)
1155
 
                     || sync_thread_levels_g(array, SYNC_TREE_NODE - 1));
 
1170
                     || sync_thread_levels_g(array, SYNC_TREE_NODE - 1, TRUE));
1156
1171
                break;
1157
1172
        case SYNC_TREE_NODE_NEW:
1158
1173
                ut_a(sync_thread_levels_contain(array, SYNC_FSP_PAGE)
1159
1174
                     || sync_thread_levels_contain(array, SYNC_IBUF_MUTEX));
1160
1175
                break;
1161
1176
        case SYNC_INDEX_TREE:
1162
 
                ut_a((sync_thread_levels_contain(array, SYNC_IBUF_MUTEX)
1163
 
                      && sync_thread_levels_contain(array, SYNC_FSP)
1164
 
                      && sync_thread_levels_g(array, SYNC_FSP_PAGE - 1))
1165
 
                     || sync_thread_levels_g(array, SYNC_TREE_NODE - 1));
 
1177
                if (sync_thread_levels_contain(array, SYNC_IBUF_MUTEX)
 
1178
                    && sync_thread_levels_contain(array, SYNC_FSP)) {
 
1179
                        ut_a(sync_thread_levels_g(array, SYNC_FSP_PAGE - 1,
 
1180
                                                  TRUE));
 
1181
                } else {
 
1182
                        ut_a(sync_thread_levels_g(array, SYNC_TREE_NODE - 1,
 
1183
                                                  TRUE));
 
1184
                }
1166
1185
                break;
1167
1186
        case SYNC_IBUF_MUTEX:
1168
 
                ut_a(sync_thread_levels_g(array, SYNC_FSP_PAGE - 1));
 
1187
                ut_a(sync_thread_levels_g(array, SYNC_FSP_PAGE - 1, TRUE));
1169
1188
                break;
1170
1189
        case SYNC_IBUF_PESS_INSERT_MUTEX:
1171
 
                ut_a(sync_thread_levels_g(array, SYNC_FSP - 1)
1172
 
                     && !sync_thread_levels_contain(array, SYNC_IBUF_MUTEX));
 
1190
                ut_a(sync_thread_levels_g(array, SYNC_FSP - 1, TRUE));
 
1191
                ut_a(!sync_thread_levels_contain(array, SYNC_IBUF_MUTEX));
1173
1192
                break;
1174
1193
        case SYNC_IBUF_HEADER:
1175
 
                ut_a(sync_thread_levels_g(array, SYNC_FSP - 1)
1176
 
                     && !sync_thread_levels_contain(array, SYNC_IBUF_MUTEX)
1177
 
                     && !sync_thread_levels_contain(
1178
 
                             array, SYNC_IBUF_PESS_INSERT_MUTEX));
 
1194
                ut_a(sync_thread_levels_g(array, SYNC_FSP - 1, TRUE));
 
1195
                ut_a(!sync_thread_levels_contain(array, SYNC_IBUF_MUTEX));
 
1196
                ut_a(!sync_thread_levels_contain(array,
 
1197
                                                 SYNC_IBUF_PESS_INSERT_MUTEX));
1179
1198
                break;
1180
1199
        case SYNC_DICT:
1181
1200
#ifdef UNIV_DEBUG
1182
1201
                ut_a(buf_debug_prints
1183
 
                     || sync_thread_levels_g(array, SYNC_DICT));
 
1202
                     || sync_thread_levels_g(array, SYNC_DICT, TRUE));
1184
1203
#else /* UNIV_DEBUG */
1185
 
                ut_a(sync_thread_levels_g(array, SYNC_DICT));
 
1204
                ut_a(sync_thread_levels_g(array, SYNC_DICT, TRUE));
1186
1205
#endif /* UNIV_DEBUG */
1187
1206
                break;
1188
1207
        default:
1358
1377
        mutex_free(&mutex_list_mutex);
1359
1378
#ifdef UNIV_SYNC_DEBUG
1360
1379
        mutex_free(&sync_thread_mutex);
 
1380
 
 
1381
        /* Switch latching order checks on in sync0sync.c */
 
1382
        sync_order_checks_on = FALSE;
1361
1383
#endif /* UNIV_SYNC_DEBUG */
 
1384
 
 
1385
        sync_initialized = FALSE;       
1362
1386
}
1363
1387
 
1364
1388
/*******************************************************************//**