← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/keycache.h

  • Committer: Monty Taylor
  • Date: 2008-10-16 06:32:30 UTC
  • mto: (511.1.5 codestyle)
  • mto: This revision was merged to the branch mainline in revision 521.
  • Revision ID: monty@inaugust.com-20081016063230-4brxsra0qsmsg84q
Added -Wunused-macros.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/keycache.h
18
18
#ifndef _keycache_h
19
19
#define _keycache_h
20
20
 
21
 
#include <my_global.h>
 
21
#include <drizzled/global.h>
22
22
 
23
 
C_MODE_START
 
23
#ifdef __cplusplus
 
24
extern "C" {
 
25
#endif
24
26
 
25
27
enum flush_type
26
28
{
58
60
 
59
61
typedef struct st_key_cache
60
62
{
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 */
 
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 */
65
67
  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 */
 
68
  uint32_t key_cache_block_size;     /* size of the page buffer of a cache block */
67
69
  ulong min_warm_blocks;         /* min number of warm blocks;               */
68
70
  ulong age_threshold;           /* age threshold for hot blocks             */
69
71
  uint64_t keycache_time;       /* total number of block link operations    */
70
 
  uint hash_entries;             /* max number of entries in the hash table  */
 
72
  uint32_t hash_entries;             /* max number of entries in the hash table  */
71
73
  int hash_links;                /* max number of hash links                 */
72
74
  int hash_links_used;           /* number of hash links currently used      */
73
75
  int disk_blocks;               /* max number of blocks in the cache        */
82
84
  HASH_LINK *free_hash_list;     /* list of free hash links                  */
83
85
  BLOCK_LINK *free_block_list;   /* list of free blocks */
84
86
  BLOCK_LINK *block_root;        /* memory for block links                   */
85
 
  uchar *block_mem;     /* memory for block buffers                 */
 
87
  unsigned char *block_mem;     /* memory for block buffers                 */
86
88
  BLOCK_LINK *used_last;         /* ptr to the last block of the LRU chain   */
87
89
  BLOCK_LINK *used_ins;          /* ptr to the insertion block in LRU chain  */
88
90
  pthread_mutex_t cache_lock;    /* to lock access to the cache structure    */
115
117
  uint64_t global_cache_read;      /* number of reads from files to cache   */
116
118
 
117
119
  int blocks;                   /* max number of blocks in the cache        */
118
 
  my_bool in_init;              /* Set to 1 in MySQL during init/resize     */
 
120
  bool in_init;         /* Set to 1 in MySQL during init/resize     */
119
121
} KEY_CACHE;
120
122
 
121
123
/* The default key cache */
122
124
extern KEY_CACHE dflt_key_cache_var, *dflt_key_cache;
123
125
 
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,
 
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,
133
135
                            File file, my_off_t filepos, int level,
134
 
                            uchar *buff, uint length,
135
 
                            uint block_length,int return_buffer);
 
136
                            unsigned char *buff, uint32_t length,
 
137
                            uint32_t block_length,int return_buffer);
136
138
extern int key_cache_insert(KEY_CACHE *keycache,
137
139
                            File file, my_off_t filepos, int level,
138
 
                            uchar *buff, uint length);
 
140
                            unsigned char *buff, uint32_t length);
139
141
extern int key_cache_write(KEY_CACHE *keycache,
140
142
                           File file, my_off_t filepos, int level,
141
 
                           uchar *buff, uint length,
142
 
                           uint block_length,int force_write);
 
143
                           unsigned char *buff, uint32_t length,
 
144
                           uint32_t block_length,int force_write);
143
145
extern int flush_key_blocks(KEY_CACHE *keycache,
144
146
                            int file, enum flush_type type);
145
 
extern void end_key_cache(KEY_CACHE *keycache, my_bool cleanup);
 
147
extern void end_key_cache(KEY_CACHE *keycache, bool cleanup);
146
148
 
147
149
/* Functions to handle multiple key caches */
148
 
extern my_bool multi_keycache_init(void);
 
150
extern bool multi_keycache_init(void);
149
151
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
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,
152
154
                                   KEY_CACHE *key_cache);
153
155
extern void multi_key_cache_change(KEY_CACHE *old_data,
154
156
                                   KEY_CACHE *new_data);
155
157
extern int reset_key_cache_counters(const char *name,
156
158
                                    KEY_CACHE *key_cache);
157
 
C_MODE_END
 
159
 
 
160
#ifdef __cplusplus
 
161
}
 
162
#endif
 
163
 
158
164
#endif /* _keycache_h */