← Back to branch summary

~ubuntu-branches/ubuntu/trusty/drizzle/trusty

« back to all changes in this revision

Viewing changes to plugin/myisam/mf_keycache.cc

  • Committer: Package Import Robot
  • Author(s): Clint Byrum
  • Date: 2012-06-19 10:46:49 UTC
  • mfrom: (1.1.6)
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20120619104649-e2l0ggd4oz3um0f4
Tags: upstream-7.1.36-stable
Import upstream version 7.1.36-stable

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/myisam/mf_keycache.cc
1
 
/* Copyright (C) 2000 MySQL AB
2
 
 
3
 
   This program is free software; you can redistribute it and/or modify
4
 
   it under the terms of the GNU General Public License as published by
5
 
   the Free Software Foundation; version 2 of the License.
6
 
 
7
 
   This program is distributed in the hope that it will be useful,
8
 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
9
 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10
 
   GNU General Public License for more details.
11
 
 
12
 
   You should have received a copy of the GNU General Public License
13
 
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
15
 
 
16
 
/*
17
 
  These functions handle keyblock cacheing for ISAM and MyISAM tables.
18
 
 
19
 
  One cache can handle many files.
20
 
  It must contain buffers of the same blocksize.
21
 
  init_key_cache() should be used to init cache handler.
22
 
 
23
 
  The free list (free_block_list) is a stack like structure.
24
 
  When a block is freed by free_block(), it is pushed onto the stack.
25
 
  When a new block is required it is first tried to pop one from the stack.
26
 
  If the stack is empty, it is tried to get a never-used block from the pool.
27
 
  If this is empty too, then a block is taken from the LRU ring, flushing it
28
 
  to disk, if neccessary. This is handled in find_key_block().
29
 
  With the new free list, the blocks can have three temperatures:
30
 
  hot, warm and cold (which is free). This is remembered in the block header
31
 
  by the enum BLOCK_TEMPERATURE temperature variable. Remembering the
32
 
  temperature is neccessary to correctly count the number of warm blocks,
33
 
  which is required to decide when blocks are allowed to become hot. Whenever
34
 
  a block is inserted to another (sub-)chain, we take the old and new
35
 
  temperature into account to decide if we got one more or less warm block.
36
 
  blocks_unused is the sum of never used blocks in the pool and of currently
37
 
  free blocks. blocks_used is the number of blocks fetched from the pool and
38
 
  as such gives the maximum number of in-use blocks at any time.
39
 
 
40
 
  Key Cache Locking
41
 
  =================
42
 
 
43
 
  All key cache locking is done with a single mutex per key cache:
44
 
  keycache->cache_lock. This mutex is locked almost all the time
45
 
  when executing code in this file (mf_keycache.c).
46
 
  However it is released for I/O and some copy operations.
47
 
 
48
 
  The cache_lock is also released when waiting for some event. Waiting
49
 
  and signalling is done via condition variables. In most cases the
50
 
  thread waits on its thread->suspend condition variable. Every thread
51
 
  has a my_thread_var structure, which contains this variable and a
52
 
  '*next' and '**prev' pointer. These pointers are used to insert the
53
 
  thread into a wait queue.
54
 
 
55
 
  A thread can wait for one block and thus be in one wait queue at a
56
 
  time only.
57
 
 
58
 
  Before starting to wait on its condition variable with
59
 
  pthread_cond_wait(), the thread enters itself to a specific wait queue
60
 
  with link_into_queue() (double linked with '*next' + '**prev') or
61
 
  wait_on_queue() (single linked with '*next').
62
 
 
63
 
  Another thread, when releasing a resource, looks up the waiting thread
64
 
  in the related wait queue. It sends a signal with
65
 
  pthread_cond_signal() to the waiting thread.
66
 
 
67
 
  NOTE: Depending on the particular wait situation, either the sending
68
 
  thread removes the waiting thread from the wait queue with
69
 
  unlink_from_queue() or release_whole_queue() respectively, or the waiting
70
 
  thread removes itself.
71
 
 
72
 
  There is one exception from this locking scheme when one thread wants
73
 
  to reuse a block for some other address. This works by first marking
74
 
  the block reserved (status= BLOCK_IN_SWITCH) and then waiting for all
75
 
  threads that are reading the block to finish. Each block has a
76
 
  reference to a condition variable (condvar). It holds a reference to
77
 
  the thread->suspend condition variable for the waiting thread (if such
78
 
  a thread exists). When that thread is signaled, the reference is
79
 
  cleared. The number of readers of a block is registered in
80
 
  block->hash_link->requests. See wait_for_readers() / remove_reader()
81
 
  for details. This is similar to the above, but it clearly means that
82
 
  only one thread can wait for a particular block. There is no queue in
83
 
  this case. Strangely enough block->convar is used for waiting for the
84
 
  assigned hash_link only. More precisely it is used to wait for all
85
 
  requests to be unregistered from the assigned hash_link.
86
 
 
87
 
  The resize_queue serves two purposes:
88
 
  1. Threads that want to do a resize wait there if in_resize is set.
89
 
     This is not used in the server. The server refuses a second resize
90
 
     request if one is already active. keycache->in_init is used for the
91
 
     synchronization. See set_var.cc.
92
 
  2. Threads that want to access blocks during resize wait here during
93
 
     the re-initialization phase.
94
 
  When the resize is done, all threads on the queue are signalled.
95
 
  Hypothetical resizers can compete for resizing, and read/write
96
 
  requests will restart to request blocks from the freshly resized
97
 
  cache. If the cache has been resized too small, it is disabled and
98
 
  'can_be_used' is false. In this case read/write requests bypass the
99
 
  cache. Since they increment and decrement 'cnt_for_resize_op', the
100
 
  next resizer can wait on the queue 'waiting_for_resize_cnt' until all
101
 
  I/O finished.
102
 
*/
103
 
 
104
 
#include <config.h>
105
 
#include <drizzled/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>
110
 
#include <errno.h>
111
 
#include <stdarg.h>
112
 
 
113
 
using namespace drizzled;
114
 
 
115
 
/*
116
 
  Some compilation flags have been added specifically for this module
117
 
  to control the following:
118
 
  - not to let a thread to yield the control when reading directly
119
 
    from key cache, which might improve performance in many cases;
120
 
    to enable this add:
121
 
    #define SERIALIZED_READ_FROM_CACHE
122
 
  - to set an upper bound for number of threads simultaneously
123
 
    using the key cache; this setting helps to determine an optimal
124
 
    size for hash table and improve performance when the number of
125
 
    blocks in the key cache much less than the number of threads
126
 
    accessing it;
127
 
    to set this number equal to <N> add
128
 
      #define MAX_THREADS <N>
129
 
 
130
 
  Example of the settings:
131
 
    #define SERIALIZED_READ_FROM_CACHE
132
 
    #define MAX_THREADS   100
133
 
*/
134
 
 
135
 
#define STRUCT_PTR(TYPE, MEMBER, a)                                           \
136
 
          (TYPE *) ((char *) (a) - offsetof(TYPE, MEMBER))
137
 
 
138
 
/* types of condition variables */
139
 
#define  COND_FOR_REQUESTED 0
140
 
#define  COND_FOR_SAVED     1
141
 
 
142
 
typedef pthread_cond_t KEYCACHE_CONDVAR;
143
 
 
144
 
/* descriptor of the page in the key cache block buffer */
145
 
struct st_keycache_page
146
 
{
147
 
  int file;               /* file to which the page belongs to  */
148
 
  internal::my_off_t filepos;       /* position of the page in the file   */
149
 
};
150
 
 
151
 
/* element in the chain of a hash table bucket */
152
 
struct st_hash_link
153
 
{
154
 
  struct st_hash_link *next, **prev; /* to connect links in the same bucket  */
155
 
  struct st_block_link *block;       /* reference to the block for the page: */
156
 
  int file;                         /* from such a file                     */
157
 
  internal::my_off_t diskpos;                  /* with such an offset                  */
158
 
  uint32_t requests;                     /* number of requests for the page      */
159
 
};
160
 
 
161
 
/* simple states of a block */
162
 
#define BLOCK_ERROR           1 /* an error occured when performing file i/o */
163
 
#define BLOCK_READ            2 /* file block is in the block buffer         */
164
 
#define BLOCK_IN_SWITCH       4 /* block is preparing to read new page       */
165
 
#define BLOCK_REASSIGNED      8 /* blk does not accept requests for old page */
166
 
#define BLOCK_IN_FLUSH       16 /* block is selected for flush               */
167
 
#define BLOCK_CHANGED        32 /* block buffer contains a dirty page        */
168
 
#define BLOCK_IN_USE         64 /* block is not free                         */
169
 
#define BLOCK_IN_EVICTION   128 /* block is selected for eviction            */
170
 
#define BLOCK_IN_FLUSHWRITE 256 /* block is in write to file                 */
171
 
#define BLOCK_FOR_UPDATE    512 /* block is selected for buffer modification */
172
 
 
173
 
/* page status, returned by find_key_block */
174
 
#define PAGE_READ               0
175
 
#define PAGE_TO_BE_READ         1
176
 
#define PAGE_WAIT_TO_BE_READ    2
177
 
 
178
 
/* block temperature determines in which (sub-)chain the block currently is */
179
 
enum BLOCK_TEMPERATURE { BLOCK_COLD /*free*/ , BLOCK_WARM , BLOCK_HOT };
180
 
 
181
 
/* key cache block */
182
 
struct st_block_link
183
 
{
184
 
  struct st_block_link
185
 
    *next_used, **prev_used;   /* to connect links in the LRU chain (ring)   */
186
 
  struct st_block_link
187
 
    *next_changed, **prev_changed; /* for lists of file dirty/clean blocks   */
188
 
  struct st_hash_link *hash_link; /* backward ptr to referring hash_link     */
189
 
  KEYCACHE_WQUEUE wqueue[2]; /* queues on waiting requests for new/old pages */
190
 
  uint32_t requests;          /* number of requests for the block                */
191
 
  unsigned char *buffer;           /* buffer for the block page                       */
192
 
  uint32_t offset;            /* beginning of modified data in the buffer        */
193
 
  uint32_t length;            /* end of data in the buffer                       */
194
 
  uint32_t status;            /* state of the block                              */
195
 
  enum BLOCK_TEMPERATURE temperature; /* block temperature: cold, warm, hot */
196
 
  uint32_t hits_left;         /* number of hits left until promotion             */
197
 
  uint64_t last_hit_time; /* timestamp of the last hit                      */
198
 
  KEYCACHE_CONDVAR *condvar; /* condition variable for 'no readers' event    */
199
 
};
200
 
 
201
 
#define FLUSH_CACHE         2000            /* sort this many blocks at once */
202
 
 
203
 
#define KEYCACHE_HASH(f, pos)                                                 \
204
 
(((uint32_t) ((pos) / keycache->key_cache_block_size) +                          \
205
 
                                     (uint32_t) (f)) & (keycache->hash_entries-1))
206
 
#define FILE_HASH(f)                 ((uint) (f) & (CHANGED_BLOCKS_HASH-1))
207
 
 
208
 
 
209
 
#define  keycache_pthread_cond_wait(A,B) (void)A;
210
 
#define keycache_pthread_mutex_lock(A) (void)A;
211
 
#define keycache_pthread_mutex_unlock(A) (void)A;
212
 
#define keycache_pthread_cond_signal(A) (void)A;
213
 
 
214
 
static inline uint32_t next_power(uint32_t value)
215
 
{
216
 
  return my_round_up_to_next_power(value) << 1;
217
 
}
218
 
 
219
 
 
220
 
/*
221
 
  Initialize a key cache
222
 
 
223
 
  SYNOPSIS
224
 
    init_key_cache()
225
 
    keycache                    pointer to a key cache data structure
226
 
    key_cache_block_size        size of blocks to keep cached data
227
 
    use_mem                     total memory to use for the key cache
228
 
    division_limit              division limit (may be zero)
229
 
    age_threshold               age threshold (may be zero)
230
 
 
231
 
  RETURN VALUE
232
 
    number of blocks in the key cache, if successful,
233
 
    0 - otherwise.
234
 
 
235
 
  NOTES.
236
 
    if keycache->key_cache_inited != 0 we assume that the key cache
237
 
    is already initialized.  This is for now used by myisamchk, but shouldn't
238
 
    be something that a program should rely on!
239
 
 
240
 
    It's assumed that no two threads call this function simultaneously
241
 
    referring to the same key cache handle.
242
 
 
243
 
*/
244
 
 
245
 
int init_key_cache(KEY_CACHE *keycache, uint32_t key_cache_block_size,
246
 
                   size_t use_mem, uint32_t division_limit,
247
 
                   uint32_t age_threshold)
248
 
{
249
 
  (void)keycache;
250
 
  (void)key_cache_block_size;
251
 
  (void)use_mem;
252
 
  (void)division_limit;
253
 
  (void)age_threshold;
254
 
  memset(keycache, 0, sizeof(KEY_CACHE));
255
 
  
256
 
  return 0;
257
 
}
258
 
 
259
 
 
260
 
/*
261
 
  Remove key_cache from memory
262
 
 
263
 
  SYNOPSIS
264
 
    end_key_cache()
265
 
    keycache            key cache handle
266
 
    cleanup             Complete free (Free also mutex for key cache)
267
 
 
268
 
  RETURN VALUE
269
 
    none
270
 
*/
271
 
 
272
 
void end_key_cache(KEY_CACHE *keycache, bool cleanup)
273
 
{
274
 
  (void)keycache;
275
 
  (void)cleanup;
276
 
} /* end_key_cache */
277
 
 
278
 
 
279
 
/*
280
 
  Add a hash link to a bucket in the hash_table
281
 
*/
282
 
 
283
 
static inline void link_hash(HASH_LINK **start, HASH_LINK *hash_link)
284
 
{
285
 
  if (*start)
286
 
    (*start)->prev= &hash_link->next;
287
 
  hash_link->next= *start;
288
 
  hash_link->prev= start;
289
 
  *start= hash_link;
290
 
}
291
 
 
292
 
 
293
 
/*
294
 
  Read a block of data from a cached file into a buffer;
295
 
 
296
 
  SYNOPSIS
297
 
 
298
 
    key_cache_read()
299
 
      keycache            pointer to a key cache data structure
300
 
      file                handler for the file for the block of data to be read
301
 
      filepos             position of the block of data in the file
302
 
      level               determines the weight of the data
303
 
      buff                buffer to where the data must be placed
304
 
      length              length of the buffer
305
 
      block_length        length of the block in the key cache buffer
306
 
      return_buffer       return pointer to the key cache buffer with the data
307
 
 
308
 
  RETURN VALUE
309
 
    Returns address from where the data is placed if sucessful, 0 - otherwise.
310
 
 
311
 
  NOTES.
312
 
    The function ensures that a block of data of size length from file
313
 
    positioned at filepos is in the buffers for some key cache blocks.
314
 
    Then the function either copies the data into the buffer buff, or,
315
 
    if return_buffer is true, it just returns the pointer to the key cache
316
 
    buffer with the data.
317
 
    Filepos must be a multiple of 'block_length', but it doesn't
318
 
    have to be a multiple of key_cache_block_size;
319
 
*/
320
 
 
321
 
unsigned char *key_cache_read(KEY_CACHE *keycache,
322
 
                      int file, internal::my_off_t filepos, int level,
323
 
                      unsigned char *buff, uint32_t length,
324
 
                      uint32_t block_length,
325
 
                      int return_buffer)
326
 
{
327
 
  (void)block_length;
328
 
  (void)return_buffer;
329
 
  (void)level;
330
 
  int error=0;
331
 
  unsigned char *start= buff;
332
 
 
333
 
  assert (! keycache->key_cache_inited);
334
 
 
335
 
  if (!pread(file, (unsigned char*) buff, length, filepos))
336
 
    error= 1;
337
 
  return(error ? (unsigned char*) 0 : start);
338
 
}
339
 
 
340
 
 
341
 
/*
342
 
  Insert a block of file data from a buffer into key cache
343
 
 
344
 
  SYNOPSIS
345
 
    key_cache_insert()
346
 
    keycache            pointer to a key cache data structure
347
 
    file                handler for the file to insert data from
348
 
    filepos             position of the block of data in the file to insert
349
 
    level               determines the weight of the data
350
 
    buff                buffer to read data from
351
 
    length              length of the data in the buffer
352
 
 
353
 
  NOTES
354
 
    This is used by MyISAM to move all blocks from a index file to the key
355
 
    cache
356
 
 
357
 
  RETURN VALUE
358
 
    0 if a success, 1 - otherwise.
359
 
*/
360
 
 
361
 
int key_cache_insert(KEY_CACHE *keycache,
362
 
                     int file, internal::my_off_t filepos, int level,
363
 
                     unsigned char *buff, uint32_t length)
364
 
{
365
 
  (void)file;
366
 
  (void)filepos;
367
 
  (void)level;
368
 
  (void)buff;
369
 
  (void)length;
370
 
 
371
 
  assert (!keycache->key_cache_inited);
372
 
  return 0;
373
 
}
374
 
 
375
 
 
376
 
/*
377
 
  Write a buffer into a cached file.
378
 
 
379
 
  SYNOPSIS
380
 
 
381
 
    key_cache_write()
382
 
      keycache            pointer to a key cache data structure
383
 
      file                handler for the file to write data to
384
 
      filepos             position in the file to write data to
385
 
      level               determines the weight of the data
386
 
      buff                buffer with the data
387
 
      length              length of the buffer
388
 
      dont_write          if is 0 then all dirty pages involved in writing
389
 
                          should have been flushed from key cache
390
 
 
391
 
  RETURN VALUE
392
 
    0 if a success, 1 - otherwise.
393
 
 
394
 
  NOTES.
395
 
    The function copies the data of size length from buff into buffers
396
 
    for key cache blocks that are  assigned to contain the portion of
397
 
    the file starting with position filepos.
398
 
    It ensures that this data is flushed to the file if dont_write is false.
399
 
    Filepos must be a multiple of 'block_length', but it doesn't
400
 
    have to be a multiple of key_cache_block_size;
401
 
 
402
 
    dont_write is always true in the server (info->lock_type is never F_UNLCK).
403
 
*/
404
 
 
405
 
int key_cache_write(KEY_CACHE *keycache,
406
 
                    int file, internal::my_off_t filepos, int level,
407
 
                    unsigned char *buff, uint32_t length,
408
 
                    uint32_t block_length,
409
 
                    int dont_write)
410
 
{
411
 
  (void)block_length;
412
 
  (void)level;
413
 
  int error=0;
414
 
 
415
 
  if (!dont_write)
416
 
  {
417
 
    /* Not used in the server. */
418
 
    /* Force writing from buff into disk. */
419
 
    if (pwrite(file, buff, length, filepos) == 0)
420
 
      return(1);
421
 
  }
422
 
 
423
 
  assert (!keycache->key_cache_inited);
424
 
 
425
 
  /* Key cache is not used */
426
 
  if (dont_write)
427
 
  {
428
 
    /* Used in the server. */
429
 
    if (pwrite(file, (unsigned char*) buff, length, filepos) == 0)
430
 
      error=1;
431
 
  }
432
 
 
433
 
  return(error);
434
 
}
435
 
 
436
 
 
437
 
/*
438
 
  Flush all blocks for a file to disk
439
 
 
440
 
  SYNOPSIS
441
 
 
442
 
    flush_key_blocks()
443
 
      keycache            pointer to a key cache data structure
444
 
      file                handler for the file to flush to
445
 
      flush_type          type of the flush
446
 
 
447
 
  RETURN
448
 
    0   ok
449
 
    1  error
450
 
*/
451
 
 
452
 
int flush_key_blocks(KEY_CACHE *keycache,
453
 
                     int file, enum flush_type type)
454
 
{
455
 
  (void)file;
456
 
  (void)type;
457
 
  assert (!keycache->key_cache_inited);
458
 
  return 0;
459
 
}