← 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-10-15 00:22:33 UTC
  • mto: (1183.1.11 merge)
  • mto: This revision was merged to the branch mainline in revision 1198.
  • Revision ID: brian@gaz-20091015002233-fa4ao2mbc67wls91
First pass of information engine. OMG, ponies... is it so much easier to
deal with creating and engine.

The list table iterator though... its ass, needs to go. We should also
abstract out share. Very few engines need a custom one. Just say'in

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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
/* Key cache variable structures */
17
17
 
18
 
#ifndef PLUGIN_MYISAM_KEYCACHE_H
19
 
#define PLUGIN_MYISAM_KEYCACHE_H
 
18
#ifndef _keycache_h
 
19
#define _keycache_h
 
20
 
 
21
#include <drizzled/global.h>
 
22
 
 
23
#ifdef __cplusplus
 
24
extern "C" {
 
25
#endif
20
26
 
21
27
enum flush_type
22
28
{
30
36
  FLUSH_FORCE_WRITE
31
37
};
32
38
 
33
 
 
34
39
/* declare structures that is used by st_key_cache */
35
40
 
36
41
struct st_block_link;
40
45
struct st_hash_link;
41
46
typedef struct st_hash_link HASH_LINK;
42
47
 
43
 
namespace drizzled
44
 
{
45
 
namespace internal
46
 
{
47
 
typedef uint64_t my_off_t;
48
 
struct st_my_thread_var;
49
 
}
50
 
 
51
48
/* info about requests in a waiting queue */
52
49
typedef struct st_keycache_wqueue
53
50
{
54
 
  drizzled::internal::st_my_thread_var *last_thread;  /* circular list of waiting threads */
 
51
  struct st_my_thread_var *last_thread;  /* circular list of waiting threads */
55
52
} KEYCACHE_WQUEUE;
56
53
 
57
54
#define CHANGED_BLOCKS_HASH 128             /* must be power of 2 */
64
61
typedef struct st_key_cache
65
62
{
66
63
  bool key_cache_inited;
 
64
  bool in_resize;             /* true during resize operation             */
 
65
  bool resize_in_flush;       /* true during flush of resize operation    */
67
66
  bool can_be_used;           /* usage of cache for read/write is allowed */
68
 
 
 
67
  uint32_t hash_entries;             /* max number of entries in the hash table  */
 
68
  size_t key_cache_mem_size;      /* specified size of the cache memory       */
69
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        */
 
71
  ulong min_warm_blocks;         /* min number of warm blocks;               */
 
72
  ulong age_threshold;           /* age threshold for hot blocks             */
 
73
  uint64_t keycache_time;       /* total number of block link operations    */
 
74
  int hash_links;                /* max number of hash links                 */
 
75
  int hash_links_used;           /* number of hash links currently used      */
 
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
  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  */
70
111
 
71
112
  int blocks;                   /* max number of blocks in the cache        */
 
113
  /* Statistics variables. These are reset in reset_key_cache_counters(). */
 
114
  ulong global_blocks_changed;  /* number of currently dirty blocks         */
 
115
  uint64_t global_cache_w_requests;/* number of write requests (write hits) */
 
116
  uint64_t global_cache_write;     /* number of writes from cache to files  */
 
117
  uint64_t global_cache_r_requests;/* number of read requests (read hits)   */
 
118
  uint64_t global_cache_read;      /* number of reads from files to cache   */
72
119
 
73
120
  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
 
 
83
121
} KEY_CACHE;
84
122
 
85
 
} /* namespace drizzled */
86
 
 
87
123
/* The default key cache */
88
 
extern int init_key_cache(drizzled::KEY_CACHE *keycache, uint32_t key_cache_block_size,
 
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,
89
127
                          size_t use_mem, uint32_t division_limit,
90
128
                          uint32_t age_threshold);
91
 
extern unsigned char *key_cache_read(drizzled::KEY_CACHE *keycache,
92
 
                            int file, drizzled::internal::my_off_t filepos, int level,
 
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 unsigned char *key_cache_read(KEY_CACHE *keycache,
 
133
                            File file, my_off_t filepos, int level,
93
134
                            unsigned char *buff, uint32_t length,
94
135
                            uint32_t block_length,int return_buffer);
95
 
extern int key_cache_insert(drizzled::KEY_CACHE *keycache,
96
 
                            int file, drizzled::internal::my_off_t filepos, int level,
 
136
extern int key_cache_insert(KEY_CACHE *keycache,
 
137
                            File file, my_off_t filepos, int level,
97
138
                            unsigned char *buff, uint32_t length);
98
 
extern int key_cache_write(drizzled::KEY_CACHE *keycache,
99
 
                           int file, drizzled::internal::my_off_t filepos, int level,
 
139
extern int key_cache_write(KEY_CACHE *keycache,
 
140
                           File file, my_off_t filepos, int level,
100
141
                           unsigned char *buff, uint32_t length,
101
142
                           uint32_t block_length,int force_write);
102
 
extern int flush_key_blocks(drizzled::KEY_CACHE *keycache,
 
143
extern int flush_key_blocks(KEY_CACHE *keycache,
103
144
                            int file, enum flush_type type);
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 */
 
145
extern void end_key_cache(KEY_CACHE *keycache, bool cleanup);
 
146
 
 
147
extern void reset_key_cache_counters();
 
148
 
 
149
#ifdef __cplusplus
134
150
}
135
 
 
136
 
 
137
 
#endif /* PLUGIN_MYISAM_KEYCACHE_H */
 
151
#endif
 
152
 
 
153
#endif /* _keycache_h */