← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/mf_keycache.c

Merged in changes. 
Edited a the comment test case so deal with our version bump.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/mf_keycache.c
101
101
  I/O finished.
102
102
*/
103
103
 
104
 
#include "config.h"
105
 
#include "drizzled/my_error.h"
106
 
#include "drizzled/internal/my_sys.h"
107
 
#include "keycache.h"
108
 
#include "drizzled/internal/m_string.h"
109
 
#include "drizzled/internal/my_bit.h"
 
104
#include "mysys_priv.h"
 
105
#include "mysys_err.h"
 
106
#include <keycache.h>
 
107
#include "my_static.h"
 
108
#include <m_string.h>
 
109
#include <my_bit.h>
110
110
#include <errno.h>
111
111
#include <stdarg.h>
112
112
 
113
 
static void change_key_cache_param(KEY_CACHE *keycache, uint32_t division_limit,
114
 
                            uint32_t age_threshold);
115
 
 
116
113
/*
117
114
  Some compilation flags have been added specifically for this module
118
115
  to control the following:
133
130
    situation, which theoretically should not happen;
134
131
    to set timeout equal to <T> seconds add
135
132
      #define KEYCACHE_TIMEOUT <T>
 
133
  - to enable the module traps and to send debug information from
 
134
    key cache module to a special debug log add:
 
135
      #define KEYCACHE_DEBUG
 
136
    the name of this debug log file <LOG NAME> can be set through:
 
137
      #define KEYCACHE_DEBUG_LOG  <LOG NAME>
 
138
    if the name is not defined, it's set by default;
 
139
    if the KEYCACHE_DEBUG flag is not set up and we are in a debug
 
140
    mode, i.e. when ! defined(DBUG_OFF), the debug information from the
 
141
    module is sent to the regular debug log.
136
142
 
137
143
  Example of the settings:
138
144
    #define SERIALIZED_READ_FROM_CACHE
139
145
    #define MAX_THREADS   100
140
146
    #define KEYCACHE_TIMEOUT  1
 
147
    #define KEYCACHE_DEBUG
 
148
    #define KEYCACHE_DEBUG_LOG  "my_key_cache_debug.log"
141
149
*/
142
150
 
143
151
#define STRUCT_PTR(TYPE, MEMBER, a)                                           \
146
154
/* types of condition variables */
147
155
#define  COND_FOR_REQUESTED 0
148
156
#define  COND_FOR_SAVED     1
 
157
#define  COND_FOR_READERS   2
149
158
 
150
159
typedef pthread_cond_t KEYCACHE_CONDVAR;
151
160
 
161
170
{
162
171
  struct st_hash_link *next, **prev; /* to connect links in the same bucket  */
163
172
  struct st_block_link *block;       /* reference to the block for the page: */
164
 
  int file;                         /* from such a file                     */
 
173
  File file;                         /* from such a file                     */
165
174
  my_off_t diskpos;                  /* with such an offset                  */
166
 
  uint32_t requests;                     /* number of requests for the page      */
 
175
  uint requests;                     /* number of requests for the page      */
167
176
};
168
177
 
169
178
/* simple states of a block */
195
204
    *next_changed, **prev_changed; /* for lists of file dirty/clean blocks   */
196
205
  struct st_hash_link *hash_link; /* backward ptr to referring hash_link     */
197
206
  KEYCACHE_WQUEUE wqueue[2]; /* queues on waiting requests for new/old pages */
198
 
  uint32_t requests;          /* number of requests for the block                */
199
 
  unsigned char *buffer;           /* buffer for the block page                       */
200
 
  uint32_t offset;            /* beginning of modified data in the buffer        */
201
 
  uint32_t length;            /* end of data in the buffer                       */
202
 
  uint32_t status;            /* state of the block                              */
 
207
  uint requests;          /* number of requests for the block                */
 
208
  uchar *buffer;           /* buffer for the block page                       */
 
209
  uint offset;            /* beginning of modified data in the buffer        */
 
210
  uint length;            /* end of data in the buffer                       */
 
211
  uint status;            /* state of the block                              */
203
212
  enum BLOCK_TEMPERATURE temperature; /* block temperature: cold, warm, hot */
204
 
  uint32_t hits_left;         /* number of hits left until promotion             */
205
 
  uint64_t last_hit_time; /* timestamp of the last hit                      */
 
213
  uint hits_left;         /* number of hits left until promotion             */
 
214
  ulonglong last_hit_time; /* timestamp of the last hit                      */
206
215
  KEYCACHE_CONDVAR *condvar; /* condition variable for 'no readers' event    */
207
216
};
208
217
 
212
221
#define FLUSH_CACHE         2000            /* sort this many blocks at once */
213
222
 
214
223
static int flush_all_key_blocks(KEY_CACHE *keycache);
 
224
#ifdef THREAD
215
225
static void wait_on_queue(KEYCACHE_WQUEUE *wqueue,
216
226
                          pthread_mutex_t *mutex);
217
227
static void release_whole_queue(KEYCACHE_WQUEUE *wqueue);
 
228
#else
 
229
#define wait_on_queue(wqueue, mutex)    do {} while (0)
 
230
#define release_whole_queue(wqueue)     do {} while (0)
 
231
#endif
218
232
static void free_block(KEY_CACHE *keycache, BLOCK_LINK *block);
 
233
#if !defined(DBUG_OFF)
 
234
static void test_key_cache(KEY_CACHE *keycache,
 
235
                           const char *where, my_bool lock);
 
236
#endif
219
237
 
220
238
#define KEYCACHE_HASH(f, pos)                                                 \
221
 
(((uint32_t) ((pos) / keycache->key_cache_block_size) +                          \
222
 
                                     (uint32_t) (f)) & (keycache->hash_entries-1))
 
239
(((ulong) ((pos) / keycache->key_cache_block_size) +                          \
 
240
                                     (ulong) (f)) & (keycache->hash_entries-1))
223
241
#define FILE_HASH(f)                 ((uint) (f) & (CHANGED_BLOCKS_HASH-1))
224
242
 
225
 
 
226
 
#ifdef KEYCACHE_TIMEOUT
 
243
#define DEFAULT_KEYCACHE_DEBUG_LOG  "keycache_debug.log"
 
244
 
 
245
#if defined(KEYCACHE_DEBUG) && ! defined(KEYCACHE_DEBUG_LOG)
 
246
#define KEYCACHE_DEBUG_LOG  DEFAULT_KEYCACHE_DEBUG_LOG
 
247
#endif
 
248
 
 
249
#if defined(KEYCACHE_DEBUG_LOG)
 
250
static FILE *keycache_debug_log=NULL;
 
251
static void keycache_debug_print _VARARGS((const char *fmt,...));
 
252
#define KEYCACHE_DEBUG_OPEN                                                   \
 
253
          if (!keycache_debug_log)                                            \
 
254
          {                                                                   \
 
255
            keycache_debug_log= fopen(KEYCACHE_DEBUG_LOG, "w");               \
 
256
            (void) setvbuf(keycache_debug_log, NULL, _IOLBF, BUFSIZ);         \
 
257
          }
 
258
 
 
259
#define KEYCACHE_DEBUG_CLOSE                                                  \
 
260
          if (keycache_debug_log)                                             \
 
261
          {                                                                   \
 
262
            fclose(keycache_debug_log);                                       \
 
263
            keycache_debug_log= 0;                                            \
 
264
          }
 
265
#else
 
266
#define KEYCACHE_DEBUG_OPEN
 
267
#define KEYCACHE_DEBUG_CLOSE
 
268
#endif /* defined(KEYCACHE_DEBUG_LOG) */
 
269
 
 
270
#if defined(KEYCACHE_DEBUG_LOG) && defined(KEYCACHE_DEBUG)
 
271
#define KEYCACHE_DBUG_PRINT(l, m)                                             \
 
272
            { if (keycache_debug_log) fprintf(keycache_debug_log, "%s: ", l); \
 
273
              keycache_debug_print m; }
 
274
 
 
275
#define KEYCACHE_DBUG_ASSERT(a)                                               \
 
276
            { if (! (a) && keycache_debug_log) fclose(keycache_debug_log);    \
 
277
              assert(a); }
 
278
#else
 
279
#define KEYCACHE_DBUG_PRINT(l, m)  DBUG_PRINT(l, m)
 
280
#define KEYCACHE_DBUG_ASSERT(a)    DBUG_ASSERT(a)
 
281
#endif /* defined(KEYCACHE_DEBUG_LOG) && defined(KEYCACHE_DEBUG) */
 
282
 
 
283
#if defined(KEYCACHE_DEBUG) || !defined(DBUG_OFF)
 
284
#ifdef THREAD
 
285
static long keycache_thread_id;
 
286
#define KEYCACHE_THREAD_TRACE(l)                                              \
 
287
             KEYCACHE_DBUG_PRINT(l,("|thread %ld",keycache_thread_id))
 
288
 
 
289
#define KEYCACHE_THREAD_TRACE_BEGIN(l)                                        \
 
290
            { struct st_my_thread_var *thread_var= my_thread_var;             \
 
291
              keycache_thread_id= thread_var->id;                             \
 
292
              KEYCACHE_DBUG_PRINT(l,("[thread %ld",keycache_thread_id)) }
 
293
 
 
294
#define KEYCACHE_THREAD_TRACE_END(l)                                          \
 
295
            KEYCACHE_DBUG_PRINT(l,("]thread %ld",keycache_thread_id))
 
296
#else /* THREAD */
 
297
#define KEYCACHE_THREAD_TRACE(l)        KEYCACHE_DBUG_PRINT(l,(""))
 
298
#define KEYCACHE_THREAD_TRACE_BEGIN(l)  KEYCACHE_DBUG_PRINT(l,(""))
 
299
#define KEYCACHE_THREAD_TRACE_END(l)    KEYCACHE_DBUG_PRINT(l,(""))
 
300
#endif /* THREAD */
 
301
#else
 
302
#define KEYCACHE_THREAD_TRACE_BEGIN(l)
 
303
#define KEYCACHE_THREAD_TRACE_END(l)
 
304
#define KEYCACHE_THREAD_TRACE(l)
 
305
#endif /* defined(KEYCACHE_DEBUG) || !defined(DBUG_OFF) */
 
306
 
 
307
#define BLOCK_NUMBER(b)                                                       \
 
308
  ((uint) (((char*)(b)-(char *) keycache->block_root)/sizeof(BLOCK_LINK)))
 
309
#define HASH_LINK_NUMBER(h)                                                   \
 
310
  ((uint) (((char*)(h)-(char *) keycache->hash_link_root)/sizeof(HASH_LINK)))
 
311
 
 
312
#if (defined(KEYCACHE_TIMEOUT)) || defined(KEYCACHE_DEBUG)
227
313
static int keycache_pthread_cond_wait(pthread_cond_t *cond,
228
314
                                      pthread_mutex_t *mutex);
229
315
#else
230
316
#define  keycache_pthread_cond_wait pthread_cond_wait
231
317
#endif
232
318
 
 
319
#if defined(KEYCACHE_DEBUG)
 
320
static int keycache_pthread_mutex_lock(pthread_mutex_t *mutex);
 
321
static void keycache_pthread_mutex_unlock(pthread_mutex_t *mutex);
 
322
static int keycache_pthread_cond_signal(pthread_cond_t *cond);
 
323
#else
233
324
#define keycache_pthread_mutex_lock pthread_mutex_lock
234
325
#define keycache_pthread_mutex_unlock pthread_mutex_unlock
235
326
#define keycache_pthread_cond_signal pthread_cond_signal
236
 
 
237
 
static inline uint32_t next_power(uint32_t value)
 
327
#endif /* defined(KEYCACHE_DEBUG) */
 
328
 
 
329
#if !defined(DBUG_OFF)
 
330
#if defined(inline)
 
331
#undef inline
 
332
#endif
 
333
#define inline  /* disabled inline for easier debugging */
 
334
static int fail_block(BLOCK_LINK *block);
 
335
static int fail_hlink(HASH_LINK *hlink);
 
336
static int cache_empty(KEY_CACHE *keycache);
 
337
#endif
 
338
 
 
339
static inline uint next_power(uint value)
238
340
{
239
 
  return (uint) my_round_up_to_next_power((uint32_t) value) << 1;
 
341
  return (uint) my_round_up_to_next_power((uint32) value) << 1;
240
342
}
241
343
 
242
344
 
265
367
 
266
368
*/
267
369
 
268
 
int init_key_cache(KEY_CACHE *keycache, uint32_t key_cache_block_size,
269
 
                   size_t use_mem, uint32_t division_limit,
270
 
                   uint32_t age_threshold)
 
370
int init_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
 
371
                   size_t use_mem, uint division_limit,
 
372
                   uint age_threshold)
271
373
{
272
 
  uint32_t blocks, hash_links;
 
374
  ulong blocks, hash_links;
273
375
  size_t length;
274
376
  int error;
275
 
  assert(key_cache_block_size >= 512);
 
377
  DBUG_ENTER("init_key_cache");
 
378
  DBUG_ASSERT(key_cache_block_size >= 512);
276
379
 
 
380
  KEYCACHE_DEBUG_OPEN;
277
381
  if (keycache->key_cache_inited && keycache->disk_blocks > 0)
278
382
  {
279
 
    return(0);
 
383
    DBUG_PRINT("warning",("key cache already in use"));
 
384
    DBUG_RETURN(0);
280
385
  }
281
386
 
282
387
  keycache->global_cache_w_requests= keycache->global_cache_r_requests= 0;
300
405
 
301
406
  keycache->key_cache_mem_size= use_mem;
302
407
  keycache->key_cache_block_size= key_cache_block_size;
 
408
  DBUG_PRINT("info", ("key_cache_block_size: %u",
 
409
                      key_cache_block_size));
303
410
 
304
 
  blocks= (uint32_t) (use_mem / (sizeof(BLOCK_LINK) + 2 * sizeof(HASH_LINK) +
 
411
  blocks= (ulong) (use_mem / (sizeof(BLOCK_LINK) + 2 * sizeof(HASH_LINK) +
305
412
                              sizeof(HASH_LINK*) * 5/4 + key_cache_block_size));
306
413
  /* It doesn't make sense to have too few blocks (less than 8) */
307
414
  if (blocks >= 8)
323
430
             ((size_t) blocks * keycache->key_cache_block_size) > use_mem)
324
431
        blocks--;
325
432
      /* Allocate memory for cache page buffers */
326
 
      if ((keycache->block_mem= (unsigned char *)malloc((size_t) blocks * keycache->key_cache_block_size)))
 
433
      if ((keycache->block_mem= malloc((size_t) blocks * keycache->key_cache_block_size)))
327
434
      {
328
435
        /*
329
436
          Allocate memory for blocks, hash_links and hash entries;
330
437
          For each block 2 hash links are allocated
331
438
        */
332
 
        if ((keycache->block_root= (BLOCK_LINK*) malloc(length)))
 
439
        if ((keycache->block_root= (BLOCK_LINK*) my_malloc(length,
 
440
                                                           MYF(0))))
333
441
          break;
334
442
        free(keycache->block_mem);
335
443
        keycache->block_mem= 0;
336
444
      }
337
445
      if (blocks < 8)
338
446
      {
339
 
        errno= ENOMEM;
 
447
        my_errno= ENOMEM;
340
448
        my_error(EE_OUTOFMEMORY, MYF(0), blocks * keycache->key_cache_block_size);
341
449
        goto err;
342
450
      }
350
458
    keycache->hash_link_root= (HASH_LINK*) ((char*) keycache->hash_root +
351
459
                                            ALIGN_SIZE((sizeof(HASH_LINK*) *
352
460
                                                        keycache->hash_entries)));
353
 
    memset(keycache->block_root, 0,
354
 
           keycache->disk_blocks * sizeof(BLOCK_LINK));
355
 
    memset(keycache->hash_root, 0,
356
 
           keycache->hash_entries * sizeof(HASH_LINK*));
357
 
    memset(keycache->hash_link_root, 0,
358
 
           keycache->hash_links * sizeof(HASH_LINK));
 
461
    bzero((uchar*) keycache->block_root,
 
462
          keycache->disk_blocks * sizeof(BLOCK_LINK));
 
463
    bzero((uchar*) keycache->hash_root,
 
464
          keycache->hash_entries * sizeof(HASH_LINK*));
 
465
    bzero((uchar*) keycache->hash_link_root,
 
466
          keycache->hash_links * sizeof(HASH_LINK));
359
467
    keycache->hash_links_used= 0;
360
468
    keycache->free_hash_list= NULL;
361
469
    keycache->blocks_used= keycache->blocks_changed= 0;
380
488
 
381
489
    keycache->waiting_for_hash_link.last_thread= NULL;
382
490
    keycache->waiting_for_block.last_thread= NULL;
383
 
    memset(keycache->changed_blocks, 0,
384
 
           sizeof(keycache->changed_blocks[0]) * CHANGED_BLOCKS_HASH);
385
 
    memset(keycache->file_blocks, 0,
386
 
           sizeof(keycache->file_blocks[0]) * CHANGED_BLOCKS_HASH);
 
491
    DBUG_PRINT("exit",
 
492
               ("disk_blocks: %d  block_root: 0x%lx  hash_entries: %d\
 
493
 hash_root: 0x%lx  hash_links: %d  hash_link_root: 0x%lx",
 
494
                keycache->disk_blocks,  (long) keycache->block_root,
 
495
                keycache->hash_entries, (long) keycache->hash_root,
 
496
                keycache->hash_links,   (long) keycache->hash_link_root));
 
497
    bzero((uchar*) keycache->changed_blocks,
 
498
          sizeof(keycache->changed_blocks[0]) * CHANGED_BLOCKS_HASH);
 
499
    bzero((uchar*) keycache->file_blocks,
 
500
          sizeof(keycache->file_blocks[0]) * CHANGED_BLOCKS_HASH);
387
501
  }
388
502
  else
389
503
  {
392
506
  }
393
507
 
394
508
  keycache->blocks= keycache->disk_blocks > 0 ? keycache->disk_blocks : 0;
395
 
  return((int) keycache->disk_blocks);
 
509
  DBUG_RETURN((int) keycache->disk_blocks);
396
510
 
397
511
err:
398
 
  error= errno;
 
512
  error= my_errno;
399
513
  keycache->disk_blocks= 0;
400
514
  keycache->blocks=  0;
401
515
  if (keycache->block_mem)
405
519
  }
406
520
  if (keycache->block_root)
407
521
  {
408
 
    free((unsigned char*) keycache->block_root);
 
522
    my_free((uchar*) keycache->block_root, MYF(0));
409
523
    keycache->block_root= NULL;
410
524
  }
411
 
  errno= error;
 
525
  my_errno= error;
412
526
  keycache->can_be_used= 0;
413
 
  return(0);
 
527
  DBUG_RETURN(0);
414
528
}
415
529
 
416
530
 
443
557
    (when cnt_for_resize=0).
444
558
*/
445
559
 
446
 
int resize_key_cache(KEY_CACHE *keycache, uint32_t key_cache_block_size,
447
 
                     size_t use_mem, uint32_t division_limit,
448
 
                     uint32_t age_threshold)
 
560
int resize_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
 
561
                     size_t use_mem, uint division_limit,
 
562
                     uint age_threshold)
449
563
{
450
564
  int blocks;
 
565
  DBUG_ENTER("resize_key_cache");
451
566
 
452
567
  if (!keycache->key_cache_inited)
453
 
    return(keycache->disk_blocks);
 
568
    DBUG_RETURN(keycache->disk_blocks);
454
569
 
455
570
  if(key_cache_block_size == keycache->key_cache_block_size &&
456
571
     use_mem == keycache->key_cache_mem_size)
457
572
  {
458
573
    change_key_cache_param(keycache, division_limit, age_threshold);
459
 
    return(keycache->disk_blocks);
 
574
    DBUG_RETURN(keycache->disk_blocks);
460
575
  }
461
576
 
462
577
  keycache_pthread_mutex_lock(&keycache->cache_lock);
463
578
 
 
579
#ifdef THREAD
464
580
  /*
465
581
    We may need to wait for another thread which is doing a resize
466
582
    already. This cannot happen in the MySQL server though. It allows
469
585
  */
470
586
  while (keycache->in_resize)
471
587
  {
 
588
    /* purecov: begin inspected */
472
589
    wait_on_queue(&keycache->resize_queue, &keycache->cache_lock);
 
590
    /* purecov: end */
473
591
  }
 
592
#endif
474
593
 
475
594
  /*
476
595
    Mark the operation in progress. This blocks other threads from doing
493
612
      keycache->can_be_used= 0;
494
613
      goto finish;
495
614
    }
 
615
    DBUG_ASSERT(cache_empty(keycache));
496
616
 
497
617
    /* End the flush phase. */
498
618
    keycache->resize_in_flush= 0;
499
619
  }
500
620
 
 
621
#ifdef THREAD
501
622
  /*
502
623
    Some direct read/write operations (bypassing the cache) may still be
503
624
    unfinished. Wait until they are done. If the key cache can be used,
511
632
  */
512
633
  while (keycache->cnt_for_resize_op)
513
634
    wait_on_queue(&keycache->waiting_for_resize_cnt, &keycache->cache_lock);
 
635
#else
 
636
  KEYCACHE_DBUG_ASSERT(keycache->cnt_for_resize_op == 0);
 
637
#endif
514
638
 
515
639
  /*
516
640
    Free old cache structures, allocate new structures, and initialize
534
658
  release_whole_queue(&keycache->resize_queue);
535
659
 
536
660
  keycache_pthread_mutex_unlock(&keycache->cache_lock);
537
 
  return(blocks);
 
661
  DBUG_RETURN(blocks);
538
662
}
539
663
 
540
664
 
575
699
    age_threshold.
576
700
*/
577
701
 
578
 
static void change_key_cache_param(KEY_CACHE *keycache, uint32_t division_limit,
579
 
                            uint32_t age_threshold)
 
702
void change_key_cache_param(KEY_CACHE *keycache, uint division_limit,
 
703
                            uint age_threshold)
580
704
{
 
705
  DBUG_ENTER("change_key_cache_param");
 
706
 
581
707
  keycache_pthread_mutex_lock(&keycache->cache_lock);
582
708
  if (division_limit)
583
709
    keycache->min_warm_blocks= (keycache->disk_blocks *
586
712
    keycache->age_threshold=   (keycache->disk_blocks *
587
713
                                age_threshold / 100);
588
714
  keycache_pthread_mutex_unlock(&keycache->cache_lock);
589
 
  return;
 
715
  DBUG_VOID_RETURN;
590
716
}
591
717
 
592
718
 
602
728
    none
603
729
*/
604
730
 
605
 
void end_key_cache(KEY_CACHE *keycache, bool cleanup)
 
731
void end_key_cache(KEY_CACHE *keycache, my_bool cleanup)
606
732
{
 
733
  DBUG_ENTER("end_key_cache");
 
734
  DBUG_PRINT("enter", ("key_cache: 0x%lx", (long) keycache));
 
735
 
607
736
  if (!keycache->key_cache_inited)
608
 
    return;
 
737
    DBUG_VOID_RETURN;
609
738
 
610
739
  if (keycache->disk_blocks > 0)
611
740
  {
613
742
    {
614
743
      free(keycache->block_mem);
615
744
      keycache->block_mem= NULL;
616
 
      free((unsigned char*) keycache->block_root);
 
745
      my_free((uchar*) keycache->block_root, MYF(0));
617
746
      keycache->block_root= NULL;
618
747
    }
619
748
    keycache->disk_blocks= -1;
621
750
    keycache->blocks_changed= 0;
622
751
  }
623
752
 
 
753
  DBUG_PRINT("status", ("used: %lu  changed: %lu  w_requests: %lu  "
 
754
                        "writes: %lu  r_requests: %lu  reads: %lu",
 
755
                        keycache->blocks_used, keycache->global_blocks_changed,
 
756
                        (ulong) keycache->global_cache_w_requests,
 
757
                        (ulong) keycache->global_cache_write,
 
758
                        (ulong) keycache->global_cache_r_requests,
 
759
                        (ulong) keycache->global_cache_read));
 
760
 
624
761
  if (cleanup)
625
762
  {
626
763
    pthread_mutex_destroy(&keycache->cache_lock);
627
764
    keycache->key_cache_inited= keycache->can_be_used= 0;
 
765
    KEYCACHE_DEBUG_CLOSE;
628
766
  }
629
 
  return;
 
767
  DBUG_VOID_RETURN;
630
768
} /* end_key_cache */
631
769
 
632
770
 
 
771
#ifdef THREAD
 
772
 
633
773
/*
634
774
  Link a thread into double-linked queue of waiting threads.
635
775
 
652
792
{
653
793
  struct st_my_thread_var *last;
654
794
 
655
 
  assert(!thread->next && !thread->prev);
 
795
  DBUG_ASSERT(!thread->next && !thread->prev);
656
796
  if (! (last= wqueue->last_thread))
657
797
  {
658
798
    /* Queue is empty */
687
827
static void unlink_from_queue(KEYCACHE_WQUEUE *wqueue,
688
828
                                     struct st_my_thread_var *thread)
689
829
{
690
 
  assert(thread->next && thread->prev);
 
830
  KEYCACHE_DBUG_PRINT("unlink_from_queue", ("thread %ld", thread->id));
 
831
  DBUG_ASSERT(thread->next && thread->prev);
691
832
  if (thread->next == thread)
692
833
    /* The queue contains only one member */
693
834
    wqueue->last_thread= NULL;
700
841
                                      thread->prev);
701
842
  }
702
843
  thread->next= NULL;
 
844
#if !defined(DBUG_OFF)
 
845
  /*
 
846
    This makes it easier to see it's not in a chain during debugging.
 
847
    And some DBUG_ASSERT() rely on it.
 
848
  */
703
849
  thread->prev= NULL;
 
850
#endif
704
851
}
705
852
 
706
853
 
734
881
  struct st_my_thread_var *thread= my_thread_var;
735
882
 
736
883
  /* Add to queue. */
737
 
  assert(!thread->next);
738
 
  assert(!thread->prev); /* Not required, but must be true anyway. */
 
884
  DBUG_ASSERT(!thread->next);
 
885
  DBUG_ASSERT(!thread->prev); /* Not required, but must be true anyway. */
739
886
  if (! (last= wqueue->last_thread))
740
887
    thread->next= thread;
741
888
  else
751
898
  */
752
899
  do
753
900
  {
 
901
    KEYCACHE_DBUG_PRINT("wait", ("suspend thread %ld", thread->id));
754
902
    keycache_pthread_cond_wait(&thread->suspend, mutex);
755
903
  }
756
904
  while (thread->next);
787
935
  do
788
936
  {
789
937
    thread=next;
 
938
    KEYCACHE_DBUG_PRINT("release_whole_queue: signal",
 
939
                        ("thread %ld", thread->id));
790
940
    /* Signal the thread. */
791
941
    keycache_pthread_cond_signal(&thread->suspend);
792
942
    /* Take thread from queue. */
799
949
  wqueue->last_thread= NULL;
800
950
}
801
951
 
 
952
#endif /* THREAD */
 
953
 
802
954
 
803
955
/*
804
956
  Unlink a block from the chain of dirty/clean blocks
805
957
*/
806
 
static void unlink_changed(BLOCK_LINK *block)
 
958
 
 
959
static inline void unlink_changed(BLOCK_LINK *block)
807
960
{
808
 
  assert(block->prev_changed && *block->prev_changed == block);
 
961
  DBUG_ASSERT(block->prev_changed && *block->prev_changed == block);
809
962
  if (block->next_changed)
810
963
    block->next_changed->prev_changed= block->prev_changed;
811
964
  *block->prev_changed= block->next_changed;
 
965
 
 
966
#if !defined(DBUG_OFF)
 
967
  /*
 
968
    This makes it easier to see it's not in a chain during debugging.
 
969
    And some DBUG_ASSERT() rely on it.
 
970
  */
812
971
  block->next_changed= NULL;
813
972
  block->prev_changed= NULL;
 
973
#endif
814
974
}
815
975
 
816
976
 
818
978
  Link a block into the chain of dirty/clean blocks
819
979
*/
820
980
 
821
 
static void link_changed(BLOCK_LINK *block, BLOCK_LINK **phead)
 
981
static inline void link_changed(BLOCK_LINK *block, BLOCK_LINK **phead)
822
982
{
823
 
  assert(!block->next_changed);
824
 
  assert(!block->prev_changed);
 
983
  DBUG_ASSERT(!block->next_changed);
 
984
  DBUG_ASSERT(!block->prev_changed);
825
985
  block->prev_changed= phead;
826
986
  if ((block->next_changed= *phead))
827
987
    (*phead)->prev_changed= &block->next_changed;
856
1016
 
857
1017
static void link_to_file_list(KEY_CACHE *keycache,
858
1018
                              BLOCK_LINK *block, int file,
859
 
                              bool unlink_block)
 
1019
                              my_bool unlink_block)
860
1020
{
861
 
  assert(block->status & BLOCK_IN_USE);
862
 
  assert(block->hash_link && block->hash_link->block == block);
863
 
  assert(block->hash_link->file == file);
 
1021
  DBUG_ASSERT(block->status & BLOCK_IN_USE);
 
1022
  DBUG_ASSERT(block->hash_link && block->hash_link->block == block);
 
1023
  DBUG_ASSERT(block->hash_link->file == file);
864
1024
  if (unlink_block)
865
1025
    unlink_changed(block);
866
1026
  link_changed(block, &keycache->file_blocks[FILE_HASH(file)]);
898
1058
static void link_to_changed_list(KEY_CACHE *keycache,
899
1059
                                 BLOCK_LINK *block)
900
1060
{
901
 
  assert(block->status & BLOCK_IN_USE);
902
 
  assert(!(block->status & BLOCK_CHANGED));
903
 
  assert(block->hash_link && block->hash_link->block == block);
 
1061
  DBUG_ASSERT(block->status & BLOCK_IN_USE);
 
1062
  DBUG_ASSERT(!(block->status & BLOCK_CHANGED));
 
1063
  DBUG_ASSERT(block->hash_link && block->hash_link->block == block);
904
1064
 
905
1065
  unlink_changed(block);
906
1066
  link_changed(block,
950
1110
    not linked in the LRU ring.
951
1111
*/
952
1112
 
953
 
static void link_block(KEY_CACHE *keycache, BLOCK_LINK *block, bool hot,
954
 
                       bool at_end)
 
1113
static void link_block(KEY_CACHE *keycache, BLOCK_LINK *block, my_bool hot,
 
1114
                       my_bool at_end)
955
1115
{
956
1116
  BLOCK_LINK *ins;
957
1117
  BLOCK_LINK **pins;
958
1118
 
959
 
  assert((block->status & ~BLOCK_CHANGED) == (BLOCK_READ | BLOCK_IN_USE));
960
 
  assert(block->hash_link); /*backptr to block NULL from free_block()*/
961
 
  assert(!block->requests);
962
 
  assert(block->prev_changed && *block->prev_changed == block);
963
 
  assert(!block->next_used);
964
 
  assert(!block->prev_used);
 
1119
  DBUG_ASSERT((block->status & ~BLOCK_CHANGED) == (BLOCK_READ | BLOCK_IN_USE));
 
1120
  DBUG_ASSERT(block->hash_link); /*backptr to block NULL from free_block()*/
 
1121
  DBUG_ASSERT(!block->requests);
 
1122
  DBUG_ASSERT(block->prev_changed && *block->prev_changed == block);
 
1123
  DBUG_ASSERT(!block->next_used);
 
1124
  DBUG_ASSERT(!block->prev_used);
 
1125
#ifdef THREAD
965
1126
  if (!hot && keycache->waiting_for_block.last_thread)
966
1127
  {
967
1128
    /* Signal that in the LRU warm sub-chain an available block has appeared */
981
1142
      */
982
1143
      if ((HASH_LINK *) thread->opt_info == hash_link)
983
1144
      {
 
1145
        KEYCACHE_DBUG_PRINT("link_block: signal", ("thread %ld", thread->id));
984
1146
        keycache_pthread_cond_signal(&thread->suspend);
985
1147
        unlink_from_queue(&keycache->waiting_for_block, thread);
986
1148
        block->requests++;
1011
1173
      probably easier to read.
1012
1174
    */
1013
1175
    block->status|= BLOCK_IN_EVICTION;
 
1176
    KEYCACHE_THREAD_TRACE("link_block: after signaling");
 
1177
#if defined(KEYCACHE_DEBUG)
 
1178
    KEYCACHE_DBUG_PRINT("link_block",
 
1179
        ("linked,unlinked block %u  status=%x  #requests=%u  #available=%u",
 
1180
         BLOCK_NUMBER(block), block->status,
 
1181
         block->requests, keycache->blocks_available));
 
1182
#endif
1014
1183
    return;
1015
1184
  }
 
1185
#else /* THREAD */
 
1186
  KEYCACHE_DBUG_ASSERT(! (!hot && keycache->waiting_for_block.last_thread));
 
1187
      /* Condition not transformed using DeMorgan, to keep the text identical */
 
1188
#endif /* THREAD */
1016
1189
  pins= hot ? &keycache->used_ins : &keycache->used_last;
1017
1190
  ins= *pins;
1018
1191
  if (ins)
1030
1203
    keycache->used_last= keycache->used_ins= block->next_used= block;
1031
1204
    block->prev_used= &block->next_used;
1032
1205
  }
 
1206
  KEYCACHE_THREAD_TRACE("link_block");
 
1207
#if defined(KEYCACHE_DEBUG)
 
1208
  keycache->blocks_available++;
 
1209
  KEYCACHE_DBUG_PRINT("link_block",
 
1210
      ("linked block %u:%1u  status=%x  #requests=%u  #available=%u",
 
1211
       BLOCK_NUMBER(block), at_end, block->status,
 
1212
       block->requests, keycache->blocks_available));
 
1213
  KEYCACHE_DBUG_ASSERT((ulong) keycache->blocks_available <=
 
1214
                       keycache->blocks_used);
 
1215
#endif
1033
1216
}
1034
1217
 
1035
1218
 
1050
1233
 
1051
1234
static void unlink_block(KEY_CACHE *keycache, BLOCK_LINK *block)
1052
1235
{
1053
 
  assert((block->status & ~BLOCK_CHANGED) == (BLOCK_READ | BLOCK_IN_USE));
1054
 
  assert(block->hash_link); /*backptr to block NULL from free_block()*/
1055
 
  assert(!block->requests);
1056
 
  assert(block->prev_changed && *block->prev_changed == block);
1057
 
  assert(block->next_used && block->prev_used &&
 
1236
  DBUG_ASSERT((block->status & ~BLOCK_CHANGED) == (BLOCK_READ | BLOCK_IN_USE));
 
1237
  DBUG_ASSERT(block->hash_link); /*backptr to block NULL from free_block()*/
 
1238
  DBUG_ASSERT(!block->requests);
 
1239
  DBUG_ASSERT(block->prev_changed && *block->prev_changed == block);
 
1240
  DBUG_ASSERT(block->next_used && block->prev_used &&
1058
1241
              (block->next_used->prev_used == &block->next_used) &&
1059
1242
              (*block->prev_used == block));
1060
1243
  if (block->next_used == block)
1070
1253
      keycache->used_ins=STRUCT_PTR(BLOCK_LINK, next_used, block->prev_used);
1071
1254
  }
1072
1255
  block->next_used= NULL;
 
1256
#if !defined(DBUG_OFF)
 
1257
  /*
 
1258
    This makes it easier to see it's not in a chain during debugging.
 
1259
    And some DBUG_ASSERT() rely on it.
 
1260
  */
1073
1261
  block->prev_used= NULL;
 
1262
#endif
 
1263
 
 
1264
  KEYCACHE_THREAD_TRACE("unlink_block");
 
1265
#if defined(KEYCACHE_DEBUG)
 
1266
  KEYCACHE_DBUG_ASSERT(keycache->blocks_available != 0);
 
1267
  keycache->blocks_available--;
 
1268
  KEYCACHE_DBUG_PRINT("unlink_block",
 
1269
    ("unlinked block %u  status=%x   #requests=%u  #available=%u",
 
1270
     BLOCK_NUMBER(block), block->status,
 
1271
     block->requests, keycache->blocks_available));
 
1272
#endif
1074
1273
}
1075
1274
 
1076
1275
 
1092
1291
*/
1093
1292
static void reg_requests(KEY_CACHE *keycache, BLOCK_LINK *block, int count)
1094
1293
{
1095
 
  assert(block->status & BLOCK_IN_USE);
1096
 
  assert(block->hash_link);
 
1294
  DBUG_ASSERT(block->status & BLOCK_IN_USE);
 
1295
  DBUG_ASSERT(block->hash_link);
1097
1296
 
1098
1297
  if (!block->requests)
1099
1298
    unlink_block(keycache, block);
1116
1315
 
1117
1316
  NOTES.
1118
1317
    Every linking to the LRU ring decrements by one a special block
1119
 
    counter (if it's positive). If the at_end parameter is true the block is
 
1318
    counter (if it's positive). If the at_end parameter is TRUE the block is
1120
1319
    added either at the end of warm sub-chain or at the end of hot sub-chain.
1121
1320
    It is added to the hot subchain if its counter is zero and number of
1122
1321
    blocks in warm sub-chain is not less than some low limit (determined by
1123
1322
    the division_limit parameter). Otherwise the block is added to the warm
1124
 
    sub-chain. If the at_end parameter is false the block is always added
 
1323
    sub-chain. If the at_end parameter is FALSE the block is always added
1125
1324
    at beginning of the warm sub-chain.
1126
1325
    Thus a warm block can be promoted to the hot sub-chain when its counter
1127
1326
    becomes zero for the first time.
1136
1335
static void unreg_request(KEY_CACHE *keycache,
1137
1336
                          BLOCK_LINK *block, int at_end)
1138
1337
{
1139
 
  assert(block->status & (BLOCK_READ | BLOCK_IN_USE));
1140
 
  assert(block->hash_link); /*backptr to block NULL from free_block()*/
1141
 
  assert(block->requests);
1142
 
  assert(block->prev_changed && *block->prev_changed == block);
1143
 
  assert(!block->next_used);
1144
 
  assert(!block->prev_used);
 
1338
  DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
 
1339
  DBUG_ASSERT(block->hash_link); /*backptr to block NULL from free_block()*/
 
1340
  DBUG_ASSERT(block->requests);
 
1341
  DBUG_ASSERT(block->prev_changed && *block->prev_changed == block);
 
1342
  DBUG_ASSERT(!block->next_used);
 
1343
  DBUG_ASSERT(!block->prev_used);
1145
1344
  if (! --block->requests)
1146
1345
  {
1147
 
    bool hot;
 
1346
    my_bool hot;
1148
1347
    if (block->hits_left)
1149
1348
      block->hits_left--;
1150
1349
    hot= !block->hits_left && at_end &&
1154
1353
      if (block->temperature == BLOCK_WARM)
1155
1354
        keycache->warm_blocks--;
1156
1355
      block->temperature= BLOCK_HOT;
 
1356
      KEYCACHE_DBUG_PRINT("unreg_request", ("#warm_blocks: %lu",
 
1357
                           keycache->warm_blocks));
1157
1358
    }
1158
 
    link_block(keycache, block, hot, (bool)at_end);
 
1359
    link_block(keycache, block, hot, (my_bool)at_end);
1159
1360
    block->last_hit_time= keycache->keycache_time;
1160
1361
    keycache->keycache_time++;
1161
1362
    /*
1184
1385
        keycache->warm_blocks++;
1185
1386
        block->temperature= BLOCK_WARM;
1186
1387
      }
 
1388
      KEYCACHE_DBUG_PRINT("unreg_request", ("#warm_blocks: %lu",
 
1389
                           keycache->warm_blocks));
1187
1390
    }
1188
1391
  }
1189
1392
}
1194
1397
 
1195
1398
static void remove_reader(BLOCK_LINK *block)
1196
1399
{
1197
 
  assert(block->status & (BLOCK_READ | BLOCK_IN_USE));
1198
 
  assert(block->hash_link && block->hash_link->block == block);
1199
 
  assert(block->prev_changed && *block->prev_changed == block);
1200
 
  assert(!block->next_used);
1201
 
  assert(!block->prev_used);
1202
 
  assert(block->hash_link->requests);
 
1400
  DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
 
1401
  DBUG_ASSERT(block->hash_link && block->hash_link->block == block);
 
1402
  DBUG_ASSERT(block->prev_changed && *block->prev_changed == block);
 
1403
  DBUG_ASSERT(!block->next_used);
 
1404
  DBUG_ASSERT(!block->prev_used);
 
1405
  DBUG_ASSERT(block->hash_link->requests);
 
1406
#ifdef THREAD
1203
1407
  if (! --block->hash_link->requests && block->condvar)
1204
1408
    keycache_pthread_cond_signal(block->condvar);
 
1409
#else
 
1410
  --block->hash_link->requests;
 
1411
#endif
1205
1412
}
1206
1413
 
1207
1414
 
1213
1420
static void wait_for_readers(KEY_CACHE *keycache,
1214
1421
                             BLOCK_LINK *block)
1215
1422
{
 
1423
#ifdef THREAD
1216
1424
  struct st_my_thread_var *thread= my_thread_var;
1217
 
  assert(block->status & (BLOCK_READ | BLOCK_IN_USE));
1218
 
  assert(!(block->status & (BLOCK_ERROR | BLOCK_IN_FLUSH |
 
1425
  DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
 
1426
  DBUG_ASSERT(!(block->status & (BLOCK_ERROR | BLOCK_IN_FLUSH |
1219
1427
                                 BLOCK_CHANGED)));
1220
 
  assert(block->hash_link);
1221
 
  assert(block->hash_link->block == block);
 
1428
  DBUG_ASSERT(block->hash_link);
 
1429
  DBUG_ASSERT(block->hash_link->block == block);
1222
1430
  /* Linked in file_blocks or changed_blocks hash. */
1223
 
  assert(block->prev_changed && *block->prev_changed == block);
 
1431
  DBUG_ASSERT(block->prev_changed && *block->prev_changed == block);
1224
1432
  /* Not linked in LRU ring. */
1225
 
  assert(!block->next_used);
1226
 
  assert(!block->prev_used);
 
1433
  DBUG_ASSERT(!block->next_used);
 
1434
  DBUG_ASSERT(!block->prev_used);
1227
1435
  while (block->hash_link->requests)
1228
1436
  {
 
1437
    KEYCACHE_DBUG_PRINT("wait_for_readers: wait",
 
1438
                        ("suspend thread %ld  block %u",
 
1439
                         thread->id, BLOCK_NUMBER(block)));
1229
1440
    /* There must be no other waiter. We have no queue here. */
1230
 
    assert(!block->condvar);
 
1441
    DBUG_ASSERT(!block->condvar);
1231
1442
    block->condvar= &thread->suspend;
1232
1443
    keycache_pthread_cond_wait(&thread->suspend, &keycache->cache_lock);
1233
1444
    block->condvar= NULL;
1234
1445
  }
 
1446
#else
 
1447
  KEYCACHE_DBUG_ASSERT(block->hash_link->requests == 0);
 
1448
#endif
1235
1449
}
1236
1450
 
1237
1451
 
1255
1469
 
1256
1470
static void unlink_hash(KEY_CACHE *keycache, HASH_LINK *hash_link)
1257
1471
{
1258
 
  assert(hash_link->requests == 0);
 
1472
  KEYCACHE_DBUG_PRINT("unlink_hash", ("fd: %u  pos_ %lu  #requests=%u",
 
1473
      (uint) hash_link->file,(ulong) hash_link->diskpos, hash_link->requests));
 
1474
  KEYCACHE_DBUG_ASSERT(hash_link->requests == 0);
1259
1475
  if ((*hash_link->prev= hash_link->next))
1260
1476
    hash_link->next->prev= hash_link->prev;
1261
1477
  hash_link->block= NULL;
 
1478
#ifdef THREAD
1262
1479
  if (keycache->waiting_for_hash_link.last_thread)
1263
1480
  {
1264
1481
    /* Signal that a free hash link has appeared */
1283
1500
      */
1284
1501
      if (page->file == hash_link->file && page->filepos == hash_link->diskpos)
1285
1502
      {
 
1503
        KEYCACHE_DBUG_PRINT("unlink_hash: signal", ("thread %ld", thread->id));
1286
1504
        keycache_pthread_cond_signal(&thread->suspend);
1287
1505
        unlink_from_queue(&keycache->waiting_for_hash_link, thread);
1288
1506
      }
1293
1511
              hash_link);
1294
1512
    return;
1295
1513
  }
 
1514
#else /* THREAD */
 
1515
  KEYCACHE_DBUG_ASSERT(! (keycache->waiting_for_hash_link.last_thread));
 
1516
#endif /* THREAD */
1296
1517
  hash_link->next= keycache->free_hash_list;
1297
1518
  keycache->free_hash_list= hash_link;
1298
1519
}
1306
1527
                                int file, my_off_t filepos)
1307
1528
{
1308
1529
  register HASH_LINK *hash_link, **start;
 
1530
#if defined(KEYCACHE_DEBUG)
 
1531
  int cnt;
 
1532
#endif
 
1533
 
 
1534
  KEYCACHE_DBUG_PRINT("get_hash_link", ("fd: %u  pos: %lu",
 
1535
                      (uint) file,(ulong) filepos));
1309
1536
 
1310
1537
restart:
1311
1538
  /*
1314
1541
     hash_link points to the first member of the list
1315
1542
  */
1316
1543
  hash_link= *(start= &keycache->hash_root[KEYCACHE_HASH(file, filepos)]);
 
1544
#if defined(KEYCACHE_DEBUG)
 
1545
  cnt= 0;
 
1546
#endif
1317
1547
  /* Look for an element for the pair (file, filepos) in the bucket chain */
1318
1548
  while (hash_link &&
1319
1549
         (hash_link->diskpos != filepos || hash_link->file != file))
1320
1550
  {
1321
1551
    hash_link= hash_link->next;
 
1552
#if defined(KEYCACHE_DEBUG)
 
1553
    cnt++;
 
1554
    if (! (cnt <= keycache->hash_links_used))
 
1555
    {
 
1556
      int i;
 
1557
      for (i=0, hash_link= *start ;
 
1558
           i < cnt ; i++, hash_link= hash_link->next)
 
1559
      {
 
1560
        KEYCACHE_DBUG_PRINT("get_hash_link", ("fd: %u  pos: %lu",
 
1561
            (uint) hash_link->file,(ulong) hash_link->diskpos));
 
1562
      }
 
1563
    }
 
1564
    KEYCACHE_DBUG_ASSERT(cnt <= keycache->hash_links_used);
 
1565
#endif
1322
1566
  }
1323
1567
  if (! hash_link)
1324
1568
  {
1334
1578
    }
1335
1579
    else
1336
1580
    {
 
1581
#ifdef THREAD
1337
1582
      /* Wait for a free hash link */
1338
1583
      struct st_my_thread_var *thread= my_thread_var;
1339
1584
      KEYCACHE_PAGE page;
 
1585
      KEYCACHE_DBUG_PRINT("get_hash_link", ("waiting"));
1340
1586
      page.file= file;
1341
1587
      page.filepos= filepos;
1342
1588
      thread->opt_info= (void *) &page;
1343
1589
      link_into_queue(&keycache->waiting_for_hash_link, thread);
 
1590
      KEYCACHE_DBUG_PRINT("get_hash_link: wait",
 
1591
                        ("suspend thread %ld", thread->id));
1344
1592
      keycache_pthread_cond_wait(&thread->suspend,
1345
1593
                                 &keycache->cache_lock);
1346
1594
      thread->opt_info= NULL;
 
1595
#else
 
1596
      KEYCACHE_DBUG_ASSERT(0);
 
1597
#endif
1347
1598
      goto restart;
1348
1599
    }
1349
1600
    hash_link->file= file;
1394
1645
*/
1395
1646
 
1396
1647
static BLOCK_LINK *find_key_block(KEY_CACHE *keycache,
1397
 
                                  int file, my_off_t filepos,
 
1648
                                  File file, my_off_t filepos,
1398
1649
                                  int init_hits_left,
1399
1650
                                  int wrmode, int *page_st)
1400
1651
{
1403
1654
  int error= 0;
1404
1655
  int page_status;
1405
1656
 
 
1657
  DBUG_ENTER("find_key_block");
 
1658
  KEYCACHE_THREAD_TRACE("find_key_block:begin");
 
1659
  DBUG_PRINT("enter", ("fd: %d  pos: %lu  wrmode: %d",
 
1660
                       file, (ulong) filepos, wrmode));
 
1661
  KEYCACHE_DBUG_PRINT("find_key_block", ("fd: %d  pos: %lu  wrmode: %d",
 
1662
                                         file, (ulong) filepos,
 
1663
                                         wrmode));
 
1664
#if !defined(DBUG_OFF) && defined(EXTRA_DEBUG)
 
1665
  DBUG_EXECUTE("check_keycache2",
 
1666
               test_key_cache(keycache, "start of find_key_block", 0););
 
1667
#endif
 
1668
 
1406
1669
restart:
1407
1670
  /*
1408
1671
    If the flush phase of a resize operation fails, the cache is left
1409
1672
    unusable. This will be detected only after "goto restart".
1410
1673
  */
1411
1674
  if (!keycache->can_be_used)
1412
 
    return(0);
 
1675
    DBUG_RETURN(0);
1413
1676
 
1414
1677
  /*
1415
1678
    Find the hash_link for the requested file block (file, filepos). We
1435
1698
          - not changed (clean).
1436
1699
  */
1437
1700
  hash_link= get_hash_link(keycache, file, filepos);
1438
 
  assert((hash_link->file == file) && (hash_link->diskpos == filepos));
 
1701
  DBUG_ASSERT((hash_link->file == file) && (hash_link->diskpos == filepos));
1439
1702
 
1440
1703
  page_status= -1;
1441
1704
  if ((block= hash_link->block) &&
1474
1737
        */
1475
1738
        hash_link->requests--;
1476
1739
        unlink_hash(keycache, hash_link);
1477
 
        return(0);
 
1740
        DBUG_RETURN(0);
1478
1741
      }
1479
1742
 
1480
1743
      /*
1493
1756
      link_into_queue(&keycache->waiting_for_block, thread);
1494
1757
      do
1495
1758
      {
 
1759
        KEYCACHE_DBUG_PRINT("find_key_block: wait",
 
1760
                            ("suspend thread %ld", thread->id));
1496
1761
        keycache_pthread_cond_wait(&thread->suspend,
1497
1762
                                   &keycache->cache_lock);
1498
1763
      } while (thread->next);
1539
1804
        only. Waiting here on COND_FOR_REQUESTED works in all
1540
1805
        situations.
1541
1806
      */
1542
 
      assert(((block->hash_link != hash_link) &&
 
1807
      DBUG_ASSERT(((block->hash_link != hash_link) &&
1543
1808
                   (block->status & (BLOCK_IN_EVICTION | BLOCK_IN_SWITCH))) ||
1544
1809
                  ((block->hash_link == hash_link) &&
1545
1810
                   !(block->status & BLOCK_READ)));
1554
1819
        again in eviction because we registered an request on it before
1555
1820
        starting to wait.
1556
1821
      */
1557
 
      assert(block->hash_link == hash_link);
1558
 
      assert(block->status & (BLOCK_READ | BLOCK_IN_USE));
1559
 
      assert(!(block->status & (BLOCK_IN_EVICTION | BLOCK_IN_SWITCH)));
 
1822
      DBUG_ASSERT(block->hash_link == hash_link);
 
1823
      DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
 
1824
      DBUG_ASSERT(!(block->status & (BLOCK_IN_EVICTION | BLOCK_IN_SWITCH)));
1560
1825
    }
1561
1826
    /*
1562
1827
      The block is in the cache. Assigned to the hash_link. Valid data.
1568
1833
    {
1569
1834
      /* A reader can just read the block. */
1570
1835
      *page_st= PAGE_READ;
1571
 
      assert((hash_link->file == file) &&
 
1836
      DBUG_ASSERT((hash_link->file == file) &&
1572
1837
                  (hash_link->diskpos == filepos) &&
1573
1838
                  (block->hash_link == hash_link));
1574
 
      return(block);
 
1839
      DBUG_RETURN(block);
1575
1840
    }
1576
1841
 
1577
1842
    /*
1578
1843
      This is a writer. No two writers for the same block can exist.
1579
1844
      This must be assured by locks outside of the key cache.
1580
1845
    */
1581
 
    assert(!(block->status & BLOCK_FOR_UPDATE));
 
1846
    DBUG_ASSERT(!(block->status & BLOCK_FOR_UPDATE) || fail_block(block));
1582
1847
 
1583
1848
    while (block->status & BLOCK_IN_FLUSH)
1584
1849
    {
1602
1867
        unreg_request(keycache, block, 1);
1603
1868
        goto restart;
1604
1869
      }
1605
 
      assert(block->status & (BLOCK_READ | BLOCK_IN_USE));
1606
 
      assert(!(block->status & BLOCK_FOR_UPDATE));
1607
 
      assert(block->hash_link == hash_link);
 
1870
      DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
 
1871
      DBUG_ASSERT(!(block->status & BLOCK_FOR_UPDATE) || fail_block(block));
 
1872
      DBUG_ASSERT(block->hash_link == hash_link);
1608
1873
    }
1609
1874
 
1610
1875
    if (block->status & BLOCK_CHANGED)
1617
1882
        not yet been selected for flush, we can still add our changes.
1618
1883
      */
1619
1884
      *page_st= PAGE_READ;
1620
 
      assert((hash_link->file == file) &&
 
1885
      DBUG_ASSERT((hash_link->file == file) &&
1621
1886
                  (hash_link->diskpos == filepos) &&
1622
1887
                  (block->hash_link == hash_link));
1623
 
      return(block);
 
1888
      DBUG_RETURN(block);
1624
1889
    }
1625
1890
 
1626
1891
    /*
1688
1953
               (block->hash_link->file == file) &&
1689
1954
               (block->hash_link->diskpos == filepos));
1690
1955
    }
1691
 
    return(0);
 
1956
    DBUG_RETURN(0);
1692
1957
  }
1693
1958
 
1694
1959
  if (page_status == PAGE_READ &&
1703
1968
      (BLOCK_IN_SWITCH), readers of the block have not finished yet
1704
1969
      (BLOCK_REASSIGNED), or the evicting thread did not yet awake after
1705
1970
      the block has been selected for it (BLOCK_IN_EVICTION).
 
1971
    */
1706
1972
 
 
1973
    KEYCACHE_DBUG_PRINT("find_key_block",
 
1974
                        ("request for old page in block %u "
 
1975
                         "wrmode: %d  block->status: %d",
 
1976
                         BLOCK_NUMBER(block), wrmode, block->status));
 
1977
    /*
1707
1978
       Only reading requests can proceed until the old dirty page is flushed,
1708
1979
       all others are to be suspended, then resubmitted
1709
1980
    */
1731
2002
        as soon as possible. Again we must wait so that we don't find
1732
2003
        the same hash_link + block again and again.
1733
2004
      */
1734
 
      assert(hash_link->requests);
 
2005
      DBUG_ASSERT(hash_link->requests);
1735
2006
      hash_link->requests--;
 
2007
      KEYCACHE_DBUG_PRINT("find_key_block",
 
2008
                          ("request waiting for old page to be saved"));
1736
2009
      wait_on_queue(&block->wqueue[COND_FOR_SAVED], &keycache->cache_lock);
 
2010
      KEYCACHE_DBUG_PRINT("find_key_block",
 
2011
                          ("request for old page resubmitted"));
1737
2012
      /*
1738
2013
        The block is no longer assigned to this hash_link.
1739
2014
        Get another one.
1768
2043
        else
1769
2044
        {
1770
2045
          /* There are some never used blocks, take first of them */
1771
 
          assert(keycache->blocks_used <
1772
 
                      (uint32_t) keycache->disk_blocks);
 
2046
          DBUG_ASSERT(keycache->blocks_used <
 
2047
                      (ulong) keycache->disk_blocks);
1773
2048
          block= &keycache->block_root[keycache->blocks_used];
1774
2049
          block->buffer= ADD_TO_PTR(keycache->block_mem,
1775
 
                                    ((uint32_t) keycache->blocks_used*
 
2050
                                    ((ulong) keycache->blocks_used*
1776
2051
                                     keycache->key_cache_block_size),
1777
 
                                    unsigned char*);
 
2052
                                    uchar*);
1778
2053
          keycache->blocks_used++;
1779
 
          assert(!block->next_used);
 
2054
          DBUG_ASSERT(!block->next_used);
1780
2055
        }
1781
 
        assert(!block->prev_used);
1782
 
        assert(!block->next_changed);
1783
 
        assert(!block->prev_changed);
1784
 
        assert(!block->hash_link);
1785
 
        assert(!block->status);
1786
 
        assert(!block->requests);
 
2056
        DBUG_ASSERT(!block->prev_used);
 
2057
        DBUG_ASSERT(!block->next_changed);
 
2058
        DBUG_ASSERT(!block->prev_changed);
 
2059
        DBUG_ASSERT(!block->hash_link);
 
2060
        DBUG_ASSERT(!block->status);
 
2061
        DBUG_ASSERT(!block->requests);
1787
2062
        keycache->blocks_unused--;
1788
2063
        block->status= BLOCK_IN_USE;
1789
2064
        block->length= 0;
1796
2071
        hash_link->block= block;
1797
2072
        link_to_file_list(keycache, block, file, 0);
1798
2073
        page_status= PAGE_TO_BE_READ;
 
2074
        KEYCACHE_DBUG_PRINT("find_key_block",
 
2075
                            ("got free or never used block %u",
 
2076
                             BLOCK_NUMBER(block)));
1799
2077
      }
1800
2078
      else
1801
2079
      {
1804
2082
          from the LRU ring.
1805
2083
        */
1806
2084
 
 
2085
#ifdef THREAD
1807
2086
        if (! keycache->used_last)
1808
2087
        {
1809
2088
          /*
1823
2102
          link_into_queue(&keycache->waiting_for_block, thread);
1824
2103
          do
1825
2104
          {
 
2105
            KEYCACHE_DBUG_PRINT("find_key_block: wait",
 
2106
                                ("suspend thread %ld", thread->id));
1826
2107
            keycache_pthread_cond_wait(&thread->suspend,
1827
2108
                                       &keycache->cache_lock);
1828
2109
          }
1829
2110
          while (thread->next);
1830
2111
          thread->opt_info= NULL;
1831
2112
          /* Assert that block has a request registered. */
1832
 
          assert(hash_link->block->requests);
 
2113
          DBUG_ASSERT(hash_link->block->requests);
1833
2114
          /* Assert that block is not in LRU ring. */
1834
 
          assert(!hash_link->block->next_used);
1835
 
          assert(!hash_link->block->prev_used);
 
2115
          DBUG_ASSERT(!hash_link->block->next_used);
 
2116
          DBUG_ASSERT(!hash_link->block->prev_used);
1836
2117
        }
 
2118
#else
 
2119
        KEYCACHE_DBUG_ASSERT(keycache->used_last);
 
2120
#endif
1837
2121
        /*
1838
2122
          If we waited above, hash_link->block has been assigned by
1839
2123
          link_block(). Otherwise it is still NULL. In the latter case
1851
2135
            Register a request on the block. This unlinks it from the
1852
2136
            LRU ring and protects it against eviction.
1853
2137
          */
1854
 
          assert(!block->requests);
 
2138
          DBUG_ASSERT(!block->requests);
1855
2139
          reg_requests(keycache, block,1);
1856
2140
          /*
1857
2141
            We do not need to set block->status|= BLOCK_IN_EVICTION here
1875
2159
          /* this is a primary request for a new page */
1876
2160
          block->status|= BLOCK_IN_SWITCH;
1877
2161
 
 
2162
          KEYCACHE_DBUG_PRINT("find_key_block",
 
2163
                        ("got block %u for new page", BLOCK_NUMBER(block)));
 
2164
 
1878
2165
          if (block->status & BLOCK_CHANGED)
1879
2166
          {
1880
2167
            /* The block contains a dirty page - push it out of the cache */
1881
2168
 
 
2169
            KEYCACHE_DBUG_PRINT("find_key_block", ("block is dirty"));
1882
2170
            if (block->status & BLOCK_IN_FLUSH)
1883
2171
            {
1884
2172
              /*
1894
2182
                The block is marked BLOCK_IN_SWITCH. It should be left
1895
2183
                alone except for reading. No free, no write.
1896
2184
              */
1897
 
              assert(block->status & (BLOCK_READ | BLOCK_IN_USE));
1898
 
              assert(!(block->status & (BLOCK_REASSIGNED |
 
2185
              DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
 
2186
              DBUG_ASSERT(!(block->status & (BLOCK_REASSIGNED |
1899
2187
                                             BLOCK_CHANGED |
1900
2188
                                             BLOCK_FOR_UPDATE)));
1901
2189
            }
1906
2194
                BLOCK_IN_EVICTION may be true or not. Other flags must
1907
2195
                have a fixed value.
1908
2196
              */
1909
 
              assert((block->status & ~BLOCK_IN_EVICTION) ==
 
2197
              DBUG_ASSERT((block->status & ~BLOCK_IN_EVICTION) ==
1910
2198
                          (BLOCK_READ | BLOCK_IN_SWITCH |
1911
2199
                           BLOCK_IN_FLUSH | BLOCK_IN_FLUSHWRITE |
1912
2200
                           BLOCK_CHANGED | BLOCK_IN_USE));
1913
 
              assert(block->hash_link);
 
2201
              DBUG_ASSERT(block->hash_link);
1914
2202
 
1915
2203
              keycache_pthread_mutex_unlock(&keycache->cache_lock);
1916
2204
              /*
1917
2205
                The call is thread safe because only the current
1918
2206
                thread might change the block->hash_link value
1919
2207
              */
1920
 
              error= (pwrite(block->hash_link->file,
1921
 
                             block->buffer+block->offset,
1922
 
                             block->length - block->offset,
1923
 
                             block->hash_link->diskpos+ block->offset) == 0);
 
2208
              error= my_pwrite(block->hash_link->file,
 
2209
                               block->buffer+block->offset,
 
2210
                               block->length - block->offset,
 
2211
                               block->hash_link->diskpos+ block->offset,
 
2212
                               MYF(MY_NABP | MY_WAIT_IF_FULL));
1924
2213
              keycache_pthread_mutex_lock(&keycache->cache_lock);
1925
2214
 
1926
2215
              /* Block status must not have changed. */
1927
 
              assert((block->status & ~BLOCK_IN_EVICTION) ==
 
2216
              DBUG_ASSERT((block->status & ~BLOCK_IN_EVICTION) ==
1928
2217
                          (BLOCK_READ | BLOCK_IN_SWITCH |
1929
2218
                           BLOCK_IN_FLUSH | BLOCK_IN_FLUSHWRITE |
1930
 
                           BLOCK_CHANGED | BLOCK_IN_USE));
 
2219
                           BLOCK_CHANGED | BLOCK_IN_USE) || fail_block(block));
1931
2220
              keycache->global_cache_write++;
1932
2221
            }
1933
2222
          }
1937
2226
            The block comes from the LRU ring. It must have a hash_link
1938
2227
            assigned.
1939
2228
          */
1940
 
          assert(block->hash_link);
 
2229
          DBUG_ASSERT(block->hash_link);
1941
2230
          if (block->hash_link)
1942
2231
          {
1943
2232
            /*
1964
2253
              a page in the cache in a sweep, without yielding control)
1965
2254
            */
1966
2255
            wait_for_readers(keycache, block);
1967
 
            assert(block->hash_link && block->hash_link->block == block &&
 
2256
            DBUG_ASSERT(block->hash_link && block->hash_link->block == block &&
1968
2257
                        block->prev_changed);
1969
2258
            /* The reader must not have been a writer. */
1970
 
            assert(!(block->status & BLOCK_CHANGED));
 
2259
            DBUG_ASSERT(!(block->status & BLOCK_CHANGED));
1971
2260
 
1972
2261
            /* Wake flushers that might have found the block in between. */
1973
2262
            release_whole_queue(&block->wqueue[COND_FOR_SAVED]);
1980
2269
              and hash_link refer to each other. Hence we need to assign
1981
2270
              the hash_link first, but then we would not know if it was
1982
2271
              linked before. Hence we would not know if to unlink it. So
1983
 
              unlink it here and call link_to_file_list(..., false).
 
2272
              unlink it here and call link_to_file_list(..., FALSE).
1984
2273
            */
1985
2274
            unlink_changed(block);
1986
2275
          }
1991
2280
          link_to_file_list(keycache, block, file, 0);
1992
2281
          page_status= PAGE_TO_BE_READ;
1993
2282
 
1994
 
          assert(block->hash_link->block == block);
1995
 
          assert(hash_link->block->hash_link == hash_link);
 
2283
          KEYCACHE_DBUG_ASSERT(block->hash_link->block == block);
 
2284
          KEYCACHE_DBUG_ASSERT(hash_link->block->hash_link == hash_link);
1996
2285
        }
1997
2286
        else
1998
2287
        {
2010
2299
            attached to the same hash_link and as such destined for the
2011
2300
            same file block.
2012
2301
          */
 
2302
          KEYCACHE_DBUG_PRINT("find_key_block",
 
2303
                              ("block->hash_link: %p  hash_link: %p  "
 
2304
                               "block->status: %u", block->hash_link,
 
2305
                               hash_link, block->status ));
2013
2306
          page_status= (((block->hash_link == hash_link) &&
2014
2307
                         (block->status & BLOCK_READ)) ?
2015
2308
                        PAGE_READ : PAGE_WAIT_TO_BE_READ);
2038
2331
        Register a request on the block. This is another protection
2039
2332
        against eviction.
2040
2333
      */
2041
 
      assert(((block->hash_link != hash_link) &&
 
2334
      DBUG_ASSERT(((block->hash_link != hash_link) &&
2042
2335
                   (block->status & (BLOCK_IN_EVICTION | BLOCK_IN_SWITCH))) ||
2043
2336
                  ((block->hash_link == hash_link) &&
2044
2337
                   !(block->status & BLOCK_READ)) ||
2045
2338
                  ((block->status & BLOCK_READ) &&
2046
2339
                   !(block->status & (BLOCK_IN_EVICTION | BLOCK_IN_SWITCH))));
2047
2340
      reg_requests(keycache, block, 1);
 
2341
      KEYCACHE_DBUG_PRINT("find_key_block",
 
2342
                          ("block->hash_link: %p  hash_link: %p  "
 
2343
                           "block->status: %u", block->hash_link,
 
2344
                           hash_link, block->status ));
2048
2345
      page_status= (((block->hash_link == hash_link) &&
2049
2346
                     (block->status & BLOCK_READ)) ?
2050
2347
                    PAGE_READ : PAGE_WAIT_TO_BE_READ);
2051
2348
    }
2052
2349
  }
2053
2350
 
2054
 
  assert(page_status != -1);
 
2351
  KEYCACHE_DBUG_ASSERT(page_status != -1);
2055
2352
  /* Same assert basically, but be very sure. */
2056
 
  assert(block);
 
2353
  KEYCACHE_DBUG_ASSERT(block);
2057
2354
  /* Assert that block has a request and is not in LRU ring. */
2058
 
  assert(block->requests);
2059
 
  assert(!block->next_used);
2060
 
  assert(!block->prev_used);
 
2355
  DBUG_ASSERT(block->requests);
 
2356
  DBUG_ASSERT(!block->next_used);
 
2357
  DBUG_ASSERT(!block->prev_used);
2061
2358
  /* Assert that we return the correct block. */
2062
 
  assert((page_status == PAGE_WAIT_TO_BE_READ) ||
 
2359
  DBUG_ASSERT((page_status == PAGE_WAIT_TO_BE_READ) ||
2063
2360
              ((block->hash_link->file == file) &&
2064
2361
               (block->hash_link->diskpos == filepos)));
2065
2362
  *page_st=page_status;
 
2363
  KEYCACHE_DBUG_PRINT("find_key_block",
 
2364
                      ("fd: %d  pos: %lu  block->status: %u  page_status: %d",
 
2365
                       file, (ulong) filepos, block->status,
 
2366
                       page_status));
2066
2367
 
2067
 
  return(block);
 
2368
#if !defined(DBUG_OFF) && defined(EXTRA_DEBUG)
 
2369
  DBUG_EXECUTE("check_keycache2",
 
2370
               test_key_cache(keycache, "end of find_key_block",0););
 
2371
#endif
 
2372
  KEYCACHE_THREAD_TRACE("find_key_block:end");
 
2373
  DBUG_RETURN(block);
2068
2374
}
2069
2375
 
2070
2376
 
2093
2399
*/
2094
2400
 
2095
2401
static void read_block(KEY_CACHE *keycache,
2096
 
                       BLOCK_LINK *block, uint32_t read_length,
2097
 
                       uint32_t min_length, bool primary)
 
2402
                       BLOCK_LINK *block, uint read_length,
 
2403
                       uint min_length, my_bool primary)
2098
2404
{
2099
 
  uint32_t got_length;
 
2405
  uint got_length;
2100
2406
 
2101
2407
  /* On entry cache_lock is locked */
2102
2408
 
 
2409
  KEYCACHE_THREAD_TRACE("read_block");
2103
2410
  if (primary)
2104
2411
  {
2105
2412
    /*
2108
2415
      request for the block become secondary requests. For a primary
2109
2416
      request the block must be properly initialized.
2110
2417
    */
2111
 
    assert(((block->status & ~BLOCK_FOR_UPDATE) == BLOCK_IN_USE));
2112
 
    assert((block->length == 0));
2113
 
    assert((block->offset == keycache->key_cache_block_size));
2114
 
    assert((block->requests > 0));
 
2418
    DBUG_ASSERT(((block->status & ~BLOCK_FOR_UPDATE) == BLOCK_IN_USE) ||
 
2419
                fail_block(block));
 
2420
    DBUG_ASSERT((block->length == 0) || fail_block(block));
 
2421
    DBUG_ASSERT((block->offset == keycache->key_cache_block_size) ||
 
2422
                fail_block(block));
 
2423
    DBUG_ASSERT((block->requests > 0) || fail_block(block));
 
2424
 
 
2425
    KEYCACHE_DBUG_PRINT("read_block",
 
2426
                        ("page to be read by primary request"));
2115
2427
 
2116
2428
    keycache->global_cache_read++;
2117
2429
    /* Page is not in buffer yet, is to be read from disk */
2120
2432
      Here other threads may step in and register as secondary readers.
2121
2433
      They will register in block->wqueue[COND_FOR_REQUESTED].
2122
2434
    */
2123
 
    got_length= pread(block->hash_link->file, block->buffer, read_length, block->hash_link->diskpos);
 
2435
    got_length= my_pread(block->hash_link->file, block->buffer,
 
2436
                         read_length, block->hash_link->diskpos, MYF(0));
2124
2437
    keycache_pthread_mutex_lock(&keycache->cache_lock);
2125
2438
    /*
2126
2439
      The block can now have been marked for free (in case of
2127
2440
      FLUSH_RELEASE). Otherwise the state must be unchanged.
2128
2441
    */
2129
 
    assert(((block->status & ~(BLOCK_REASSIGNED |
2130
 
                                    BLOCK_FOR_UPDATE)) == BLOCK_IN_USE));
2131
 
    assert((block->length == 0));
2132
 
    assert((block->offset == keycache->key_cache_block_size));
2133
 
    assert((block->requests > 0));
 
2442
    DBUG_ASSERT(((block->status & ~(BLOCK_REASSIGNED |
 
2443
                                    BLOCK_FOR_UPDATE)) == BLOCK_IN_USE) ||
 
2444
                fail_block(block));
 
2445
    DBUG_ASSERT((block->length == 0) || fail_block(block));
 
2446
    DBUG_ASSERT((block->offset == keycache->key_cache_block_size) ||
 
2447
                fail_block(block));
 
2448
    DBUG_ASSERT((block->requests > 0) || fail_block(block));
2134
2449
 
2135
2450
    if (got_length < min_length)
2136
2451
      block->status|= BLOCK_ERROR;
2145
2460
        keycache->key_cache_block_size.
2146
2461
      */
2147
2462
    }
 
2463
    KEYCACHE_DBUG_PRINT("read_block",
 
2464
                        ("primary request: new page in cache"));
2148
2465
    /* Signal that all pending requests for this page now can be processed */
2149
2466
    release_whole_queue(&block->wqueue[COND_FOR_REQUESTED]);
2150
2467
  }
2159
2476
      for the requested file block nor the file and position. So we have
2160
2477
      to assert this in the caller.
2161
2478
    */
 
2479
    KEYCACHE_DBUG_PRINT("read_block",
 
2480
                      ("secondary request waiting for new page to be read"));
2162
2481
    wait_on_queue(&block->wqueue[COND_FOR_REQUESTED], &keycache->cache_lock);
 
2482
    KEYCACHE_DBUG_PRINT("read_block",
 
2483
                        ("secondary request: new page in cache"));
2163
2484
  }
2164
2485
}
2165
2486
 
2186
2507
    The function ensures that a block of data of size length from file
2187
2508
    positioned at filepos is in the buffers for some key cache blocks.
2188
2509
    Then the function either copies the data into the buffer buff, or,
2189
 
    if return_buffer is true, it just returns the pointer to the key cache
 
2510
    if return_buffer is TRUE, it just returns the pointer to the key cache
2190
2511
    buffer with the data.
2191
2512
    Filepos must be a multiple of 'block_length', but it doesn't
2192
2513
    have to be a multiple of key_cache_block_size;
2193
2514
*/
2194
2515
 
2195
 
unsigned char *key_cache_read(KEY_CACHE *keycache,
2196
 
                      int file, my_off_t filepos, int level,
2197
 
                      unsigned char *buff, uint32_t length,
2198
 
                      uint32_t block_length,
2199
 
                      int return_buffer)
 
2516
uchar *key_cache_read(KEY_CACHE *keycache,
 
2517
                      File file, my_off_t filepos, int level,
 
2518
                      uchar *buff, uint length,
 
2519
                      uint block_length __attribute__((unused)),
 
2520
                      int return_buffer __attribute__((unused)))
2200
2521
{
2201
 
  (void)block_length;
2202
 
  (void)return_buffer;
2203
 
  bool locked_and_incremented= false;
 
2522
  my_bool locked_and_incremented= FALSE;
2204
2523
  int error=0;
2205
 
  unsigned char *start= buff;
 
2524
  uchar *start= buff;
 
2525
  DBUG_ENTER("key_cache_read");
 
2526
  DBUG_PRINT("enter", ("fd: %u  pos: %lu  length: %u",
 
2527
               (uint) file, (ulong) filepos, length));
2206
2528
 
2207
2529
  if (keycache->key_cache_inited)
2208
2530
  {
2209
2531
    /* Key cache is used */
2210
2532
    register BLOCK_LINK *block;
2211
 
    uint32_t read_length;
2212
 
    uint32_t offset;
2213
 
    uint32_t status;
 
2533
    uint read_length;
 
2534
    uint offset;
 
2535
    uint status;
2214
2536
    int page_st;
2215
2537
 
2216
2538
    /*
2238
2560
      wait_on_queue(&keycache->resize_queue, &keycache->cache_lock);
2239
2561
    /* Register the I/O for the next resize. */
2240
2562
    inc_counter_for_resize_op(keycache);
2241
 
    locked_and_incremented= true;
 
2563
    locked_and_incremented= TRUE;
2242
2564
    /* Requested data may not always be aligned to cache blocks. */
2243
2565
    offset= (uint) (filepos % keycache->key_cache_block_size);
2244
2566
    /* Read data in key_cache_block_size increments */
2253
2575
      /* Do not read beyond the end of the cache block. */
2254
2576
      read_length= length;
2255
2577
      set_if_smaller(read_length, keycache->key_cache_block_size-offset);
2256
 
      assert(read_length > 0);
 
2578
      KEYCACHE_DBUG_ASSERT(read_length > 0);
 
2579
 
 
2580
#ifndef THREAD
 
2581
      if (block_length > keycache->key_cache_block_size || offset)
 
2582
        return_buffer=0;
 
2583
#endif
2257
2584
 
2258
2585
      /* Request the cache block that matches file/pos. */
2259
2586
      keycache->global_cache_r_requests++;
2267
2594
        */
2268
2595
        keycache->global_cache_read++;
2269
2596
        keycache_pthread_mutex_unlock(&keycache->cache_lock);
2270
 
        error= (pread(file, (unsigned char*) buff, read_length, filepos + offset) == 0);
 
2597
        error= (my_pread(file, (uchar*) buff, read_length,
 
2598
                         filepos + offset, MYF(MY_NABP)) != 0);
2271
2599
        keycache_pthread_mutex_lock(&keycache->cache_lock);
2272
2600
        goto next_block;
2273
2601
      }
2278
2606
          /* The requested page is to be read into the block buffer */
2279
2607
          read_block(keycache, block,
2280
2608
                     keycache->key_cache_block_size, read_length+offset,
2281
 
                     (bool)(page_st == PAGE_TO_BE_READ));
 
2609
                     (my_bool)(page_st == PAGE_TO_BE_READ));
2282
2610
          /*
2283
2611
            A secondary request must now have the block assigned to the
2284
2612
            requested file block. It does not hurt to check it for
2285
2613
            primary requests too.
2286
2614
          */
2287
 
          assert(keycache->can_be_used);
2288
 
          assert(block->hash_link->file == file);
2289
 
          assert(block->hash_link->diskpos == filepos);
2290
 
          assert(block->status & (BLOCK_READ | BLOCK_IN_USE));
 
2615
          DBUG_ASSERT(keycache->can_be_used);
 
2616
          DBUG_ASSERT(block->hash_link->file == file);
 
2617
          DBUG_ASSERT(block->hash_link->diskpos == filepos);
 
2618
          DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
2291
2619
        }
2292
2620
        else if (block->length < read_length + offset)
2293
2621
        {
2296
2624
            this could only happen if we are using a file with
2297
2625
            small key blocks and are trying to read outside the file
2298
2626
          */
2299
 
          errno= -1;
 
2627
          my_errno= -1;
2300
2628
          block->status|= BLOCK_ERROR;
2301
2629
        }
2302
2630
      }
2304
2632
      /* block status may have added BLOCK_ERROR in the above 'if'. */
2305
2633
      if (!((status= block->status) & BLOCK_ERROR))
2306
2634
      {
 
2635
#ifndef THREAD
 
2636
        if (! return_buffer)
 
2637
#endif
2307
2638
        {
2308
 
          assert(block->status & (BLOCK_READ | BLOCK_IN_USE));
 
2639
          DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
2309
2640
#if !defined(SERIALIZED_READ_FROM_CACHE)
2310
2641
          keycache_pthread_mutex_unlock(&keycache->cache_lock);
2311
2642
#endif
2312
2643
 
2313
2644
          /* Copy data from the cache buffer */
2314
 
          memcpy(buff, block->buffer+offset, (size_t) read_length);
 
2645
          if (!(read_length & 511))
 
2646
            bmove512(buff, block->buffer+offset, read_length);
 
2647
          else
 
2648
            memcpy(buff, block->buffer+offset, (size_t) read_length);
2315
2649
 
2316
2650
#if !defined(SERIALIZED_READ_FROM_CACHE)
2317
2651
          keycache_pthread_mutex_lock(&keycache->cache_lock);
2318
 
          assert(block->status & (BLOCK_READ | BLOCK_IN_USE));
 
2652
          DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
2319
2653
#endif
2320
2654
        }
2321
2655
      }
2334
2668
        break;
2335
2669
      }
2336
2670
 
 
2671
#ifndef THREAD
 
2672
      /* This is only true if we where able to read everything in one block */
 
2673
      if (return_buffer)
 
2674
        DBUG_RETURN(block->buffer);
 
2675
#endif
2337
2676
  next_block:
2338
2677
      buff+= read_length;
2339
2678
      filepos+= read_length+offset;
2351
2690
 
2352
2691
  if (locked_and_incremented)
2353
2692
    keycache_pthread_mutex_unlock(&keycache->cache_lock);
2354
 
  if (!pread(file, (unsigned char*) buff, length, filepos))
 
2693
  if (my_pread(file, (uchar*) buff, length, filepos, MYF(MY_NABP)))
2355
2694
    error= 1;
2356
2695
  if (locked_and_incremented)
2357
2696
    keycache_pthread_mutex_lock(&keycache->cache_lock);
2362
2701
    dec_counter_for_resize_op(keycache);
2363
2702
    keycache_pthread_mutex_unlock(&keycache->cache_lock);
2364
2703
  }
2365
 
  return(error ? (unsigned char*) 0 : start);
 
2704
  DBUG_RETURN(error ? (uchar*) 0 : start);
2366
2705
}
2367
2706
 
2368
2707
 
2387
2726
*/
2388
2727
 
2389
2728
int key_cache_insert(KEY_CACHE *keycache,
2390
 
                     int file, my_off_t filepos, int level,
2391
 
                     unsigned char *buff, uint32_t length)
 
2729
                     File file, my_off_t filepos, int level,
 
2730
                     uchar *buff, uint length)
2392
2731
{
2393
2732
  int error= 0;
 
2733
  DBUG_ENTER("key_cache_insert");
 
2734
  DBUG_PRINT("enter", ("fd: %u  pos: %lu  length: %u",
 
2735
               (uint) file,(ulong) filepos, length));
2394
2736
 
2395
2737
  if (keycache->key_cache_inited)
2396
2738
  {
2397
2739
    /* Key cache is used */
2398
2740
    register BLOCK_LINK *block;
2399
 
    uint32_t read_length;
2400
 
    uint32_t offset;
 
2741
    uint read_length;
 
2742
    uint offset;
2401
2743
    int page_st;
2402
 
    bool locked_and_incremented= false;
 
2744
    my_bool locked_and_incremented= FALSE;
2403
2745
 
2404
2746
    /*
2405
2747
      When the keycache is once initialized, we use the cache_lock to
2416
2758
        goto no_key_cache;
2417
2759
    /* Register the pseudo I/O for the next resize. */
2418
2760
    inc_counter_for_resize_op(keycache);
2419
 
    locked_and_incremented= true;
 
2761
    locked_and_incremented= TRUE;
2420
2762
    /* Loaded data may not always be aligned to cache blocks. */
2421
2763
    offset= (uint) (filepos % keycache->key_cache_block_size);
2422
2764
    /* Load data in key_cache_block_size increments. */
2430
2772
      /* Do not load beyond the end of the cache block. */
2431
2773
      read_length= length;
2432
2774
      set_if_smaller(read_length, keycache->key_cache_block_size-offset);
2433
 
      assert(read_length > 0);
 
2775
      KEYCACHE_DBUG_ASSERT(read_length > 0);
2434
2776
 
2435
2777
      /* The block has been read by the caller already. */
2436
2778
      keycache->global_cache_read++;
2461
2803
            hash_link). So we cannot call remove_reader() on the block.
2462
2804
            And we cannot access the hash_link directly here. We need to
2463
2805
            wait until the assignment is complete. read_block() executes
2464
 
            the correct wait when called with primary == false.
 
2806
            the correct wait when called with primary == FALSE.
2465
2807
 
2466
2808
            Or
2467
2809
 
2486
2828
            requested file block. It does not hurt to check it for
2487
2829
            primary requests too.
2488
2830
          */
2489
 
          assert(keycache->can_be_used);
2490
 
          assert(block->hash_link->file == file);
2491
 
          assert(block->hash_link->diskpos == filepos);
2492
 
          assert(block->status & (BLOCK_READ | BLOCK_IN_USE));
 
2831
          DBUG_ASSERT(keycache->can_be_used);
 
2832
          DBUG_ASSERT(block->hash_link->file == file);
 
2833
          DBUG_ASSERT(block->hash_link->diskpos == filepos);
 
2834
          DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
2493
2835
        }
2494
2836
        else if (page_st == PAGE_TO_BE_READ)
2495
2837
        {
2497
2839
            This is a new block in the cache. If we come here, we have
2498
2840
            data for the whole block.
2499
2841
          */
2500
 
          assert(block->hash_link->requests);
2501
 
          assert(block->status & BLOCK_IN_USE);
2502
 
          assert((page_st == PAGE_TO_BE_READ) ||
 
2842
          DBUG_ASSERT(block->hash_link->requests);
 
2843
          DBUG_ASSERT(block->status & BLOCK_IN_USE);
 
2844
          DBUG_ASSERT((page_st == PAGE_TO_BE_READ) ||
2503
2845
                      (block->status & BLOCK_READ));
2504
2846
 
2505
2847
#if !defined(SERIALIZED_READ_FROM_CACHE)
2511
2853
#endif
2512
2854
 
2513
2855
          /* Copy data from buff */
2514
 
          memcpy(block->buffer+offset, buff, (size_t) read_length);
 
2856
          if (!(read_length & 511))
 
2857
            bmove512(block->buffer+offset, buff, read_length);
 
2858
          else
 
2859
            memcpy(block->buffer+offset, buff, (size_t) read_length);
2515
2860
 
2516
2861
#if !defined(SERIALIZED_READ_FROM_CACHE)
2517
2862
          keycache_pthread_mutex_lock(&keycache->cache_lock);
2518
 
          assert(block->status & BLOCK_IN_USE);
2519
 
          assert((page_st == PAGE_TO_BE_READ) ||
 
2863
          DBUG_ASSERT(block->status & BLOCK_IN_USE);
 
2864
          DBUG_ASSERT((page_st == PAGE_TO_BE_READ) ||
2520
2865
                      (block->status & BLOCK_READ));
2521
2866
#endif
2522
2867
          /*
2533
2878
            only a writer may set block->offset down from
2534
2879
            keycache->key_cache_block_size.
2535
2880
          */
 
2881
          KEYCACHE_DBUG_PRINT("key_cache_insert",
 
2882
                              ("primary request: new page in cache"));
2536
2883
          /* Signal all pending requests. */
2537
2884
          release_whole_queue(&block->wqueue[COND_FOR_REQUESTED]);
2538
2885
        }
2548
2895
            with the new data. If the condition is met, we can simply
2549
2896
            ignore the block.
2550
2897
          */
2551
 
          assert((page_st == PAGE_READ) &&
 
2898
          DBUG_ASSERT((page_st == PAGE_READ) &&
2552
2899
                      (read_length + offset <= block->length));
2553
2900
        }
2554
2901
 
2557
2904
          requested file block. It does not hurt to check it for primary
2558
2905
          requests too.
2559
2906
        */
2560
 
        assert(block->hash_link->file == file);
2561
 
        assert(block->hash_link->diskpos == filepos);
2562
 
        assert(block->status & (BLOCK_READ | BLOCK_IN_USE));
 
2907
        DBUG_ASSERT(block->hash_link->file == file);
 
2908
        DBUG_ASSERT(block->hash_link->diskpos == filepos);
 
2909
        DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
2563
2910
      } /* end of if (!(block->status & BLOCK_ERROR)) */
2564
2911
 
2565
2912
 
2587
2934
      dec_counter_for_resize_op(keycache);
2588
2935
    keycache_pthread_mutex_unlock(&keycache->cache_lock);
2589
2936
  }
2590
 
  return(error);
 
2937
  DBUG_RETURN(error);
2591
2938
}
2592
2939
 
2593
2940
 
2613
2960
    The function copies the data of size length from buff into buffers
2614
2961
    for key cache blocks that are  assigned to contain the portion of
2615
2962
    the file starting with position filepos.
2616
 
    It ensures that this data is flushed to the file if dont_write is false.
 
2963
    It ensures that this data is flushed to the file if dont_write is FALSE.
2617
2964
    Filepos must be a multiple of 'block_length', but it doesn't
2618
2965
    have to be a multiple of key_cache_block_size;
2619
2966
 
2620
 
    dont_write is always true in the server (info->lock_type is never F_UNLCK).
 
2967
    dont_write is always TRUE in the server (info->lock_type is never F_UNLCK).
2621
2968
*/
2622
2969
 
2623
2970
int key_cache_write(KEY_CACHE *keycache,
2624
 
                    int file, my_off_t filepos, int level,
2625
 
                    unsigned char *buff, uint32_t length,
2626
 
                    uint32_t block_length,
 
2971
                    File file, my_off_t filepos, int level,
 
2972
                    uchar *buff, uint length,
 
2973
                    uint block_length  __attribute__((unused)),
2627
2974
                    int dont_write)
2628
2975
{
2629
 
  (void)block_length;
2630
 
  bool locked_and_incremented= false;
 
2976
  my_bool locked_and_incremented= FALSE;
2631
2977
  int error=0;
 
2978
  DBUG_ENTER("key_cache_write");
 
2979
  DBUG_PRINT("enter",
 
2980
             ("fd: %u  pos: %lu  length: %u  block_length: %u"
 
2981
              "  key_block_length: %u",
 
2982
              (uint) file, (ulong) filepos, length, block_length,
 
2983
              keycache ? keycache->key_cache_block_size : 0));
2632
2984
 
2633
2985
  if (!dont_write)
2634
2986
  {
 
2987
    /* purecov: begin inspected */
2635
2988
    /* Not used in the server. */
2636
2989
    /* Force writing from buff into disk. */
2637
2990
    keycache->global_cache_w_requests++;
2638
2991
    keycache->global_cache_write++;
2639
 
    if (pwrite(file, buff, length, filepos) == 0)
2640
 
      return(1);
 
2992
    if (my_pwrite(file, buff, length, filepos, MYF(MY_NABP | MY_WAIT_IF_FULL)))
 
2993
      DBUG_RETURN(1);
 
2994
    /* purecov: end */
2641
2995
  }
2642
2996
 
 
2997
#if !defined(DBUG_OFF) && defined(EXTRA_DEBUG)
 
2998
  DBUG_EXECUTE("check_keycache",
 
2999
               test_key_cache(keycache, "start of key_cache_write", 1););
 
3000
#endif
 
3001
 
2643
3002
  if (keycache->key_cache_inited)
2644
3003
  {
2645
3004
    /* Key cache is used */
2646
3005
    register BLOCK_LINK *block;
2647
 
    uint32_t read_length;
2648
 
    uint32_t offset;
 
3006
    uint read_length;
 
3007
    uint offset;
2649
3008
    int page_st;
2650
3009
 
2651
3010
    /*
2674
3033
      wait_on_queue(&keycache->resize_queue, &keycache->cache_lock);
2675
3034
    /* Register the I/O for the next resize. */
2676
3035
    inc_counter_for_resize_op(keycache);
2677
 
    locked_and_incremented= true;
 
3036
    locked_and_incremented= TRUE;
2678
3037
    /* Requested data may not always be aligned to cache blocks. */
2679
3038
    offset= (uint) (filepos % keycache->key_cache_block_size);
2680
3039
    /* Write data in key_cache_block_size increments. */
2688
3047
      /* Do not write beyond the end of the cache block. */
2689
3048
      read_length= length;
2690
3049
      set_if_smaller(read_length, keycache->key_cache_block_size-offset);
2691
 
      assert(read_length > 0);
 
3050
      KEYCACHE_DBUG_ASSERT(read_length > 0);
2692
3051
 
2693
3052
      /* Request the cache block that matches file/pos. */
2694
3053
      keycache->global_cache_w_requests++;
2705
3064
          /* Used in the server. */
2706
3065
          keycache->global_cache_write++;
2707
3066
          keycache_pthread_mutex_unlock(&keycache->cache_lock);
2708
 
          if (pwrite(file, (unsigned char*) buff, read_length, filepos + offset) == 0)
 
3067
          if (my_pwrite(file, (uchar*) buff, read_length, filepos + offset,
 
3068
                        MYF(MY_NABP | MY_WAIT_IF_FULL)))
2709
3069
            error=1;
2710
3070
          keycache_pthread_mutex_lock(&keycache->cache_lock);
2711
3071
        }
2740
3100
                   offset + read_length >= keycache->key_cache_block_size?
2741
3101
                   offset : keycache->key_cache_block_size,
2742
3102
                   offset, (page_st == PAGE_TO_BE_READ));
2743
 
        assert(keycache->can_be_used);
2744
 
        assert(block->status & (BLOCK_READ | BLOCK_IN_USE));
 
3103
        DBUG_ASSERT(keycache->can_be_used);
 
3104
        DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
2745
3105
        /*
2746
3106
          Prevent block from flushing and from being selected for to be
2747
3107
          freed. This must be set when we release the cache_lock.
2753
3113
        The block should always be assigned to the requested file block
2754
3114
        here. It need not be BLOCK_READ when overwriting the whole block.
2755
3115
      */
2756
 
      assert(block->hash_link->file == file);
2757
 
      assert(block->hash_link->diskpos == filepos);
2758
 
      assert(block->status & BLOCK_IN_USE);
2759
 
      assert((page_st == PAGE_TO_BE_READ) || (block->status & BLOCK_READ));
 
3116
      DBUG_ASSERT(block->hash_link->file == file);
 
3117
      DBUG_ASSERT(block->hash_link->diskpos == filepos);
 
3118
      DBUG_ASSERT(block->status & BLOCK_IN_USE);
 
3119
      DBUG_ASSERT((page_st == PAGE_TO_BE_READ) || (block->status & BLOCK_READ));
2760
3120
      /*
2761
3121
        The block to be written must not be marked BLOCK_REASSIGNED.
2762
3122
        Otherwise it could be freed in dirty state or reused without
2765
3125
        the flusher could clear BLOCK_CHANGED without flushing the
2766
3126
        new changes again.
2767
3127
      */
2768
 
      assert(!(block->status & BLOCK_REASSIGNED));
 
3128
      DBUG_ASSERT(!(block->status & BLOCK_REASSIGNED));
2769
3129
 
2770
3130
      while (block->status & BLOCK_IN_FLUSHWRITE)
2771
3131
      {
2779
3139
          another hash_link until we release our request on it.
2780
3140
        */
2781
3141
        wait_on_queue(&block->wqueue[COND_FOR_SAVED], &keycache->cache_lock);
2782
 
        assert(keycache->can_be_used);
2783
 
        assert(block->status & (BLOCK_READ | BLOCK_IN_USE));
 
3142
        DBUG_ASSERT(keycache->can_be_used);
 
3143
        DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
2784
3144
        /* Still must not be marked for free. */
2785
 
        assert(!(block->status & BLOCK_REASSIGNED));
2786
 
        assert(block->hash_link && (block->hash_link->block == block));
 
3145
        DBUG_ASSERT(!(block->status & BLOCK_REASSIGNED));
 
3146
        DBUG_ASSERT(block->hash_link && (block->hash_link->block == block));
2787
3147
      }
2788
3148
 
2789
3149
      /*
2800
3160
#if !defined(SERIALIZED_READ_FROM_CACHE)
2801
3161
        keycache_pthread_mutex_unlock(&keycache->cache_lock);
2802
3162
#endif
2803
 
        memcpy(block->buffer+offset, buff, (size_t) read_length);
 
3163
        if (!(read_length & 511))
 
3164
          bmove512(block->buffer+offset, buff, read_length);
 
3165
        else
 
3166
          memcpy(block->buffer+offset, buff, (size_t) read_length);
2804
3167
 
2805
3168
#if !defined(SERIALIZED_READ_FROM_CACHE)
2806
3169
        keycache_pthread_mutex_lock(&keycache->cache_lock);
2869
3232
    keycache->global_cache_write++;
2870
3233
    if (locked_and_incremented)
2871
3234
      keycache_pthread_mutex_unlock(&keycache->cache_lock);
2872
 
    if (pwrite(file, (unsigned char*) buff, length, filepos) == 0)
 
3235
    if (my_pwrite(file, (uchar*) buff, length, filepos,
 
3236
                  MYF(MY_NABP | MY_WAIT_IF_FULL)))
2873
3237
      error=1;
2874
3238
    if (locked_and_incremented)
2875
3239
      keycache_pthread_mutex_lock(&keycache->cache_lock);
2881
3245
    dec_counter_for_resize_op(keycache);
2882
3246
    keycache_pthread_mutex_unlock(&keycache->cache_lock);
2883
3247
  }
2884
 
  return(error);
 
3248
#if !defined(DBUG_OFF) && defined(EXTRA_DEBUG)
 
3249
  DBUG_EXECUTE("exec",
 
3250
               test_key_cache(keycache, "end of key_cache_write", 1););
 
3251
#endif
 
3252
  DBUG_RETURN(error);
2885
3253
}
2886
3254
 
2887
3255
 
2914
3282
 
2915
3283
static void free_block(KEY_CACHE *keycache, BLOCK_LINK *block)
2916
3284
{
 
3285
  KEYCACHE_THREAD_TRACE("free block");
 
3286
  KEYCACHE_DBUG_PRINT("free_block",
 
3287
                      ("block %u to be freed, hash_link %p",
 
3288
                       BLOCK_NUMBER(block), block->hash_link));
2917
3289
  /*
2918
3290
    Assert that the block is not free already. And that it is in a clean
2919
3291
    state. Note that the block might just be assigned to a hash_link and
2921
3293
    is registered in the hash_link and free_block() will wait for it
2922
3294
    below.
2923
3295
  */
2924
 
  assert((block->status & BLOCK_IN_USE) &&
 
3296
  DBUG_ASSERT((block->status & BLOCK_IN_USE) &&
2925
3297
              !(block->status & (BLOCK_IN_EVICTION | BLOCK_IN_SWITCH |
2926
3298
                                 BLOCK_REASSIGNED | BLOCK_IN_FLUSH |
2927
3299
                                 BLOCK_CHANGED | BLOCK_FOR_UPDATE)));
2928
3300
  /* Assert that the block is in a file_blocks chain. */
2929
 
  assert(block->prev_changed && *block->prev_changed == block);
 
3301
  DBUG_ASSERT(block->prev_changed && *block->prev_changed == block);
2930
3302
  /* Assert that the block is not in the LRU ring. */
2931
 
  assert(!block->next_used && !block->prev_used);
 
3303
  DBUG_ASSERT(!block->next_used && !block->prev_used);
2932
3304
  /*
2933
3305
    IMHO the below condition (if()) makes no sense. I can't see how it
2934
3306
    could be possible that free_block() is entered with a NULL hash_link
2935
3307
    pointer. The only place where it can become NULL is in free_block()
2936
3308
    (or before its first use ever, but for those blocks free_block() is
2937
3309
    not called). I don't remove the conditional as it cannot harm, but
2938
 
    place an assert to confirm my hypothesis. Eventually the
 
3310
    place an DBUG_ASSERT to confirm my hypothesis. Eventually the
2939
3311
    condition (if()) can be removed.
2940
3312
  */
2941
 
  assert(block->hash_link && block->hash_link->block == block);
 
3313
  DBUG_ASSERT(block->hash_link && block->hash_link->block == block);
2942
3314
  if (block->hash_link)
2943
3315
  {
2944
3316
    /*
2954
3326
      checks. An additional requirement is that it must be read now
2955
3327
      (BLOCK_READ).
2956
3328
    */
2957
 
    assert(block->hash_link && block->hash_link->block == block);
2958
 
    assert((block->status & (BLOCK_READ | BLOCK_IN_USE |
 
3329
    DBUG_ASSERT(block->hash_link && block->hash_link->block == block);
 
3330
    DBUG_ASSERT((block->status & (BLOCK_READ | BLOCK_IN_USE |
2959
3331
                                  BLOCK_REASSIGNED)) &&
2960
3332
                !(block->status & (BLOCK_IN_EVICTION | BLOCK_IN_SWITCH |
2961
3333
                                   BLOCK_IN_FLUSH | BLOCK_CHANGED |
2962
3334
                                   BLOCK_FOR_UPDATE)));
2963
 
    assert(block->prev_changed && *block->prev_changed == block);
2964
 
    assert(!block->prev_used);
 
3335
    DBUG_ASSERT(block->prev_changed && *block->prev_changed == block);
 
3336
    DBUG_ASSERT(!block->prev_used);
2965
3337
    /*
2966
3338
      Unset BLOCK_REASSIGNED again. If we hand the block to an evicting
2967
3339
      thread (through unreg_request() below), other threads must not see
2984
3356
    operation in this case. Assert that there are no other requests
2985
3357
    registered.
2986
3358
  */
2987
 
  assert(block->requests == 1);
 
3359
  DBUG_ASSERT(block->requests == 1);
2988
3360
  unreg_request(keycache, block, 0);
2989
3361
  /*
2990
3362
    Note that even without releasing the cache lock it is possible that
2996
3368
    return;
2997
3369
 
2998
3370
  /* Here the block must be in the LRU ring. Unlink it again. */
2999
 
  assert(block->next_used && block->prev_used &&
 
3371
  DBUG_ASSERT(block->next_used && block->prev_used &&
3000
3372
              *block->prev_used == block);
3001
3373
  unlink_block(keycache, block);
3002
3374
  if (block->temperature == BLOCK_WARM)
3013
3385
  block->status= 0;
3014
3386
  block->length= 0;
3015
3387
  block->offset= keycache->key_cache_block_size;
 
3388
  KEYCACHE_THREAD_TRACE("free block");
 
3389
  KEYCACHE_DBUG_PRINT("free_block", ("block is freed"));
3016
3390
 
3017
3391
  /* Enforced by unlink_changed(), but just to be sure. */
3018
 
  assert(!block->next_changed && !block->prev_changed);
 
3392
  DBUG_ASSERT(!block->next_changed && !block->prev_changed);
3019
3393
  /* Enforced by unlink_block(): not in LRU ring nor in free_block_list. */
3020
 
  assert(!block->next_used && !block->prev_used);
 
3394
  DBUG_ASSERT(!block->next_used && !block->prev_used);
3021
3395
  /* Insert the free block in the free list. */
3022
3396
  block->next_used= keycache->free_block_list;
3023
3397
  keycache->free_block_list= block;
3042
3416
*/
3043
3417
 
3044
3418
static int flush_cached_blocks(KEY_CACHE *keycache,
3045
 
                               int file, BLOCK_LINK **cache,
 
3419
                               File file, BLOCK_LINK **cache,
3046
3420
                               BLOCK_LINK **end,
3047
3421
                               enum flush_type type)
3048
3422
{
3049
3423
  int error;
3050
3424
  int last_errno= 0;
3051
 
  uint32_t count= (uint) (end-cache);
 
3425
  uint count= (uint) (end-cache);
3052
3426
 
3053
3427
  /* Don't lock the cache during the flush */
3054
3428
  keycache_pthread_mutex_unlock(&keycache->cache_lock);
3056
3430
     As all blocks referred in 'cache' are marked by BLOCK_IN_FLUSH
3057
3431
     we are guarunteed no thread will change them
3058
3432
  */
3059
 
  my_qsort((unsigned char*) cache, count, sizeof(*cache), (qsort_cmp) cmp_sec_link);
 
3433
  my_qsort((uchar*) cache, count, sizeof(*cache), (qsort_cmp) cmp_sec_link);
3060
3434
 
3061
3435
  keycache_pthread_mutex_lock(&keycache->cache_lock);
3062
3436
  /*
3067
3441
  for ( ; cache != end ; cache++)
3068
3442
  {
3069
3443
    BLOCK_LINK *block= *cache;
 
3444
 
 
3445
    KEYCACHE_DBUG_PRINT("flush_cached_blocks",
 
3446
                        ("block %u to be flushed", BLOCK_NUMBER(block)));
3070
3447
    /*
3071
3448
      If the block contents is going to be changed, we abandon the flush
3072
3449
      for this block. flush_key_blocks_int() will restart its search and
3075
3452
    if (!(block->status & BLOCK_FOR_UPDATE))
3076
3453
    {
3077
3454
      /* Blocks coming here must have a certain status. */
3078
 
      assert(block->hash_link);
3079
 
      assert(block->hash_link->block == block);
3080
 
      assert(block->hash_link->file == file);
3081
 
      assert((block->status & ~BLOCK_IN_EVICTION) ==
 
3455
      DBUG_ASSERT(block->hash_link);
 
3456
      DBUG_ASSERT(block->hash_link->block == block);
 
3457
      DBUG_ASSERT(block->hash_link->file == file);
 
3458
      DBUG_ASSERT((block->status & ~BLOCK_IN_EVICTION) ==
3082
3459
                  (BLOCK_READ | BLOCK_IN_FLUSH | BLOCK_CHANGED | BLOCK_IN_USE));
3083
3460
      block->status|= BLOCK_IN_FLUSHWRITE;
3084
3461
      keycache_pthread_mutex_unlock(&keycache->cache_lock);
3085
 
      error= (pwrite(file,
3086
 
                     block->buffer+block->offset,
3087
 
                     block->length - block->offset,
3088
 
                     block->hash_link->diskpos+ block->offset) == 0);
 
3462
      error= my_pwrite(file,
 
3463
                       block->buffer+block->offset,
 
3464
                       block->length - block->offset,
 
3465
                       block->hash_link->diskpos+ block->offset,
 
3466
                       MYF(MY_NABP | MY_WAIT_IF_FULL));
3089
3467
      keycache_pthread_mutex_lock(&keycache->cache_lock);
3090
3468
      keycache->global_cache_write++;
3091
3469
      if (error)
3096
3474
      }
3097
3475
      block->status&= ~BLOCK_IN_FLUSHWRITE;
3098
3476
      /* Block must not have changed status except BLOCK_FOR_UPDATE. */
3099
 
      assert(block->hash_link);
3100
 
      assert(block->hash_link->block == block);
3101
 
      assert(block->hash_link->file == file);
3102
 
      assert((block->status & ~(BLOCK_FOR_UPDATE | BLOCK_IN_EVICTION)) ==
 
3477
      DBUG_ASSERT(block->hash_link);
 
3478
      DBUG_ASSERT(block->hash_link->block == block);
 
3479
      DBUG_ASSERT(block->hash_link->file == file);
 
3480
      DBUG_ASSERT((block->status & ~(BLOCK_FOR_UPDATE | BLOCK_IN_EVICTION)) ==
3103
3481
                  (BLOCK_READ | BLOCK_IN_FLUSH | BLOCK_CHANGED | BLOCK_IN_USE));
3104
3482
      /*
3105
3483
        Set correct status and link in right queue for free or later use.
3168
3546
*/
3169
3547
 
3170
3548
static int flush_key_blocks_int(KEY_CACHE *keycache,
3171
 
                                int file, enum flush_type type)
 
3549
                                File file, enum flush_type type)
3172
3550
{
3173
3551
  BLOCK_LINK *cache_buff[FLUSH_CACHE],**cache;
3174
3552
  int last_errno= 0;
3175
3553
  int last_errcnt= 0;
 
3554
  DBUG_ENTER("flush_key_blocks_int");
 
3555
  DBUG_PRINT("enter",("file: %d  blocks_used: %lu  blocks_changed: %lu",
 
3556
              file, keycache->blocks_used, keycache->blocks_changed));
 
3557
 
 
3558
#if !defined(DBUG_OFF) && defined(EXTRA_DEBUG)
 
3559
    DBUG_EXECUTE("check_keycache",
 
3560
                 test_key_cache(keycache, "start of flush_key_blocks", 0););
 
3561
#endif
3176
3562
 
3177
3563
  cache= cache_buff;
3178
3564
  if (keycache->disk_blocks > 0 &&
3180
3566
  {
3181
3567
    /* Key cache exists and flush is not disabled */
3182
3568
    int error= 0;
3183
 
    uint32_t count= FLUSH_CACHE;
 
3569
    uint count= FLUSH_CACHE;
3184
3570
    BLOCK_LINK **pos,**end;
3185
3571
    BLOCK_LINK *first_in_switch= NULL;
3186
3572
    BLOCK_LINK *last_in_flush;
3187
3573
    BLOCK_LINK *last_for_update;
3188
 
    BLOCK_LINK *last_in_switch;
3189
3574
    BLOCK_LINK *block, *next;
 
3575
#if defined(KEYCACHE_DEBUG)
 
3576
    uint cnt=0;
 
3577
#endif
3190
3578
 
3191
3579
    if (type != FLUSH_IGNORE_CHANGED)
3192
3580
    {
3203
3591
            !(block->status & BLOCK_IN_FLUSH))
3204
3592
        {
3205
3593
          count++;
3206
 
          assert(count<= keycache->blocks_used);
 
3594
          KEYCACHE_DBUG_ASSERT(count<= keycache->blocks_used);
3207
3595
        }
3208
3596
      }
3209
3597
      /*
3212
3600
        changed blocks appear while we need to wait for something.
3213
3601
      */
3214
3602
      if ((count > FLUSH_CACHE) &&
3215
 
          !(cache= (BLOCK_LINK**) malloc(sizeof(BLOCK_LINK*)*count)))
 
3603
          !(cache= (BLOCK_LINK**) my_malloc(sizeof(BLOCK_LINK*)*count,
 
3604
                                            MYF(0))))
3216
3605
        cache= cache_buff;
3217
3606
      /*
3218
3607
        After a restart there could be more changed blocks than now.
3231
3620
         block ;
3232
3621
         block= next)
3233
3622
    {
 
3623
#if defined(KEYCACHE_DEBUG)
 
3624
      cnt++;
 
3625
      KEYCACHE_DBUG_ASSERT(cnt <= keycache->blocks_used);
 
3626
#endif
3234
3627
      next= block->next_changed;
3235
3628
      if (block->hash_link->file == file)
3236
3629
      {
3294
3687
            else
3295
3688
            {
3296
3689
              /* It's a temporary file */
3297
 
              assert(!(block->status & BLOCK_REASSIGNED));
 
3690
              DBUG_ASSERT(!(block->status & BLOCK_REASSIGNED));
3298
3691
 
3299
3692
              /*
3300
3693
                free_block() must not be called with BLOCK_CHANGED. Note
3415
3808
    */
3416
3809
    while (first_in_switch)
3417
3810
    {
 
3811
#if defined(KEYCACHE_DEBUG)
 
3812
      cnt= 0;
 
3813
#endif
3418
3814
      wait_on_queue(&first_in_switch->wqueue[COND_FOR_SAVED],
3419
3815
                    &keycache->cache_lock);
 
3816
#if defined(KEYCACHE_DEBUG)
 
3817
      cnt++;
 
3818
      KEYCACHE_DBUG_ASSERT(cnt <= keycache->blocks_used);
 
3819
#endif
3420
3820
      /*
3421
3821
        Do not restart here. We have flushed all blocks that were
3422
3822
        changed when entering this function and were not marked for
3427
3827
 
3428
3828
    if (! (type == FLUSH_KEEP || type == FLUSH_FORCE_WRITE))
3429
3829
    {
3430
 
      last_for_update= NULL;
3431
 
      last_in_switch= NULL;
3432
 
      uint32_t total_found= 0;
3433
 
      uint32_t found;
 
3830
      BLOCK_LINK *last_for_update= NULL;
 
3831
      BLOCK_LINK *last_in_switch= NULL;
 
3832
      uint total_found= 0;
 
3833
      uint found;
3434
3834
 
3435
3835
      /*
3436
3836
        Finally free all clean blocks for this file.
3447
3847
          next= block->next_changed;
3448
3848
 
3449
3849
          /* Changed blocks cannot appear in the file_blocks hash. */
3450
 
          assert(!(block->status & BLOCK_CHANGED));
 
3850
          DBUG_ASSERT(!(block->status & BLOCK_CHANGED));
3451
3851
          if (block->hash_link->file == file)
3452
3852
          {
3453
3853
            /* We must skip blocks that will be changed. */
3465
3865
            if (!(block->status & (BLOCK_IN_EVICTION | BLOCK_IN_SWITCH |
3466
3866
                                   BLOCK_REASSIGNED)))
3467
3867
            {
3468
 
              struct st_hash_link *next_hash_link= NULL;
3469
 
              my_off_t            next_diskpos= 0;
3470
 
              int                next_file= 0;
3471
 
              uint32_t                next_status= 0;
3472
 
              uint32_t                hash_requests= 0;
 
3868
              struct st_hash_link *next_hash_link;
 
3869
              my_off_t            next_diskpos;
 
3870
              File                next_file;
 
3871
              uint                next_status;
 
3872
              uint                hash_requests;
3473
3873
 
3474
3874
              total_found++;
3475
3875
              found++;
3476
 
              assert(found <= keycache->blocks_used);
 
3876
              KEYCACHE_DBUG_ASSERT(found <= keycache->blocks_used);
3477
3877
 
3478
3878
              /*
3479
3879
                Register a request. This unlinks the block from the LRU
3495
3895
                next_hash_link= next->hash_link;
3496
3896
                next_diskpos=   next_hash_link->diskpos;
3497
3897
                next_file=      next_hash_link->file;
3498
 
                assert(next == next_hash_link->block);
 
3898
                DBUG_ASSERT(next == next_hash_link->block);
3499
3899
              }
3500
3900
 
3501
3901
              free_block(keycache, block);
3542
3942
      if (last_for_update)
3543
3943
      {
3544
3944
        /* We did not wait. Block must not have changed status. */
3545
 
        assert(last_for_update->status & BLOCK_FOR_UPDATE);
 
3945
        DBUG_ASSERT(last_for_update->status & BLOCK_FOR_UPDATE);
3546
3946
        wait_on_queue(&last_for_update->wqueue[COND_FOR_REQUESTED],
3547
3947
                      &keycache->cache_lock);
3548
3948
        goto restart;
3555
3955
      if (last_in_switch)
3556
3956
      {
3557
3957
        /* We did not wait. Block must not have changed status. */
3558
 
        assert(last_in_switch->status & (BLOCK_IN_EVICTION |
 
3958
        DBUG_ASSERT(last_in_switch->status & (BLOCK_IN_EVICTION |
3559
3959
                                              BLOCK_IN_SWITCH |
3560
3960
                                              BLOCK_REASSIGNED));
3561
3961
        wait_on_queue(&last_in_switch->wqueue[COND_FOR_SAVED],
3567
3967
 
3568
3968
  } /* if (keycache->disk_blocks > 0 */
3569
3969
 
 
3970
#ifndef DBUG_OFF
 
3971
  DBUG_EXECUTE("check_keycache",
 
3972
               test_key_cache(keycache, "end of flush_key_blocks", 0););
 
3973
#endif
3570
3974
err:
3571
3975
  if (cache != cache_buff)
3572
 
    free((unsigned char*) cache);
 
3976
    my_free((uchar*) cache, MYF(0));
3573
3977
  if (last_errno)
3574
3978
    errno=last_errno;                /* Return first error */
3575
 
  return(last_errno != 0);
 
3979
  DBUG_RETURN(last_errno != 0);
3576
3980
}
3577
3981
 
3578
3982
 
3592
3996
*/
3593
3997
 
3594
3998
int flush_key_blocks(KEY_CACHE *keycache,
3595
 
                     int file, enum flush_type type)
 
3999
                     File file, enum flush_type type)
3596
4000
{
3597
4001
  int res= 0;
 
4002
  DBUG_ENTER("flush_key_blocks");
 
4003
  DBUG_PRINT("enter", ("keycache: 0x%lx", (long) keycache));
3598
4004
 
3599
4005
  if (!keycache->key_cache_inited)
3600
 
    return(0);
 
4006
    DBUG_RETURN(0);
3601
4007
 
3602
4008
  keycache_pthread_mutex_lock(&keycache->cache_lock);
3603
4009
  /* While waiting for lock, keycache could have been ended. */
3608
4014
    dec_counter_for_resize_op(keycache);
3609
4015
  }
3610
4016
  keycache_pthread_mutex_unlock(&keycache->cache_lock);
3611
 
  return(res);
 
4017
  DBUG_RETURN(res);
3612
4018
}
3613
4019
 
3614
4020
 
3647
4053
static int flush_all_key_blocks(KEY_CACHE *keycache)
3648
4054
{
3649
4055
  BLOCK_LINK    *block;
3650
 
  uint32_t          total_found;
3651
 
  uint32_t          found;
3652
 
  uint32_t          idx;
 
4056
  uint          total_found;
 
4057
  uint          found;
 
4058
  uint          idx;
 
4059
  DBUG_ENTER("flush_all_key_blocks");
3653
4060
 
3654
4061
  do
3655
4062
  {
3684
4091
          */
3685
4092
          if (flush_key_blocks_int(keycache, block->hash_link->file,
3686
4093
                                   FLUSH_FORCE_WRITE))
3687
 
            return(1);
 
4094
            DBUG_RETURN(1);
3688
4095
        }
3689
4096
      }
3690
4097
 
3718
4125
          found++;
3719
4126
          if (flush_key_blocks_int(keycache, block->hash_link->file,
3720
4127
                                   FLUSH_RELEASE))
3721
 
            return(1);
 
4128
            DBUG_RETURN(1);
3722
4129
        }
3723
4130
      }
3724
4131
 
3731
4138
      before the resize started (BLOCK_FOR_UPDATE). Re-check the hashes.
3732
4139
    */
3733
4140
  } while (total_found);
3734
 
  return(0);
 
4141
 
 
4142
#ifndef DBUG_OFF
 
4143
  /* Now there should not exist any block any more. */
 
4144
  for (idx= 0; idx < CHANGED_BLOCKS_HASH; idx++)
 
4145
  {
 
4146
    DBUG_ASSERT(!keycache->changed_blocks[idx]);
 
4147
    DBUG_ASSERT(!keycache->file_blocks[idx]);
 
4148
  }
 
4149
#endif
 
4150
 
 
4151
  DBUG_RETURN(0);
3735
4152
}
3736
4153
 
3737
4154
 
3740
4157
 
3741
4158
  SYNOPSIS
3742
4159
    reset_key_cache_counters()
 
4160
    name       the name of a key cache
 
4161
    key_cache  pointer to the key kache to be reset
3743
4162
 
3744
4163
  DESCRIPTION
3745
 
   This procedure is used by process_key_caches() to reset the key_cache.
 
4164
   This procedure is used by process_key_caches() to reset the counters of all
 
4165
   currently used key caches, both the default one and the named ones.
3746
4166
 
3747
4167
  RETURN
3748
4168
    0 on success (always because it can't fail)
3749
4169
*/
3750
4170
 
3751
 
void reset_key_cache_counters()
3752
 
{
3753
 
  dflt_key_cache->global_blocks_changed= 0;   /* Key_blocks_not_flushed */
3754
 
  dflt_key_cache->global_cache_r_requests= 0; /* Key_read_requests */
3755
 
  dflt_key_cache->global_cache_read= 0;       /* Key_reads */
3756
 
  dflt_key_cache->global_cache_w_requests= 0; /* Key_write_requests */
3757
 
  dflt_key_cache->global_cache_write= 0;      /* Key_writes */
3758
 
}
 
4171
int reset_key_cache_counters(const char *name __attribute__((unused)),
 
4172
                             KEY_CACHE *key_cache)
 
4173
{
 
4174
  DBUG_ENTER("reset_key_cache_counters");
 
4175
  if (!key_cache->key_cache_inited)
 
4176
  {
 
4177
    DBUG_PRINT("info", ("Key cache %s not initialized.", name));
 
4178
    DBUG_RETURN(0);
 
4179
  }
 
4180
  DBUG_PRINT("info", ("Resetting counters for key cache %s.", name));
 
4181
 
 
4182
  key_cache->global_blocks_changed= 0;   /* Key_blocks_not_flushed */
 
4183
  key_cache->global_cache_r_requests= 0; /* Key_read_requests */
 
4184
  key_cache->global_cache_read= 0;       /* Key_reads */
 
4185
  key_cache->global_cache_w_requests= 0; /* Key_write_requests */
 
4186
  key_cache->global_cache_write= 0;      /* Key_writes */
 
4187
  DBUG_RETURN(0);
 
4188
}
 
4189
 
 
4190
 
 
4191
#ifndef DBUG_OFF
 
4192
/*
 
4193
  Test if disk-cache is ok
 
4194
*/
 
4195
static void test_key_cache(KEY_CACHE *keycache __attribute__((unused)),
 
4196
                           const char *where __attribute__((unused)),
 
4197
                           my_bool lock __attribute__((unused)))
 
4198
{
 
4199
  /* TODO */
 
4200
}
 
4201
#endif
3759
4202
 
3760
4203
#if defined(KEYCACHE_TIMEOUT)
3761
4204
 
3762
 
 
3763
 
static inline
3764
 
unsigned int hash_link_number(HASH_LINK *hash_link, KEY_CACHE *keycache)
3765
 
{
3766
 
  return ((unsigned int) (((char*)hash_link-(char *) keycache->hash_link_root)/
3767
 
                  sizeof(HASH_LINK)));
3768
 
}
3769
 
 
3770
 
static inline
3771
 
unsigned int block_number(BLOCK_LINK *block, KEY_CACHE *keycache)
3772
 
{
3773
 
  return ((unsigned int) (((char*)block-(char *)keycache->block_root)/
3774
 
                  sizeof(BLOCK_LINK)));
3775
 
}
3776
 
 
3777
 
 
3778
4205
#define KEYCACHE_DUMP_FILE  "keycache_dump.txt"
3779
4206
#define MAX_QUEUE_LEN  100
3780
4207
 
3787
4214
  BLOCK_LINK *block;
3788
4215
  HASH_LINK *hash_link;
3789
4216
  KEYCACHE_PAGE *page;
3790
 
  uint32_t i;
 
4217
  uint i;
3791
4218
 
3792
4219
  fprintf(keycache_dump_file, "thread:%u\n", thread->id);
3793
4220
 
3801
4228
      page= (KEYCACHE_PAGE *) thread->opt_info;
3802
4229
      fprintf(keycache_dump_file,
3803
4230
              "thread:%u, (file,filepos)=(%u,%lu)\n",
3804
 
              thread->id,(uint) page->file,(uint32_t) page->filepos);
 
4231
              thread->id,(uint) page->file,(ulong) page->filepos);
3805
4232
      if (++i == MAX_QUEUE_LEN)
3806
4233
        break;
3807
4234
    }
3816
4243
      thread=thread->next;
3817
4244
      hash_link= (HASH_LINK *) thread->opt_info;
3818
4245
      fprintf(keycache_dump_file,
3819
 
              "thread:%u hash_link:%u (file,filepos)=(%u,%u)\n",
3820
 
              thread->id, (uint) hash_link_number(hash_link, keycache),
3821
 
              (uint) hash_link->file,(uint32_t) hash_link->diskpos);
 
4246
        "thread:%u hash_link:%u (file,filepos)=(%u,%lu)\n",
 
4247
        thread->id, (uint) HASH_LINK_NUMBER(hash_link),
 
4248
        (uint) hash_link->file,(ulong) hash_link->diskpos);
3822
4249
      if (++i == MAX_QUEUE_LEN)
3823
4250
        break;
3824
4251
    }
3830
4257
    block= &keycache->block_root[i];
3831
4258
    hash_link= block->hash_link;
3832
4259
    fprintf(keycache_dump_file,
3833
 
            "block:%u hash_link:%d status:%x #requests=%u "
3834
 
            "waiting_for_readers:%d\n",
3835
 
            i, (int) (hash_link ? hash_link_number(hash_link, keycache) : -1),
3836
 
            block->status, block->requests, block->condvar ? 1 : 0);
 
4260
            "block:%u hash_link:%d status:%x #requests=%u waiting_for_readers:%d\n",
 
4261
            i, (int) (hash_link ? HASH_LINK_NUMBER(hash_link) : -1),
 
4262
            block->status, block->requests, block->condvar ? 1 : 0);
3837
4263
    for (j=0 ; j < 2; j++)
3838
4264
    {
3839
4265
      KEYCACHE_WQUEUE *wqueue=&block->wqueue[j];
3861
4287
    {
3862
4288
      block= block->next_used;
3863
4289
      fprintf(keycache_dump_file,
3864
 
              "block:%u, ", block_number(block, keycache));
 
4290
              "block:%u, ", BLOCK_NUMBER(block));
3865
4291
    }
3866
4292
    while (block != keycache->used_last);
3867
4293
  }
3870
4296
  fclose(keycache_dump_file);
3871
4297
}
3872
4298
 
 
4299
#endif /* defined(KEYCACHE_TIMEOUT) */
 
4300
 
 
4301
#if defined(KEYCACHE_TIMEOUT)
 
4302
 
 
4303
 
3873
4304
static int keycache_pthread_cond_wait(pthread_cond_t *cond,
3874
4305
                                      pthread_mutex_t *mutex)
3875
4306
{
3877
4308
  struct timeval  now;            /* time when we started waiting        */
3878
4309
  struct timespec timeout;        /* timeout value for the wait function */
3879
4310
  struct timezone tz;
 
4311
#if defined(KEYCACHE_DEBUG)
 
4312
  int cnt=0;
 
4313
#endif
3880
4314
 
3881
4315
  /* Get current time */
3882
4316
  gettimeofday(&now, &tz);
3888
4322
   1 nanosecond = 1000 micro seconds
3889
4323
 */
3890
4324
  timeout.tv_nsec= now.tv_usec * 1000;
 
4325
  KEYCACHE_THREAD_TRACE_END("started waiting");
 
4326
#if defined(KEYCACHE_DEBUG)
 
4327
  cnt++;
 
4328
  if (cnt % 100 == 0)
 
4329
    fprintf(keycache_debug_log, "waiting...\n");
 
4330
    fflush(keycache_debug_log);
 
4331
#endif
3891
4332
  rc= pthread_cond_timedwait(cond, mutex, &timeout);
 
4333
  KEYCACHE_THREAD_TRACE_BEGIN("finished waiting");
3892
4334
  if (rc == ETIMEDOUT || rc == ETIME)
3893
4335
  {
 
4336
#if defined(KEYCACHE_DEBUG)
 
4337
    fprintf(keycache_debug_log,"aborted by keycache timeout\n");
 
4338
    fclose(keycache_debug_log);
 
4339
    abort();
 
4340
#endif
3894
4341
    keycache_dump();
3895
4342
  }
3896
4343
 
 
4344
#if defined(KEYCACHE_DEBUG)
 
4345
  KEYCACHE_DBUG_ASSERT(rc != ETIMEDOUT);
 
4346
#else
3897
4347
  assert(rc != ETIMEDOUT);
3898
 
  return rc;
3899
 
}
 
4348
#endif
 
4349
  return rc;
 
4350
}
 
4351
#else
 
4352
#if defined(KEYCACHE_DEBUG)
 
4353
static int keycache_pthread_cond_wait(pthread_cond_t *cond,
 
4354
                                      pthread_mutex_t *mutex)
 
4355
{
 
4356
  int rc;
 
4357
  KEYCACHE_THREAD_TRACE_END("started waiting");
 
4358
  rc= pthread_cond_wait(cond, mutex);
 
4359
  KEYCACHE_THREAD_TRACE_BEGIN("finished waiting");
 
4360
  return rc;
 
4361
}
 
4362
#endif
3900
4363
#endif /* defined(KEYCACHE_TIMEOUT) */
 
4364
 
 
4365
#if defined(KEYCACHE_DEBUG)
 
4366
 
 
4367
 
 
4368
static int keycache_pthread_mutex_lock(pthread_mutex_t *mutex)
 
4369
{
 
4370
  int rc;
 
4371
  rc= pthread_mutex_lock(mutex);
 
4372
  KEYCACHE_THREAD_TRACE_BEGIN("");
 
4373
  return rc;
 
4374
}
 
4375
 
 
4376
 
 
4377
static void keycache_pthread_mutex_unlock(pthread_mutex_t *mutex)
 
4378
{
 
4379
  KEYCACHE_THREAD_TRACE_END("");
 
4380
  pthread_mutex_unlock(mutex);
 
4381
}
 
4382
 
 
4383
 
 
4384
static int keycache_pthread_cond_signal(pthread_cond_t *cond)
 
4385
{
 
4386
  int rc;
 
4387
  KEYCACHE_THREAD_TRACE("signal");
 
4388
  rc= pthread_cond_signal(cond);
 
4389
  return rc;
 
4390
}
 
4391
 
 
4392
 
 
4393
#if defined(KEYCACHE_DEBUG_LOG)
 
4394
 
 
4395
 
 
4396
static void keycache_debug_print(const char * fmt,...)
 
4397
{
 
4398
  va_list args;
 
4399
  va_start(args,fmt);
 
4400
  if (keycache_debug_log)
 
4401
  {
 
4402
    VOID(vfprintf(keycache_debug_log, fmt, args));
 
4403
    VOID(fputc('\n',keycache_debug_log));
 
4404
  }
 
4405
  va_end(args);
 
4406
}
 
4407
#endif /* defined(KEYCACHE_DEBUG_LOG) */
 
4408
 
 
4409
#if defined(KEYCACHE_DEBUG_LOG)
 
4410
 
 
4411
 
 
4412
void keycache_debug_log_close(void)
 
4413
{
 
4414
  if (keycache_debug_log)
 
4415
    fclose(keycache_debug_log);
 
4416
}
 
4417
#endif /* defined(KEYCACHE_DEBUG_LOG) */
 
4418
 
 
4419
#endif /* defined(KEYCACHE_DEBUG) */
 
4420
 
 
4421
#if !defined(DBUG_OFF)
 
4422
#define F_B_PRT(_f_, _v_) DBUG_PRINT("assert_fail", (_f_, _v_))
 
4423
 
 
4424
static int fail_block(BLOCK_LINK *block)
 
4425
{
 
4426
  F_B_PRT("block->next_used:    %lx\n", (ulong) block->next_used);
 
4427
  F_B_PRT("block->prev_used:    %lx\n", (ulong) block->prev_used);
 
4428
  F_B_PRT("block->next_changed: %lx\n", (ulong) block->next_changed);
 
4429
  F_B_PRT("block->prev_changed: %lx\n", (ulong) block->prev_changed);
 
4430
  F_B_PRT("block->hash_link:    %lx\n", (ulong) block->hash_link);
 
4431
  F_B_PRT("block->status:       %u\n", block->status);
 
4432
  F_B_PRT("block->length:       %u\n", block->length);
 
4433
  F_B_PRT("block->offset:       %u\n", block->offset);
 
4434
  F_B_PRT("block->requests:     %u\n", block->requests);
 
4435
  F_B_PRT("block->temperature:  %u\n", block->temperature);
 
4436
  return 0; /* Let the assert fail. */
 
4437
}
 
4438
 
 
4439
static int fail_hlink(HASH_LINK *hlink)
 
4440
{
 
4441
  F_B_PRT("hlink->next:    %lx\n", (ulong) hlink->next);
 
4442
  F_B_PRT("hlink->prev:    %lx\n", (ulong) hlink->prev);
 
4443
  F_B_PRT("hlink->block:   %lx\n", (ulong) hlink->block);
 
4444
  F_B_PRT("hlink->diskpos: %lu\n", (ulong) hlink->diskpos);
 
4445
  F_B_PRT("hlink->file:    %d\n", hlink->file);
 
4446
  return 0; /* Let the assert fail. */
 
4447
}
 
4448
 
 
4449
static int cache_empty(KEY_CACHE *keycache)
 
4450
{
 
4451
  int errcnt= 0;
 
4452
  int idx;
 
4453
  if (keycache->disk_blocks <= 0)
 
4454
    return 1;
 
4455
  for (idx= 0; idx < keycache->disk_blocks; idx++)
 
4456
  {
 
4457
    BLOCK_LINK *block= keycache->block_root + idx;
 
4458
    if (block->status || block->requests || block->hash_link)
 
4459
    {
 
4460
      fprintf(stderr, "block index: %u\n", idx);
 
4461
      fail_block(block);
 
4462
      errcnt++;
 
4463
    }
 
4464
  }
 
4465
  for (idx= 0; idx < keycache->hash_links; idx++)
 
4466
  {
 
4467
    HASH_LINK *hash_link= keycache->hash_link_root + idx;
 
4468
    if (hash_link->requests || hash_link->block)
 
4469
    {
 
4470
      fprintf(stderr, "hash_link index: %u\n", idx);
 
4471
      fail_hlink(hash_link);
 
4472
      errcnt++;
 
4473
    }
 
4474
  }
 
4475
  if (errcnt)
 
4476
  {
 
4477
    fprintf(stderr, "blocks: %d  used: %lu\n",
 
4478
            keycache->disk_blocks, keycache->blocks_used);
 
4479
    fprintf(stderr, "hash_links: %d  used: %d\n",
 
4480
            keycache->hash_links, keycache->hash_links_used);
 
4481
    fprintf(stderr, "\n");
 
4482
  }
 
4483
  return !errcnt;
 
4484
}
 
4485
#endif
 
4486