← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/keycache.h

  • Committer: Brian Aker
  • Date: 2008-10-06 06:47:29 UTC
  • Revision ID: brian@tangent.org-20081006064729-2i9mhjkzyvow9xsm
Remove uint.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/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 <drizzled/global.h>
 
22
 
 
23
#ifdef __cplusplus
 
24
extern "C" {
 
25
#endif
20
26
 
21
27
enum flush_type
22
28
{
30
36
  FLUSH_FORCE_WRITE
31
37
};
32
38
 
33
 
 
34
39
/* declare structures that is used by st_key_cache */
35
40
 
36
41
struct st_block_link;
40
45
struct st_hash_link;
41
46
typedef struct st_hash_link HASH_LINK;
42
47
 
43
 
namespace drizzled
44
 
{
45
 
namespace internal
46
 
{
47
 
typedef uint64_t my_off_t;
48
 
struct st_my_thread_var;
49
 
}
50
 
 
51
48
/* info about requests in a waiting queue */
52
49
typedef struct st_keycache_wqueue
53
50
{
54
 
  drizzled::internal::st_my_thread_var *last_thread;  /* circular list of waiting threads */
 
51
  struct st_my_thread_var *last_thread;  /* circular list of waiting threads */
55
52
} KEYCACHE_WQUEUE;
56
53
 
57
54
#define CHANGED_BLOCKS_HASH 128             /* must be power of 2 */
59
56
/*
60
57
  The key cache structure
61
58
  It also contains read-only statistics parameters.
62
 
*/
 
59
*/   
63
60
 
64
61
typedef struct st_key_cache
65
62
{
67
64
  bool in_resize;             /* true during resize operation             */
68
65
  bool resize_in_flush;       /* true during flush of resize operation    */
69
66
  bool can_be_used;           /* usage of cache for read/write is allowed */
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       */
 
67
  size_t key_cache_mem_size;      /* specified size of the cache memory       */
72
68
  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        */
74
69
  ulong min_warm_blocks;         /* min number of warm blocks;               */
75
70
  ulong age_threshold;           /* age threshold for hot blocks             */
76
71
  uint64_t keycache_time;       /* total number of block link operations    */
 
72
  uint32_t hash_entries;             /* max number of entries in the hash table  */
77
73
  int hash_links;                /* max number of hash links                 */
78
74
  int hash_links_used;           /* number of hash links currently used      */
 
75
  int disk_blocks;               /* max number of blocks in the cache        */
79
76
  ulong blocks_used; /* maximum number of concurrently used blocks */
80
77
  ulong blocks_unused; /* number of currently unused blocks */
81
78
  ulong blocks_changed;          /* number of currently dirty blocks         */
107
104
    initializing the key cache.
108
105
  */
109
106
 
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  */
 
107
  uint64_t param_buff_size;    /* size the memory allocated for the cache  */
 
108
  ulong param_block_size;       /* size of the blocks in the key cache      */
 
109
  ulong param_division_limit;   /* min. percentage of warm blocks           */
 
110
  ulong param_age_threshold;    /* determines when hot block is downgraded  */
114
111
 
115
 
  int blocks;                   /* max number of blocks in the cache        */
116
112
  /* Statistics variables. These are reset in reset_key_cache_counters(). */
117
113
  ulong global_blocks_changed;  /* number of currently dirty blocks         */
118
114
  uint64_t global_cache_w_requests;/* number of write requests (write hits) */
120
116
  uint64_t global_cache_r_requests;/* number of read requests (read hits)   */
121
117
  uint64_t global_cache_read;      /* number of reads from files to cache   */
122
118
 
 
119
  int blocks;                   /* max number of blocks in the cache        */
123
120
  bool in_init;         /* Set to 1 in MySQL during init/resize     */
124
121
} KEY_CACHE;
125
122
 
126
 
} /* namespace drizzled */
127
 
 
128
123
/* The default key cache */
129
 
extern drizzled::KEY_CACHE dflt_key_cache_var, *dflt_key_cache;
 
124
extern KEY_CACHE dflt_key_cache_var, *dflt_key_cache;
130
125
 
131
 
extern int init_key_cache(drizzled::KEY_CACHE *keycache, uint32_t key_cache_block_size,
 
126
extern int init_key_cache(KEY_CACHE *keycache, uint32_t key_cache_block_size,
132
127
                          size_t use_mem, uint32_t division_limit,
133
128
                          uint32_t age_threshold);
134
 
extern int resize_key_cache(drizzled::KEY_CACHE *keycache, uint32_t key_cache_block_size,
 
129
extern int resize_key_cache(KEY_CACHE *keycache, uint32_t key_cache_block_size,
135
130
                            size_t use_mem, uint32_t division_limit,
136
131
                            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,
 
132
extern void change_key_cache_param(KEY_CACHE *keycache, uint32_t division_limit,
 
133
                                   uint32_t age_threshold);
 
134
extern unsigned char *key_cache_read(KEY_CACHE *keycache,
 
135
                            File file, my_off_t filepos, int level,
139
136
                            unsigned char *buff, uint32_t length,
140
137
                            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,
 
138
extern int key_cache_insert(KEY_CACHE *keycache,
 
139
                            File file, my_off_t filepos, int level,
143
140
                            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,
 
141
extern int key_cache_write(KEY_CACHE *keycache,
 
142
                           File file, my_off_t filepos, int level,
146
143
                           unsigned char *buff, uint32_t length,
147
144
                           uint32_t block_length,int force_write);
148
 
extern int flush_key_blocks(drizzled::KEY_CACHE *keycache,
 
145
extern int flush_key_blocks(KEY_CACHE *keycache,
149
146
                            int file, enum flush_type type);
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 */
 
147
extern void end_key_cache(KEY_CACHE *keycache, bool cleanup);
 
148
 
 
149
/* Functions to handle multiple key caches */
 
150
extern bool multi_keycache_init(void);
 
151
extern void multi_keycache_free(void);
 
152
extern KEY_CACHE *multi_key_cache_search(unsigned char *key, uint32_t length);
 
153
extern bool multi_key_cache_set(const unsigned char *key, uint32_t length,
 
154
                                   KEY_CACHE *key_cache);
 
155
extern void multi_key_cache_change(KEY_CACHE *old_data,
 
156
                                   KEY_CACHE *new_data);
 
157
extern int reset_key_cache_counters(const char *name,
 
158
                                    KEY_CACHE *key_cache);
 
159
 
 
160
#ifdef __cplusplus
182
161
}
183
 
 
184
 
 
185
 
#endif /* PLUGIN_MYISAM_KEYCACHE_H */
 
162
#endif
 
163
 
 
164
#endif /* _keycache_h */