← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to include/keycache.h

Removed/replaced DBUG symbols and standardized TRUE/FALSE

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/keycache.h
18
18
#ifndef _keycache_h
19
19
#define _keycache_h
20
20
 
21
 
#include <drizzled/global.h>
 
21
#include <my_global.h>
22
22
 
23
 
#ifdef __cplusplus
24
 
extern "C" {
25
 
#endif
 
23
C_MODE_START
26
24
 
27
25
enum flush_type
28
26
{
60
58
 
61
59
typedef struct st_key_cache
62
60
{
63
 
  bool key_cache_inited;
64
 
  bool in_resize;             /* true during resize operation             */
65
 
  bool resize_in_flush;       /* true during flush of resize operation    */
66
 
  bool can_be_used;           /* usage of cache for read/write is allowed */
 
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 */
67
65
  size_t key_cache_mem_size;      /* specified size of the cache memory       */
68
 
  uint32_t key_cache_block_size;     /* size of the page buffer of a cache block */
 
66
  uint key_cache_block_size;     /* size of the page buffer of a cache block */
69
67
  ulong min_warm_blocks;         /* min number of warm blocks;               */
70
68
  ulong age_threshold;           /* age threshold for hot blocks             */
71
 
  uint64_t keycache_time;       /* total number of block link operations    */
72
 
  uint32_t hash_entries;             /* max number of entries in the hash table  */
 
69
  ulonglong keycache_time;       /* total number of block link operations    */
 
70
  uint hash_entries;             /* max number of entries in the hash table  */
73
71
  int hash_links;                /* max number of hash links                 */
74
72
  int hash_links_used;           /* number of hash links currently used      */
75
73
  int disk_blocks;               /* max number of blocks in the cache        */
84
82
  HASH_LINK *free_hash_list;     /* list of free hash links                  */
85
83
  BLOCK_LINK *free_block_list;   /* list of free blocks */
86
84
  BLOCK_LINK *block_root;        /* memory for block links                   */
87
 
  unsigned char *block_mem;     /* memory for block buffers                 */
 
85
  uchar *block_mem;     /* memory for block buffers                 */
88
86
  BLOCK_LINK *used_last;         /* ptr to the last block of the LRU chain   */
89
87
  BLOCK_LINK *used_ins;          /* ptr to the insertion block in LRU chain  */
90
88
  pthread_mutex_t cache_lock;    /* to lock access to the cache structure    */
104
102
    initializing the key cache.
105
103
  */
106
104
 
107
 
  uint64_t param_buff_size;    /* size the memory allocated for the cache  */
 
105
  ulonglong param_buff_size;    /* size the memory allocated for the cache  */
108
106
  ulong param_block_size;       /* size of the blocks in the key cache      */
109
107
  ulong param_division_limit;   /* min. percentage of warm blocks           */
110
108
  ulong param_age_threshold;    /* determines when hot block is downgraded  */
111
109
 
112
110
  /* Statistics variables. These are reset in reset_key_cache_counters(). */
113
111
  ulong global_blocks_changed;  /* number of currently dirty blocks         */
114
 
  uint64_t global_cache_w_requests;/* number of write requests (write hits) */
115
 
  uint64_t global_cache_write;     /* number of writes from cache to files  */
116
 
  uint64_t global_cache_r_requests;/* number of read requests (read hits)   */
117
 
  uint64_t global_cache_read;      /* number of reads from files to cache   */
 
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   */
118
116
 
119
117
  int blocks;                   /* max number of blocks in the cache        */
120
 
  bool in_init;         /* Set to 1 in MySQL during init/resize     */
 
118
  my_bool in_init;              /* Set to 1 in MySQL during init/resize     */
121
119
} KEY_CACHE;
122
120
 
123
121
/* The default key cache */
124
122
extern KEY_CACHE dflt_key_cache_var, *dflt_key_cache;
125
123
 
126
 
extern int init_key_cache(KEY_CACHE *keycache, uint32_t key_cache_block_size,
127
 
                          size_t use_mem, uint32_t division_limit,
128
 
                          uint32_t age_threshold);
129
 
extern int resize_key_cache(KEY_CACHE *keycache, uint32_t key_cache_block_size,
130
 
                            size_t use_mem, uint32_t division_limit,
131
 
                            uint32_t age_threshold);
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,
 
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,
135
133
                            File file, my_off_t filepos, int level,
136
 
                            unsigned char *buff, uint32_t length,
137
 
                            uint32_t block_length,int return_buffer);
 
134
                            uchar *buff, uint length,
 
135
                            uint block_length,int return_buffer);
138
136
extern int key_cache_insert(KEY_CACHE *keycache,
139
137
                            File file, my_off_t filepos, int level,
140
 
                            unsigned char *buff, uint32_t length);
 
138
                            uchar *buff, uint length);
141
139
extern int key_cache_write(KEY_CACHE *keycache,
142
140
                           File file, my_off_t filepos, int level,
143
 
                           unsigned char *buff, uint32_t length,
144
 
                           uint32_t block_length,int force_write);
 
141
                           uchar *buff, uint length,
 
142
                           uint block_length,int force_write);
145
143
extern int flush_key_blocks(KEY_CACHE *keycache,
146
144
                            int file, enum flush_type type);
147
 
extern void end_key_cache(KEY_CACHE *keycache, bool cleanup);
 
145
extern void end_key_cache(KEY_CACHE *keycache, my_bool cleanup);
148
146
 
149
147
/* Functions to handle multiple key caches */
150
 
extern bool multi_keycache_init(void);
 
148
extern my_bool multi_keycache_init(void);
151
149
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,
 
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,
154
152
                                   KEY_CACHE *key_cache);
155
153
extern void multi_key_cache_change(KEY_CACHE *old_data,
156
154
                                   KEY_CACHE *new_data);
157
155
extern int reset_key_cache_counters(const char *name,
158
156
                                    KEY_CACHE *key_cache);
159
 
 
160
 
#ifdef __cplusplus
161
 
}
162
 
#endif
163
 
 
 
157
C_MODE_END
164
158
#endif /* _keycache_h */