← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to include/keycache.h

Merged from trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/keycache.h
15
15
 
16
16
/* Key cache variable structures */
17
17
 
18
 
#ifndef PLUGIN_MYISAM_KEYCACHE_H
19
 
#define PLUGIN_MYISAM_KEYCACHE_H
 
18
#ifndef _keycache_h
 
19
#define _keycache_h
 
20
 
 
21
#include <my_global.h>
 
22
 
 
23
C_MODE_START
20
24
 
21
25
enum flush_type
22
26
{
30
34
  FLUSH_FORCE_WRITE
31
35
};
32
36
 
33
 
 
34
37
/* declare structures that is used by st_key_cache */
35
38
 
36
39
struct st_block_link;
40
43
struct st_hash_link;
41
44
typedef struct st_hash_link HASH_LINK;
42
45
 
43
 
namespace drizzled
44
 
{
45
 
namespace internal
46
 
{
47
 
typedef uint64_t my_off_t;
48
 
struct st_my_thread_var;
49
 
}
50
 
 
51
46
/* info about requests in a waiting queue */
52
47
typedef struct st_keycache_wqueue
53
48
{
54
 
  drizzled::internal::st_my_thread_var *last_thread;  /* circular list of waiting threads */
 
49
  struct st_my_thread_var *last_thread;  /* circular list of waiting threads */
55
50
} KEYCACHE_WQUEUE;
56
51
 
57
52
#define CHANGED_BLOCKS_HASH 128             /* must be power of 2 */
59
54
/*
60
55
  The key cache structure
61
56
  It also contains read-only statistics parameters.
62
 
*/
 
57
*/   
63
58
 
64
59
typedef struct st_key_cache
65
60
{
66
 
  bool key_cache_inited;
67
 
  bool can_be_used;           /* usage of cache for read/write is allowed */
68
 
 
69
 
  uint32_t key_cache_block_size;     /* size of the page buffer of a cache block */
 
61
  my_bool key_cache_inited;
 
62
  my_bool in_resize;             /* true during resize operation             */
 
63
  my_bool resize_in_flush;       /* true during flush of resize operation    */
 
64
  my_bool can_be_used;           /* usage of cache for read/write is allowed */
 
65
  size_t key_cache_mem_size;      /* specified size of the cache memory       */
 
66
  uint key_cache_block_size;     /* size of the page buffer of a cache block */
 
67
  ulong min_warm_blocks;         /* min number of warm blocks;               */
 
68
  ulong age_threshold;           /* age threshold for hot blocks             */
 
69
  ulonglong keycache_time;       /* total number of block link operations    */
 
70
  uint hash_entries;             /* max number of entries in the hash table  */
 
71
  int hash_links;                /* max number of hash links                 */
 
72
  int hash_links_used;           /* number of hash links currently used      */
 
73
  int disk_blocks;               /* max number of blocks in the cache        */
 
74
  ulong blocks_used; /* maximum number of concurrently used blocks */
 
75
  ulong blocks_unused; /* number of currently unused blocks */
 
76
  ulong blocks_changed;          /* number of currently dirty blocks         */
 
77
  ulong warm_blocks;             /* number of blocks in warm sub-chain       */
 
78
  ulong cnt_for_resize_op;       /* counter to block resize operation        */
 
79
  long blocks_available;      /* number of blocks available in the LRU chain */
 
80
  HASH_LINK **hash_root;         /* arr. of entries into hash table buckets  */
 
81
  HASH_LINK *hash_link_root;     /* memory for hash table links              */
 
82
  HASH_LINK *free_hash_list;     /* list of free hash links                  */
 
83
  BLOCK_LINK *free_block_list;   /* list of free blocks */
 
84
  BLOCK_LINK *block_root;        /* memory for block links                   */
 
85
  uchar *block_mem;     /* memory for block buffers                 */
 
86
  BLOCK_LINK *used_last;         /* ptr to the last block of the LRU chain   */
 
87
  BLOCK_LINK *used_ins;          /* ptr to the insertion block in LRU chain  */
 
88
  pthread_mutex_t cache_lock;    /* to lock access to the cache structure    */
 
89
  KEYCACHE_WQUEUE resize_queue;  /* threads waiting during resize operation  */
 
90
  /*
 
91
    Waiting for a zero resize count. Using a queue for symmetry though
 
92
    only one thread can wait here.
 
93
  */
 
94
  KEYCACHE_WQUEUE waiting_for_resize_cnt;
 
95
  KEYCACHE_WQUEUE waiting_for_hash_link; /* waiting for a free hash link     */
 
96
  KEYCACHE_WQUEUE waiting_for_block;    /* requests waiting for a free block */
 
97
  BLOCK_LINK *changed_blocks[CHANGED_BLOCKS_HASH]; /* hash for dirty file bl.*/
 
98
  BLOCK_LINK *file_blocks[CHANGED_BLOCKS_HASH];    /* hash for other file bl.*/
 
99
 
 
100
  /*
 
101
    The following variables are and variables used to hold parameters for
 
102
    initializing the key cache.
 
103
  */
 
104
 
 
105
  ulonglong param_buff_size;    /* size the memory allocated for the cache  */
 
106
  ulong param_block_size;       /* size of the blocks in the key cache      */
 
107
  ulong param_division_limit;   /* min. percentage of warm blocks           */
 
108
  ulong param_age_threshold;    /* determines when hot block is downgraded  */
 
109
 
 
110
  /* Statistics variables. These are reset in reset_key_cache_counters(). */
 
111
  ulong global_blocks_changed;  /* number of currently dirty blocks         */
 
112
  ulonglong global_cache_w_requests;/* number of write requests (write hits) */
 
113
  ulonglong global_cache_write;     /* number of writes from cache to files  */
 
114
  ulonglong global_cache_r_requests;/* number of read requests (read hits)   */
 
115
  ulonglong global_cache_read;      /* number of reads from files to cache   */
70
116
 
71
117
  int blocks;                   /* max number of blocks in the cache        */
72
 
 
73
 
  bool in_init;         /* Set to 1 in MySQL during init/resize     */
74
 
 
75
 
  st_key_cache():
76
 
    key_cache_inited(false),
77
 
    can_be_used(false),
78
 
    key_cache_block_size(0),
79
 
    blocks(0),
80
 
    in_init(0)
81
 
  { }
82
 
 
 
118
  my_bool in_init;              /* Set to 1 in MySQL during init/resize     */
83
119
} KEY_CACHE;
84
120
 
85
 
} /* namespace drizzled */
86
 
 
87
121
/* The default key cache */
88
 
extern int init_key_cache(drizzled::KEY_CACHE *keycache, uint32_t key_cache_block_size,
89
 
                          size_t use_mem, uint32_t division_limit,
90
 
                          uint32_t age_threshold);
91
 
extern unsigned char *key_cache_read(drizzled::KEY_CACHE *keycache,
92
 
                            int file, drizzled::internal::my_off_t filepos, int level,
93
 
                            unsigned char *buff, uint32_t length,
94
 
                            uint32_t block_length,int return_buffer);
95
 
extern int key_cache_insert(drizzled::KEY_CACHE *keycache,
96
 
                            int file, drizzled::internal::my_off_t filepos, int level,
97
 
                            unsigned char *buff, uint32_t length);
98
 
extern int key_cache_write(drizzled::KEY_CACHE *keycache,
99
 
                           int file, drizzled::internal::my_off_t filepos, int level,
100
 
                           unsigned char *buff, uint32_t length,
101
 
                           uint32_t block_length,int force_write);
102
 
extern int flush_key_blocks(drizzled::KEY_CACHE *keycache,
 
122
extern KEY_CACHE dflt_key_cache_var, *dflt_key_cache;
 
123
 
 
124
extern int init_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
 
125
                          size_t use_mem, uint division_limit,
 
126
                          uint age_threshold);
 
127
extern int resize_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
 
128
                            size_t use_mem, uint division_limit,
 
129
                            uint age_threshold);
 
130
extern void change_key_cache_param(KEY_CACHE *keycache, uint division_limit,
 
131
                                   uint age_threshold);
 
132
extern uchar *key_cache_read(KEY_CACHE *keycache,
 
133
                            File file, my_off_t filepos, int level,
 
134
                            uchar *buff, uint length,
 
135
                            uint block_length,int return_buffer);
 
136
extern int key_cache_insert(KEY_CACHE *keycache,
 
137
                            File file, my_off_t filepos, int level,
 
138
                            uchar *buff, uint length);
 
139
extern int key_cache_write(KEY_CACHE *keycache,
 
140
                           File file, my_off_t filepos, int level,
 
141
                           uchar *buff, uint length,
 
142
                           uint block_length,int force_write);
 
143
extern int flush_key_blocks(KEY_CACHE *keycache,
103
144
                            int file, enum flush_type type);
104
 
extern void end_key_cache(drizzled::KEY_CACHE *keycache, bool cleanup);
105
 
 
106
 
/*
107
 
  Next highest power of two
108
 
 
109
 
  SYNOPSIS
110
 
    my_round_up_to_next_power()
111
 
    v           Value to check
112
 
 
113
 
  RETURN
114
 
    Next or equal power of 2
115
 
    Note: 0 will return 0
116
 
 
117
 
  NOTES
118
 
    Algorithm by Sean Anderson, according to:
119
 
    http://graphics.stanford.edu/~seander/bithacks.html
120
 
    (Orignal code public domain)
121
 
 
122
 
    Comments shows how this works with 01100000000000000000000000001011
123
 
*/
124
 
 
125
 
static inline uint32_t my_round_up_to_next_power(uint32_t v)
126
 
{
127
 
  v--;                  /* 01100000000000000000000000001010 */
128
 
  v|= v >> 1;           /* 01110000000000000000000000001111 */
129
 
  v|= v >> 2;           /* 01111100000000000000000000001111 */
130
 
  v|= v >> 4;           /* 01111111110000000000000000001111 */
131
 
  v|= v >> 8;           /* 01111111111111111100000000001111 */
132
 
  v|= v >> 16;          /* 01111111111111111111111111111111 */
133
 
  return v+1;           /* 10000000000000000000000000000000 */
134
 
}
135
 
 
136
 
 
137
 
#endif /* PLUGIN_MYISAM_KEYCACHE_H */
 
145
extern void end_key_cache(KEY_CACHE *keycache, my_bool cleanup);
 
146
 
 
147
/* Functions to handle multiple key caches */
 
148
extern my_bool multi_keycache_init(void);
 
149
extern void multi_keycache_free(void);
 
150
extern KEY_CACHE *multi_key_cache_search(uchar *key, uint length);
 
151
extern my_bool multi_key_cache_set(const uchar *key, uint length,
 
152
                                   KEY_CACHE *key_cache);
 
153
extern void multi_key_cache_change(KEY_CACHE *old_data,
 
154
                                   KEY_CACHE *new_data);
 
155
extern int reset_key_cache_counters(const char *name,
 
156
                                    KEY_CACHE *key_cache);
 
157
C_MODE_END
 
158
#endif /* _keycache_h */