← 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: 2010-12-08 22:35:56 UTC
  • mfrom: (1819.9.158 update-innobase)
  • Revision ID: brian@tangent.org-20101208223556-37mi4omqg7lkjzf3
Merge in Stewart's changes, 1.3 changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/myisam/keycache.h
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
14
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
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
 
#ifdef __cplusplus
24
 
extern "C" {
25
 
#endif
 
18
#ifndef PLUGIN_MYISAM_KEYCACHE_H
 
19
#define PLUGIN_MYISAM_KEYCACHE_H
26
20
 
27
21
enum flush_type
28
22
{
36
30
  FLUSH_FORCE_WRITE
37
31
};
38
32
 
 
33
 
39
34
/* declare structures that is used by st_key_cache */
40
35
 
41
36
struct st_block_link;
45
40
struct st_hash_link;
46
41
typedef struct st_hash_link HASH_LINK;
47
42
 
 
43
namespace drizzled
 
44
{
 
45
namespace internal
 
46
{
 
47
typedef uint64_t my_off_t;
 
48
struct st_my_thread_var;
 
49
}
 
50
 
48
51
/* info about requests in a waiting queue */
49
52
typedef struct st_keycache_wqueue
50
53
{
51
 
  struct st_my_thread_var *last_thread;  /* circular list of waiting threads */
 
54
  drizzled::internal::st_my_thread_var *last_thread;  /* circular list of waiting threads */
52
55
} KEYCACHE_WQUEUE;
53
56
 
54
57
#define CHANGED_BLOCKS_HASH 128             /* must be power of 2 */
56
59
/*
57
60
  The key cache structure
58
61
  It also contains read-only statistics parameters.
59
 
*/   
 
62
*/
60
63
 
61
64
typedef struct st_key_cache
62
65
{
63
66
  bool key_cache_inited;
64
 
  bool in_resize;             /* true during resize operation             */
65
 
  bool resize_in_flush;       /* true during flush of resize operation    */
66
67
  bool can_be_used;           /* usage of cache for read/write is allowed */
67
 
  size_t key_cache_mem_size;      /* specified size of the cache memory       */
 
68
 
68
69
  uint32_t key_cache_block_size;     /* size of the page buffer of a cache block */
69
 
  ulong min_warm_blocks;         /* min number of warm blocks;               */
70
 
  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  */
73
 
  int hash_links;                /* max number of hash links                 */
74
 
  int hash_links_used;           /* number of hash links currently used      */
75
 
  int disk_blocks;               /* max number of blocks in the cache        */
76
 
  ulong blocks_used; /* maximum number of concurrently used blocks */
77
 
  ulong blocks_unused; /* number of currently unused blocks */
78
 
  ulong blocks_changed;          /* number of currently dirty blocks         */
79
 
  ulong warm_blocks;             /* number of blocks in warm sub-chain       */
80
 
  ulong cnt_for_resize_op;       /* counter to block resize operation        */
81
 
  long blocks_available;      /* number of blocks available in the LRU chain */
82
 
  HASH_LINK **hash_root;         /* arr. of entries into hash table buckets  */
83
 
  HASH_LINK *hash_link_root;     /* memory for hash table links              */
84
 
  HASH_LINK *free_hash_list;     /* list of free hash links                  */
85
 
  BLOCK_LINK *free_block_list;   /* list of free blocks */
86
 
  BLOCK_LINK *block_root;        /* memory for block links                   */
87
 
  unsigned char *block_mem;     /* memory for block buffers                 */
88
 
  BLOCK_LINK *used_last;         /* ptr to the last block of the LRU chain   */
89
 
  BLOCK_LINK *used_ins;          /* ptr to the insertion block in LRU chain  */
90
 
  pthread_mutex_t cache_lock;    /* to lock access to the cache structure    */
91
 
  KEYCACHE_WQUEUE resize_queue;  /* threads waiting during resize operation  */
92
 
  /*
93
 
    Waiting for a zero resize count. Using a queue for symmetry though
94
 
    only one thread can wait here.
95
 
  */
96
 
  KEYCACHE_WQUEUE waiting_for_resize_cnt;
97
 
  KEYCACHE_WQUEUE waiting_for_hash_link; /* waiting for a free hash link     */
98
 
  KEYCACHE_WQUEUE waiting_for_block;    /* requests waiting for a free block */
99
 
  BLOCK_LINK *changed_blocks[CHANGED_BLOCKS_HASH]; /* hash for dirty file bl.*/
100
 
  BLOCK_LINK *file_blocks[CHANGED_BLOCKS_HASH];    /* hash for other file bl.*/
101
 
 
102
 
  /*
103
 
    The following variables are and variables used to hold parameters for
104
 
    initializing the key cache.
105
 
  */
106
 
 
107
 
  uint64_t param_buff_size;    /* size the memory allocated for the cache  */
108
 
  ulong param_block_size;       /* size of the blocks in the key cache      */
109
 
  ulong param_division_limit;   /* min. percentage of warm blocks           */
110
 
  ulong param_age_threshold;    /* determines when hot block is downgraded  */
111
 
 
112
 
  /* Statistics variables. These are reset in reset_key_cache_counters(). */
113
 
  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   */
118
70
 
119
71
  int blocks;                   /* max number of blocks in the cache        */
 
72
 
120
73
  bool in_init;         /* Set to 1 in MySQL during init/resize     */
 
74
 
 
75
  st_key_cache():
 
76
    key_cache_inited(false),
 
77
    can_be_used(false),
 
78
    key_cache_block_size(0),
 
79
    blocks(0),
 
80
    in_init(0)
 
81
  { }
 
82
 
121
83
} KEY_CACHE;
122
84
 
 
85
} /* namespace drizzled */
 
86
 
123
87
/* The default key cache */
124
 
extern KEY_CACHE dflt_key_cache_var, *dflt_key_cache;
125
 
 
126
 
extern int init_key_cache(KEY_CACHE *keycache, uint32_t key_cache_block_size,
 
88
extern int init_key_cache(drizzled::KEY_CACHE *keycache, uint32_t key_cache_block_size,
127
89
                          size_t use_mem, uint32_t division_limit,
128
90
                          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,
135
 
                            File file, my_off_t filepos, int level,
 
91
extern unsigned char *key_cache_read(drizzled::KEY_CACHE *keycache,
 
92
                            int file, drizzled::internal::my_off_t filepos, int level,
136
93
                            unsigned char *buff, uint32_t length,
137
94
                            uint32_t block_length,int return_buffer);
138
 
extern int key_cache_insert(KEY_CACHE *keycache,
139
 
                            File file, my_off_t filepos, int level,
 
95
extern int key_cache_insert(drizzled::KEY_CACHE *keycache,
 
96
                            int file, drizzled::internal::my_off_t filepos, int level,
140
97
                            unsigned char *buff, uint32_t length);
141
 
extern int key_cache_write(KEY_CACHE *keycache,
142
 
                           File file, my_off_t filepos, int level,
 
98
extern int key_cache_write(drizzled::KEY_CACHE *keycache,
 
99
                           int file, drizzled::internal::my_off_t filepos, int level,
143
100
                           unsigned char *buff, uint32_t length,
144
101
                           uint32_t block_length,int force_write);
145
 
extern int flush_key_blocks(KEY_CACHE *keycache,
 
102
extern int flush_key_blocks(drizzled::KEY_CACHE *keycache,
146
103
                            int file, enum flush_type type);
147
 
extern void end_key_cache(KEY_CACHE *keycache, bool cleanup);
148
 
 
149
 
/* Functions to handle multiple key caches */
150
 
extern bool multi_keycache_init(void);
151
 
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,
154
 
                                   KEY_CACHE *key_cache);
155
 
extern void multi_key_cache_change(KEY_CACHE *old_data,
156
 
                                   KEY_CACHE *new_data);
157
 
extern int reset_key_cache_counters(const char *name,
158
 
                                    KEY_CACHE *key_cache);
159
 
 
160
 
#ifdef __cplusplus
 
104
extern void end_key_cache(drizzled::KEY_CACHE *keycache, bool cleanup);
 
105
 
 
106
/*
 
107
  Next highest power of two
 
108
 
 
109
  SYNOPSIS
 
110
    my_round_up_to_next_power()
 
111
    v           Value to check
 
112
 
 
113
  RETURN
 
114
    Next or equal power of 2
 
115
    Note: 0 will return 0
 
116
 
 
117
  NOTES
 
118
    Algorithm by Sean Anderson, according to:
 
119
    http://graphics.stanford.edu/~seander/bithacks.html
 
120
    (Orignal code public domain)
 
121
 
 
122
    Comments shows how this works with 01100000000000000000000000001011
 
123
*/
 
124
 
 
125
static inline uint32_t my_round_up_to_next_power(uint32_t v)
 
126
{
 
127
  v--;                  /* 01100000000000000000000000001010 */
 
128
  v|= v >> 1;           /* 01110000000000000000000000001111 */
 
129
  v|= v >> 2;           /* 01111100000000000000000000001111 */
 
130
  v|= v >> 4;           /* 01111111110000000000000000001111 */
 
131
  v|= v >> 8;           /* 01111111111111111100000000001111 */
 
132
  v|= v >> 16;          /* 01111111111111111111111111111111 */
 
133
  return v+1;           /* 10000000000000000000000000000000 */
161
134
}
162
 
#endif
163
 
 
164
 
#endif /* _keycache_h */
 
135
 
 
136
 
 
137
#endif /* PLUGIN_MYISAM_KEYCACHE_H */