← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Monty Taylor
  • Date: 2010-10-11 06:27:10 UTC
  • mto: (1843.1.1 build)
  • mto: This revision was merged to the branch mainline in revision 1844.
  • Revision ID: mordred@inaugust.com-20101011062710-hw270dnron7sojwe
Removed libdrizzle doxygen. Put in function stubs in sphinx. Someone can
quite easily and mechanically go in and transfer the descriptions in -
especially if they decide on a proper way to describe arguments.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/sync/sync0sync.c
39
39
#include "buf0buf.h"
40
40
#include "srv0srv.h"
41
41
#include "buf0types.h"
42
 
#include "os0sync.h" /* for HAVE_ATOMIC_BUILTINS */
43
42
 
44
43
/*
45
44
        REASONS FOR IMPLEMENTING THE SPIN LOCK MUTEX
850
849
/*=================*/
851
850
        sync_level_t*   arr,    /*!< in: pointer to level array for an OS
852
851
                                thread */
853
 
        ulint           limit,  /*!< in: level limit */
854
 
        ulint           warn)   /*!< in: TRUE=display a diagnostic message */
 
852
        ulint           limit)  /*!< in: level limit */
855
853
{
856
854
        sync_level_t*   slot;
857
855
        rw_lock_t*      lock;
865
863
                if (slot->latch != NULL) {
866
864
                        if (slot->level <= limit) {
867
865
 
868
 
                                if (!warn) {
869
 
 
870
 
                                        return(FALSE);
871
 
                                }
872
 
 
873
866
                                lock = slot->latch;
874
867
                                mutex = slot->latch;
875
868
 
1107
1100
        case SYNC_DICT_HEADER:
1108
1101
        case SYNC_TRX_I_S_RWLOCK:
1109
1102
        case SYNC_TRX_I_S_LAST_READ:
1110
 
                if (!sync_thread_levels_g(array, level, TRUE)) {
 
1103
                if (!sync_thread_levels_g(array, level)) {
1111
1104
                        fprintf(stderr,
1112
1105
                                "InnoDB: sync_thread_levels_g(array, %lu)"
1113
1106
                                " does not hold!\n", level);
1118
1111
                /* Either the thread must own the buffer pool mutex
1119
1112
                (buf_pool_mutex), or it is allowed to latch only ONE
1120
1113
                buffer block (block->mutex or buf_pool_zip_mutex). */
1121
 
                if (!sync_thread_levels_g(array, level, FALSE)) {
1122
 
                        ut_a(sync_thread_levels_g(array, level - 1, TRUE));
 
1114
                if (!sync_thread_levels_g(array, level)) {
 
1115
                        ut_a(sync_thread_levels_g(array, level - 1));
1123
1116
                        ut_a(sync_thread_levels_contain(array, SYNC_BUF_POOL));
1124
1117
                }
1125
1118
                break;
1126
1119
        case 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
 
                }
 
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));
1133
1123
                break;
1134
1124
        case SYNC_IBUF_BITMAP:
1135
1125
                /* Either the thread must own the master mutex to all
1136
1126
                the bitmap pages, or it is allowed to latch only ONE
1137
1127
                bitmap page. */
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
 
                }
 
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));
1146
1131
                break;
1147
1132
        case SYNC_FSP_PAGE:
1148
1133
                ut_a(sync_thread_levels_contain(array, SYNC_FSP));
1149
1134
                break;
1150
1135
        case SYNC_FSP:
1151
1136
                ut_a(sync_thread_levels_contain(array, SYNC_FSP)
1152
 
                     || sync_thread_levels_g(array, SYNC_FSP, TRUE));
 
1137
                     || sync_thread_levels_g(array, SYNC_FSP));
1153
1138
                break;
1154
1139
        case SYNC_TRX_UNDO_PAGE:
1155
1140
                ut_a(sync_thread_levels_contain(array, SYNC_TRX_UNDO)
1156
1141
                     || sync_thread_levels_contain(array, SYNC_RSEG)
1157
1142
                     || sync_thread_levels_contain(array, SYNC_PURGE_SYS)
1158
 
                     || sync_thread_levels_g(array, SYNC_TRX_UNDO_PAGE, TRUE));
 
1143
                     || sync_thread_levels_g(array, SYNC_TRX_UNDO_PAGE));
1159
1144
                break;
1160
1145
        case SYNC_RSEG_HEADER:
1161
1146
                ut_a(sync_thread_levels_contain(array, SYNC_RSEG));
1167
1152
        case SYNC_TREE_NODE:
1168
1153
                ut_a(sync_thread_levels_contain(array, SYNC_INDEX_TREE)
1169
1154
                     || sync_thread_levels_contain(array, SYNC_DICT_OPERATION)
1170
 
                     || sync_thread_levels_g(array, SYNC_TREE_NODE - 1, TRUE));
 
1155
                     || sync_thread_levels_g(array, SYNC_TREE_NODE - 1));
1171
1156
                break;
1172
1157
        case SYNC_TREE_NODE_NEW:
1173
1158
                ut_a(sync_thread_levels_contain(array, SYNC_FSP_PAGE)
1174
1159
                     || sync_thread_levels_contain(array, SYNC_IBUF_MUTEX));
1175
1160
                break;
1176
1161
        case SYNC_INDEX_TREE:
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
 
                }
 
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));
1185
1166
                break;
1186
1167
        case SYNC_IBUF_MUTEX:
1187
 
                ut_a(sync_thread_levels_g(array, SYNC_FSP_PAGE - 1, TRUE));
 
1168
                ut_a(sync_thread_levels_g(array, SYNC_FSP_PAGE - 1));
1188
1169
                break;
1189
1170
        case SYNC_IBUF_PESS_INSERT_MUTEX:
1190
 
                ut_a(sync_thread_levels_g(array, SYNC_FSP - 1, TRUE));
1191
 
                ut_a(!sync_thread_levels_contain(array, SYNC_IBUF_MUTEX));
 
1171
                ut_a(sync_thread_levels_g(array, SYNC_FSP - 1)
 
1172
                     && !sync_thread_levels_contain(array, SYNC_IBUF_MUTEX));
1192
1173
                break;
1193
1174
        case SYNC_IBUF_HEADER:
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));
 
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));
1198
1179
                break;
1199
1180
        case SYNC_DICT:
1200
1181
#ifdef UNIV_DEBUG
1201
1182
                ut_a(buf_debug_prints
1202
 
                     || sync_thread_levels_g(array, SYNC_DICT, TRUE));
 
1183
                     || sync_thread_levels_g(array, SYNC_DICT));
1203
1184
#else /* UNIV_DEBUG */
1204
 
                ut_a(sync_thread_levels_g(array, SYNC_DICT, TRUE));
 
1185
                ut_a(sync_thread_levels_g(array, SYNC_DICT));
1205
1186
#endif /* UNIV_DEBUG */
1206
1187
                break;
1207
1188
        default: