← 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-09-05 22:55:50 UTC
  • mfrom: (373.1.9 stl-client-progs)
  • Revision ID: monty@inaugust.com-20080905225550-zco374c9s7kxwqyb
Merged removal of DYNAMIC_STRING.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/keycache.h
20
20
 
21
21
#include <drizzled/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
{
65
63
  bool resize_in_flush;       /* true during flush of resize operation    */
66
64
  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
69
  uint64_t keycache_time;       /* total number of block link operations    */
72
 
  uint32_t hash_entries;             /* max number of entries in the hash table  */
 
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    */
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
145
extern void end_key_cache(KEY_CACHE *keycache, bool cleanup);
149
147
/* Functions to handle multiple key caches */
150
148
extern 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 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 */