← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/myisam/keycache.h

  • Committer: Brian Aker
  • Date: 2010-02-07 01:33:54 UTC
  • Revision ID: brian@gaz-20100207013354-d2pg1n68u5c09pgo
Remove giant include header to its own file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/myisam/keycache.h
15
15
 
16
16
/* Key cache variable structures */
17
17
 
18
 
#ifndef _keycache_h
19
 
#define _keycache_h
20
 
 
21
 
#include <drizzled/global.h>
22
 
 
23
 
C_MODE_START
 
18
#ifndef PLUGIN_MYISAM_KEYCACHE_H
 
19
#define PLUGIN_MYISAM_KEYCACHE_H
24
20
 
25
21
enum flush_type
26
22
{
34
30
  FLUSH_FORCE_WRITE
35
31
};
36
32
 
 
33
 
37
34
/* declare structures that is used by st_key_cache */
38
35
 
39
36
struct st_block_link;
43
40
struct st_hash_link;
44
41
typedef struct st_hash_link HASH_LINK;
45
42
 
 
43
namespace drizzled
 
44
{
 
45
namespace internal
 
46
{
 
47
typedef uint64_t my_off_t;
 
48
struct st_my_thread_var;
 
49
}
 
50
 
46
51
/* info about requests in a waiting queue */
47
52
typedef struct st_keycache_wqueue
48
53
{
49
 
  struct st_my_thread_var *last_thread;  /* circular list of waiting threads */
 
54
  drizzled::internal::st_my_thread_var *last_thread;  /* circular list of waiting threads */
50
55
} KEYCACHE_WQUEUE;
51
56
 
52
57
#define CHANGED_BLOCKS_HASH 128             /* must be power of 2 */
54
59
/*
55
60
  The key cache structure
56
61
  It also contains read-only statistics parameters.
57
 
*/   
 
62
*/
58
63
 
59
64
typedef struct st_key_cache
60
65
{
62
67
  bool in_resize;             /* true during resize operation             */
63
68
  bool resize_in_flush;       /* true during flush of resize operation    */
64
69
  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 */
 
70
  uint32_t hash_entries;             /* max number of entries in the hash table  */
 
71
  uint32_t key_cache_mem_size;      /* specified size of the cache memory       */
 
72
  uint32_t key_cache_block_size;     /* size of the page buffer of a cache block */
 
73
  int disk_blocks;               /* max number of blocks in the cache        */
67
74
  ulong min_warm_blocks;         /* min number of warm blocks;               */
68
75
  ulong age_threshold;           /* age threshold for hot blocks             */
69
76
  uint64_t keycache_time;       /* total number of block link operations    */
70
 
  uint hash_entries;             /* max number of entries in the hash table  */
71
77
  int hash_links;                /* max number of hash links                 */
72
78
  int hash_links_used;           /* number of hash links currently used      */
73
 
  int disk_blocks;               /* max number of blocks in the cache        */
74
79
  ulong blocks_used; /* maximum number of concurrently used blocks */
75
80
  ulong blocks_unused; /* number of currently unused blocks */
76
81
  ulong blocks_changed;          /* number of currently dirty blocks         */
82
87
  HASH_LINK *free_hash_list;     /* list of free hash links                  */
83
88
  BLOCK_LINK *free_block_list;   /* list of free blocks */
84
89
  BLOCK_LINK *block_root;        /* memory for block links                   */
85
 
  uchar *block_mem;     /* memory for block buffers                 */
 
90
  unsigned char *block_mem;     /* memory for block buffers                 */
86
91
  BLOCK_LINK *used_last;         /* ptr to the last block of the LRU chain   */
87
92
  BLOCK_LINK *used_ins;          /* ptr to the insertion block in LRU chain  */
88
93
  pthread_mutex_t cache_lock;    /* to lock access to the cache structure    */
102
107
    initializing the key cache.
103
108
  */
104
109
 
105
 
  uint64_t 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  */
 
110
  uint32_t param_buff_size;    /* size the memory allocated for the cache  */
 
111
  uint32_t param_block_size;   /* size of the blocks in the key cache      */
 
112
  uint32_t param_division_limit; /* min. percentage of warm blocks           */
 
113
  uint32_t param_age_threshold;    /* determines when hot block is downgraded  */
109
114
 
 
115
  int blocks;                   /* max number of blocks in the cache        */
110
116
  /* Statistics variables. These are reset in reset_key_cache_counters(). */
111
117
  ulong global_blocks_changed;  /* number of currently dirty blocks         */
112
118
  uint64_t global_cache_w_requests;/* number of write requests (write hits) */
114
120
  uint64_t global_cache_r_requests;/* number of read requests (read hits)   */
115
121
  uint64_t global_cache_read;      /* number of reads from files to cache   */
116
122
 
117
 
  int blocks;                   /* max number of blocks in the cache        */
118
123
  bool in_init;         /* Set to 1 in MySQL during init/resize     */
119
124
} KEY_CACHE;
120
125
 
 
126
} /* namespace drizzled */
 
127
 
121
128
/* The default key cache */
122
 
extern KEY_CACHE dflt_key_cache_var, *dflt_key_cache;
 
129
extern drizzled::KEY_CACHE dflt_key_cache_var, *dflt_key_cache;
123
130
 
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,
 
131
extern int init_key_cache(drizzled::KEY_CACHE *keycache, uint32_t key_cache_block_size,
 
132
                          size_t use_mem, uint32_t division_limit,
 
133
                          uint32_t age_threshold);
 
134
extern int resize_key_cache(drizzled::KEY_CACHE *keycache, uint32_t key_cache_block_size,
 
135
                            size_t use_mem, uint32_t division_limit,
 
136
                            uint32_t age_threshold);
 
137
extern unsigned char *key_cache_read(drizzled::KEY_CACHE *keycache,
 
138
                            int file, drizzled::internal::my_off_t filepos, int level,
 
139
                            unsigned char *buff, uint32_t length,
 
140
                            uint32_t block_length,int return_buffer);
 
141
extern int key_cache_insert(drizzled::KEY_CACHE *keycache,
 
142
                            int file, drizzled::internal::my_off_t filepos, int level,
 
143
                            unsigned char *buff, uint32_t length);
 
144
extern int key_cache_write(drizzled::KEY_CACHE *keycache,
 
145
                           int file, drizzled::internal::my_off_t filepos, int level,
 
146
                           unsigned char *buff, uint32_t length,
 
147
                           uint32_t block_length,int force_write);
 
148
extern int flush_key_blocks(drizzled::KEY_CACHE *keycache,
144
149
                            int file, enum flush_type type);
145
 
extern void end_key_cache(KEY_CACHE *keycache, bool cleanup);
146
 
 
147
 
/* Functions to handle multiple key caches */
148
 
extern 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 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 */
 
150
extern void end_key_cache(drizzled::KEY_CACHE *keycache, bool cleanup);
 
151
 
 
152
extern void reset_key_cache_counters();
 
153
 
 
154
/*
 
155
  Next highest power of two
 
156
 
 
157
  SYNOPSIS
 
158
    my_round_up_to_next_power()
 
159
    v           Value to check
 
160
 
 
161
  RETURN
 
162
    Next or equal power of 2
 
163
    Note: 0 will return 0
 
164
 
 
165
  NOTES
 
166
    Algorithm by Sean Anderson, according to:
 
167
    http://graphics.stanford.edu/~seander/bithacks.html
 
168
    (Orignal code public domain)
 
169
 
 
170
    Comments shows how this works with 01100000000000000000000000001011
 
171
*/
 
172
 
 
173
static inline uint32_t my_round_up_to_next_power(uint32_t v)
 
174
{
 
175
  v--;                  /* 01100000000000000000000000001010 */
 
176
  v|= v >> 1;           /* 01110000000000000000000000001111 */
 
177
  v|= v >> 2;           /* 01111100000000000000000000001111 */
 
178
  v|= v >> 4;           /* 01111111110000000000000000001111 */
 
179
  v|= v >> 8;           /* 01111111111111111100000000001111 */
 
180
  v|= v >> 16;          /* 01111111111111111111111111111111 */
 
181
  return v+1;           /* 10000000000000000000000000000000 */
 
182
}
 
183
 
 
184
 
 
185
#endif /* PLUGIN_MYISAM_KEYCACHE_H */