← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to include/keycache.h

  • Committer: Stewart Smith
  • Date: 2008-06-30 06:46:40 UTC
  • mto: This revision was merged to the branch mainline in revision 19.
  • Revision ID: stewart@flamingspork.com-20080630064640-1tbyi1e8j4duba45
no embedded server, stop testing for it in tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/keycache.h
17
17
 
18
18
#ifndef _keycache_h
19
19
#define _keycache_h
20
 
 
21
 
#include <drizzled/global.h>
22
 
 
23
 
#ifdef __cplusplus
24
 
extern "C" {
25
 
#endif
26
 
 
27
 
enum flush_type
28
 
{
29
 
  FLUSH_KEEP,           /* flush block and keep it in the cache */
30
 
  FLUSH_RELEASE,        /* flush block and remove it from the cache */
31
 
  FLUSH_IGNORE_CHANGED, /* remove block from the cache */
32
 
  /*
33
 
 *     As my_disable_flush_pagecache_blocks is always 0, the following option
34
 
 *         is strictly equivalent to FLUSH_KEEP
35
 
 *           */
36
 
  FLUSH_FORCE_WRITE
37
 
};
 
20
C_MODE_START
38
21
 
39
22
/* declare structures that is used by st_key_cache */
40
23
 
60
43
 
61
44
typedef struct st_key_cache
62
45
{
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 */
 
46
  my_bool key_cache_inited;
 
47
  my_bool in_resize;             /* true during resize operation             */
 
48
  my_bool resize_in_flush;       /* true during flush of resize operation    */
 
49
  my_bool can_be_used;           /* usage of cache for read/write is allowed */
67
50
  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 */
 
51
  uint key_cache_block_size;     /* size of the page buffer of a cache block */
69
52
  ulong min_warm_blocks;         /* min number of warm blocks;               */
70
53
  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  */
 
54
  ulonglong keycache_time;       /* total number of block link operations    */
 
55
  uint hash_entries;             /* max number of entries in the hash table  */
73
56
  int hash_links;                /* max number of hash links                 */
74
57
  int hash_links_used;           /* number of hash links currently used      */
75
58
  int disk_blocks;               /* max number of blocks in the cache        */
84
67
  HASH_LINK *free_hash_list;     /* list of free hash links                  */
85
68
  BLOCK_LINK *free_block_list;   /* list of free blocks */
86
69
  BLOCK_LINK *block_root;        /* memory for block links                   */
87
 
  unsigned char *block_mem;     /* memory for block buffers                 */
 
70
  uchar *block_mem;     /* memory for block buffers                 */
88
71
  BLOCK_LINK *used_last;         /* ptr to the last block of the LRU chain   */
89
72
  BLOCK_LINK *used_ins;          /* ptr to the insertion block in LRU chain  */
90
73
  pthread_mutex_t cache_lock;    /* to lock access to the cache structure    */
104
87
    initializing the key cache.
105
88
  */
106
89
 
107
 
  uint64_t param_buff_size;    /* size the memory allocated for the cache  */
 
90
  ulonglong param_buff_size;    /* size the memory allocated for the cache  */
108
91
  ulong param_block_size;       /* size of the blocks in the key cache      */
109
92
  ulong param_division_limit;   /* min. percentage of warm blocks           */
110
93
  ulong param_age_threshold;    /* determines when hot block is downgraded  */
111
94
 
112
95
  /* Statistics variables. These are reset in reset_key_cache_counters(). */
113
96
  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   */
 
97
  ulonglong global_cache_w_requests;/* number of write requests (write hits) */
 
98
  ulonglong global_cache_write;     /* number of writes from cache to files  */
 
99
  ulonglong global_cache_r_requests;/* number of read requests (read hits)   */
 
100
  ulonglong global_cache_read;      /* number of reads from files to cache   */
118
101
 
119
102
  int blocks;                   /* max number of blocks in the cache        */
120
 
  bool in_init;         /* Set to 1 in MySQL during init/resize     */
 
103
  my_bool in_init;              /* Set to 1 in MySQL during init/resize     */
121
104
} KEY_CACHE;
122
105
 
123
106
/* The default key cache */
124
107
extern KEY_CACHE dflt_key_cache_var, *dflt_key_cache;
125
108
 
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,
 
109
extern int init_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
 
110
                          size_t use_mem, uint division_limit,
 
111
                          uint age_threshold);
 
112
extern int resize_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
 
113
                            size_t use_mem, uint division_limit,
 
114
                            uint age_threshold);
 
115
extern void change_key_cache_param(KEY_CACHE *keycache, uint division_limit,
 
116
                                   uint age_threshold);
 
117
extern uchar *key_cache_read(KEY_CACHE *keycache,
135
118
                            File file, my_off_t filepos, int level,
136
 
                            unsigned char *buff, uint32_t length,
137
 
                            uint32_t block_length,int return_buffer);
 
119
                            uchar *buff, uint length,
 
120
                            uint block_length,int return_buffer);
138
121
extern int key_cache_insert(KEY_CACHE *keycache,
139
122
                            File file, my_off_t filepos, int level,
140
 
                            unsigned char *buff, uint32_t length);
 
123
                            uchar *buff, uint length);
141
124
extern int key_cache_write(KEY_CACHE *keycache,
142
125
                           File file, my_off_t filepos, int level,
143
 
                           unsigned char *buff, uint32_t length,
144
 
                           uint32_t block_length,int force_write);
 
126
                           uchar *buff, uint length,
 
127
                           uint block_length,int force_write);
145
128
extern int flush_key_blocks(KEY_CACHE *keycache,
146
129
                            int file, enum flush_type type);
147
 
extern void end_key_cache(KEY_CACHE *keycache, bool cleanup);
 
130
extern void end_key_cache(KEY_CACHE *keycache, my_bool cleanup);
148
131
 
149
132
/* Functions to handle multiple key caches */
150
 
extern bool multi_keycache_init(void);
 
133
extern my_bool multi_keycache_init(void);
151
134
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,
 
135
extern KEY_CACHE *multi_key_cache_search(uchar *key, uint length);
 
136
extern my_bool multi_key_cache_set(const uchar *key, uint length,
154
137
                                   KEY_CACHE *key_cache);
155
138
extern void multi_key_cache_change(KEY_CACHE *old_data,
156
139
                                   KEY_CACHE *new_data);
157
140
extern int reset_key_cache_counters(const char *name,
158
141
                                    KEY_CACHE *key_cache);
159
 
 
160
 
#ifdef __cplusplus
161
 
}
162
 
#endif
163
 
 
 
142
C_MODE_END
164
143
#endif /* _keycache_h */