← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/myisam/keycache.h

Updated an include guard thanks to a nice catch during code review from Jay. Thanks Jay!

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/myisam/keycache.h
18
18
#ifndef PLUGIN_MYISAM_KEYCACHE_H
19
19
#define PLUGIN_MYISAM_KEYCACHE_H
20
20
 
 
21
#ifdef __cplusplus
 
22
extern "C" {
 
23
#endif
 
24
 
21
25
enum flush_type
22
26
{
23
27
  FLUSH_KEEP,           /* flush block and keep it in the cache */
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 */
68
63
  bool resize_in_flush;       /* true during flush of resize operation    */
69
64
  bool can_be_used;           /* usage of cache for read/write is allowed */
70
65
  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       */
 
66
  size_t key_cache_mem_size;      /* specified size of the cache memory       */
72
67
  uint32_t key_cache_block_size;     /* size of the page buffer of a cache block */
73
68
  int disk_blocks;               /* max number of blocks in the cache        */
74
69
  ulong min_warm_blocks;         /* min number of warm blocks;               */
107
102
    initializing the key cache.
108
103
  */
109
104
 
110
 
  uint32_t param_buff_size;    /* size the memory allocated for the cache  */
 
105
  uint64_t param_buff_size;    /* size the memory allocated for the cache  */
111
106
  uint32_t param_block_size;   /* size of the blocks in the key cache      */
112
107
  uint32_t param_division_limit; /* min. percentage of warm blocks           */
113
108
  uint32_t param_age_threshold;    /* determines when hot block is downgraded  */
123
118
  bool in_init;         /* Set to 1 in MySQL during init/resize     */
124
119
} KEY_CACHE;
125
120
 
126
 
} /* namespace drizzled */
127
 
 
128
121
/* The default key cache */
129
 
extern drizzled::KEY_CACHE dflt_key_cache_var, *dflt_key_cache;
 
122
extern KEY_CACHE dflt_key_cache_var, *dflt_key_cache;
130
123
 
131
 
extern int init_key_cache(drizzled::KEY_CACHE *keycache, uint32_t key_cache_block_size,
 
124
extern int init_key_cache(KEY_CACHE *keycache, uint32_t key_cache_block_size,
132
125
                          size_t use_mem, uint32_t division_limit,
133
126
                          uint32_t age_threshold);
134
 
extern int resize_key_cache(drizzled::KEY_CACHE *keycache, uint32_t key_cache_block_size,
 
127
extern int resize_key_cache(KEY_CACHE *keycache, uint32_t key_cache_block_size,
135
128
                            size_t use_mem, uint32_t division_limit,
136
129
                            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,
 
130
extern unsigned char *key_cache_read(KEY_CACHE *keycache,
 
131
                            File file, my_off_t filepos, int level,
139
132
                            unsigned char *buff, uint32_t length,
140
133
                            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,
 
134
extern int key_cache_insert(KEY_CACHE *keycache,
 
135
                            File file, my_off_t filepos, int level,
143
136
                            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,
 
137
extern int key_cache_write(KEY_CACHE *keycache,
 
138
                           File file, my_off_t filepos, int level,
146
139
                           unsigned char *buff, uint32_t length,
147
140
                           uint32_t block_length,int force_write);
148
 
extern int flush_key_blocks(drizzled::KEY_CACHE *keycache,
 
141
extern int flush_key_blocks(KEY_CACHE *keycache,
149
142
                            int file, enum flush_type type);
150
 
extern void end_key_cache(drizzled::KEY_CACHE *keycache, bool cleanup);
 
143
extern void end_key_cache(KEY_CACHE *keycache, bool cleanup);
151
144
 
152
145
extern void reset_key_cache_counters();
153
146
 
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 */
 
147
#ifdef __cplusplus
182
148
}
183
 
 
 
149
#endif
184
150
 
185
151
#endif /* PLUGIN_MYISAM_KEYCACHE_H */