← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/myisam/keycache.h

pandora-build v0.100 - Fixes several bugs found by cb1kenobi. Add several thoughts from folks at LCA.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/myisam/keycache.h
15
15
 
16
16
/* Key cache variable structures */
17
17
 
18
 
#ifndef _keycache_h
19
 
#define _keycache_h
20
 
 
21
 
#include <drizzled/global.h>
22
 
 
23
 
C_MODE_START
 
18
#ifndef PLUGIN_MYISAM_KEYCACHE_H
 
19
#define PLUGIN_MYISAM_KEYCACHE_H
 
20
 
 
21
#ifdef __cplusplus
 
22
extern "C" {
 
23
#endif
24
24
 
25
25
enum flush_type
26
26
{
34
34
  FLUSH_FORCE_WRITE
35
35
};
36
36
 
 
37
typedef uint64_t my_off_t;
 
38
 
37
39
/* declare structures that is used by st_key_cache */
38
40
 
39
41
struct st_block_link;
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 */
65
 
  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 */
 
67
  uint32_t hash_entries;             /* max number of entries in the hash table  */
 
68
  uint32_t key_cache_mem_size;      /* specified size of the cache memory       */
 
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    */
102
104
    initializing the key cache.
103
105
  */
104
106
 
105
 
  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  */
 
107
  uint32_t param_buff_size;    /* size the memory allocated for the cache  */
 
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,
133
 
                            File file, my_off_t filepos, int level,
134
 
                            uchar *buff, uint length,
135
 
                            uint block_length,int return_buffer);
 
126
extern int init_key_cache(KEY_CACHE *keycache, uint32_t key_cache_block_size,
 
127
                          uint32_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
                            uint32_t use_mem, uint32_t division_limit,
 
131
                            uint32_t age_threshold);
 
132
extern unsigned char *key_cache_read(KEY_CACHE *keycache,
 
133
                            int file, my_off_t filepos, int level,
 
134
                            unsigned char *buff, uint32_t length,
 
135
                            uint32_t block_length,int return_buffer);
136
136
extern int key_cache_insert(KEY_CACHE *keycache,
137
 
                            File file, my_off_t filepos, int level,
138
 
                            uchar *buff, uint length);
 
137
                            int file, my_off_t filepos, int level,
 
138
                            unsigned char *buff, uint32_t length);
139
139
extern int key_cache_write(KEY_CACHE *keycache,
140
 
                           File file, my_off_t filepos, int level,
141
 
                           uchar *buff, uint length,
142
 
                           uint block_length,int force_write);
 
140
                           int file, my_off_t filepos, int level,
 
141
                           unsigned char *buff, uint32_t length,
 
142
                           uint32_t block_length,int force_write);
143
143
extern int flush_key_blocks(KEY_CACHE *keycache,
144
144
                            int file, enum flush_type type);
145
145
extern void end_key_cache(KEY_CACHE *keycache, bool cleanup);
146
146
 
147
 
/* Functions to handle multiple key caches */
148
 
extern bool multi_keycache_init(void);
149
 
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
 
                                   KEY_CACHE *key_cache);
153
 
extern void multi_key_cache_change(KEY_CACHE *old_data,
154
 
                                   KEY_CACHE *new_data);
155
 
extern int reset_key_cache_counters(const char *name,
156
 
                                    KEY_CACHE *key_cache);
157
 
C_MODE_END
158
 
#endif /* _keycache_h */
 
147
extern void reset_key_cache_counters();
 
148
 
 
149
#ifdef __cplusplus
 
150
}
 
151
#endif
 
152
 
 
153
#endif /* PLUGIN_MYISAM_KEYCACHE_H */