← 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: 2009-07-11 19:23:04 UTC
  • mfrom: (1089.1.14 merge)
  • Revision ID: brian@gaz-20090711192304-ootijyl5yf9jq9kd
Merge Brian

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/myisam/keycache.h
20
20
 
21
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
{
54
56
/*
55
57
  The key cache structure
56
58
  It also contains read-only statistics parameters.
57
 
*/   
 
59
*/
58
60
 
59
61
typedef struct st_key_cache
60
62
{
62
64
  bool in_resize;             /* true during resize operation             */
63
65
  bool resize_in_flush;       /* true during flush of resize operation    */
64
66
  bool can_be_used;           /* usage of cache for read/write is allowed */
 
67
  uint32_t hash_entries;             /* max number of entries in the hash table  */
65
68
  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 */
 
69
  uint32_t key_cache_block_size;     /* size of the page buffer of a cache block */
 
70
  int disk_blocks;               /* max number of blocks in the cache        */
67
71
  ulong min_warm_blocks;         /* min number of warm blocks;               */
68
72
  ulong age_threshold;           /* age threshold for hot blocks             */
69
73
  uint64_t keycache_time;       /* total number of block link operations    */
70
 
  uint hash_entries;             /* max number of entries in the hash table  */
71
74
  int hash_links;                /* max number of hash links                 */
72
75
  int hash_links_used;           /* number of hash links currently used      */
73
 
  int disk_blocks;               /* max number of blocks in the cache        */
74
76
  ulong blocks_used; /* maximum number of concurrently used blocks */
75
77
  ulong blocks_unused; /* number of currently unused blocks */
76
78
  ulong blocks_changed;          /* number of currently dirty blocks         */
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    */
103
105
  */
104
106
 
105
107
  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  */
 
108
  uint32_t param_block_size;   /* size of the blocks in the key cache      */
 
109
  uint32_t param_division_limit; /* min. percentage of warm blocks           */
 
110
  uint32_t param_age_threshold;    /* determines when hot block is downgraded  */
109
111
 
 
112
  int blocks;                   /* max number of blocks in the cache        */
110
113
  /* Statistics variables. These are reset in reset_key_cache_counters(). */
111
114
  ulong global_blocks_changed;  /* number of currently dirty blocks         */
112
115
  uint64_t global_cache_w_requests;/* number of write requests (write hits) */
114
117
  uint64_t global_cache_r_requests;/* number of read requests (read hits)   */
115
118
  uint64_t global_cache_read;      /* number of reads from files to cache   */
116
119
 
117
 
  int blocks;                   /* max number of blocks in the cache        */
118
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
147
extern void end_key_cache(KEY_CACHE *keycache, bool cleanup);
147
149
/* Functions to handle multiple key caches */
148
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 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 */