← Back to branch summary

~ubuntu-branches/ubuntu/saucy/drizzle/saucy-proposed

« back to all changes in this revision

Viewing changes to plugin/myisam/keycache.h

  • Committer: Bazaar Package Importer
  • Author(s): Monty Taylor
  • Date: 2010-03-18 12:12:31 UTC
  • Revision ID: james.westby@ubuntu.com-20100318121231-k6g1xe6cshbwa0f8
Tags: upstream-2010.03.1347
Import upstream version 2010.03.1347

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/myisam/keycache.h
 
1
/* Copyright (C) 2003 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
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 */
 
15
 
 
16
/* Key cache variable structures */
 
17
 
 
18
#ifndef PLUGIN_MYISAM_KEYCACHE_H
 
19
#define PLUGIN_MYISAM_KEYCACHE_H
 
20
 
 
21
enum flush_type
 
22
{
 
23
  FLUSH_KEEP,           /* flush block and keep it in the cache */
 
24
  FLUSH_RELEASE,        /* flush block and remove it from the cache */
 
25
  FLUSH_IGNORE_CHANGED, /* remove block from the cache */
 
26
  /*
 
27
 *     As my_disable_flush_pagecache_blocks is always 0, the following option
 
28
 *         is strictly equivalent to FLUSH_KEEP
 
29
 *           */
 
30
  FLUSH_FORCE_WRITE
 
31
};
 
32
 
 
33
 
 
34
/* declare structures that is used by st_key_cache */
 
35
 
 
36
struct st_block_link;
 
37
typedef struct st_block_link BLOCK_LINK;
 
38
struct st_keycache_page;
 
39
typedef struct st_keycache_page KEYCACHE_PAGE;
 
40
struct st_hash_link;
 
41
typedef struct st_hash_link HASH_LINK;
 
42
 
 
43
namespace drizzled
 
44
{
 
45
namespace internal
 
46
{
 
47
typedef uint64_t my_off_t;
 
48
struct st_my_thread_var;
 
49
}
 
50
 
 
51
/* info about requests in a waiting queue */
 
52
typedef struct st_keycache_wqueue
 
53
{
 
54
  drizzled::internal::st_my_thread_var *last_thread;  /* circular list of waiting threads */
 
55
} KEYCACHE_WQUEUE;
 
56
 
 
57
#define CHANGED_BLOCKS_HASH 128             /* must be power of 2 */
 
58
 
 
59
/*
 
60
  The key cache structure
 
61
  It also contains read-only statistics parameters.
 
62
*/
 
63
 
 
64
typedef struct st_key_cache
 
65
{
 
66
  bool key_cache_inited;
 
67
  bool in_resize;             /* true during resize operation             */
 
68
  bool resize_in_flush;       /* true during flush of resize operation    */
 
69
  bool can_be_used;           /* usage of cache for read/write is allowed */
 
70
  uint32_t hash_entries;             /* max number of entries in the hash table  */
 
71
  uint32_t key_cache_mem_size;      /* specified size of the cache memory       */
 
72
  uint32_t key_cache_block_size;     /* size of the page buffer of a cache block */
 
73
  int disk_blocks;               /* max number of blocks in the cache        */
 
74
  ulong min_warm_blocks;         /* min number of warm blocks;               */
 
75
  ulong age_threshold;           /* age threshold for hot blocks             */
 
76
  uint64_t keycache_time;       /* total number of block link operations    */
 
77
  int hash_links;                /* max number of hash links                 */
 
78
  int hash_links_used;           /* number of hash links currently used      */
 
79
  ulong blocks_used; /* maximum number of concurrently used blocks */
 
80
  ulong blocks_unused; /* number of currently unused blocks */
 
81
  ulong blocks_changed;          /* number of currently dirty blocks         */
 
82
  ulong warm_blocks;             /* number of blocks in warm sub-chain       */
 
83
  ulong cnt_for_resize_op;       /* counter to block resize operation        */
 
84
  long blocks_available;      /* number of blocks available in the LRU chain */
 
85
  HASH_LINK **hash_root;         /* arr. of entries into hash table buckets  */
 
86
  HASH_LINK *hash_link_root;     /* memory for hash table links              */
 
87
  HASH_LINK *free_hash_list;     /* list of free hash links                  */
 
88
  BLOCK_LINK *free_block_list;   /* list of free blocks */
 
89
  BLOCK_LINK *block_root;        /* memory for block links                   */
 
90
  unsigned char *block_mem;     /* memory for block buffers                 */
 
91
  BLOCK_LINK *used_last;         /* ptr to the last block of the LRU chain   */
 
92
  BLOCK_LINK *used_ins;          /* ptr to the insertion block in LRU chain  */
 
93
  pthread_mutex_t cache_lock;    /* to lock access to the cache structure    */
 
94
  KEYCACHE_WQUEUE resize_queue;  /* threads waiting during resize operation  */
 
95
  /*
 
96
    Waiting for a zero resize count. Using a queue for symmetry though
 
97
    only one thread can wait here.
 
98
  */
 
99
  KEYCACHE_WQUEUE waiting_for_resize_cnt;
 
100
  KEYCACHE_WQUEUE waiting_for_hash_link; /* waiting for a free hash link     */
 
101
  KEYCACHE_WQUEUE waiting_for_block;    /* requests waiting for a free block */
 
102
  BLOCK_LINK *changed_blocks[CHANGED_BLOCKS_HASH]; /* hash for dirty file bl.*/
 
103
  BLOCK_LINK *file_blocks[CHANGED_BLOCKS_HASH];    /* hash for other file bl.*/
 
104
 
 
105
  /*
 
106
    The following variables are and variables used to hold parameters for
 
107
    initializing the key cache.
 
108
  */
 
109
 
 
110
  uint32_t param_buff_size;    /* size the memory allocated for the cache  */
 
111
  uint32_t param_block_size;   /* size of the blocks in the key cache      */
 
112
  uint32_t param_division_limit; /* min. percentage of warm blocks           */
 
113
  uint32_t param_age_threshold;    /* determines when hot block is downgraded  */
 
114
 
 
115
  int blocks;                   /* max number of blocks in the cache        */
 
116
  /* Statistics variables. These are reset in reset_key_cache_counters(). */
 
117
  ulong global_blocks_changed;  /* number of currently dirty blocks         */
 
118
  uint64_t global_cache_w_requests;/* number of write requests (write hits) */
 
119
  uint64_t global_cache_write;     /* number of writes from cache to files  */
 
120
  uint64_t global_cache_r_requests;/* number of read requests (read hits)   */
 
121
  uint64_t global_cache_read;      /* number of reads from files to cache   */
 
122
 
 
123
  bool in_init;         /* Set to 1 in MySQL during init/resize     */
 
124
} KEY_CACHE;
 
125
 
 
126
} /* namespace drizzled */
 
127
 
 
128
/* The default key cache */
 
129
extern drizzled::KEY_CACHE dflt_key_cache_var, *dflt_key_cache;
 
130
 
 
131
extern int init_key_cache(drizzled::KEY_CACHE *keycache, uint32_t key_cache_block_size,
 
132
                          size_t use_mem, uint32_t division_limit,
 
133
                          uint32_t age_threshold);
 
134
extern int resize_key_cache(drizzled::KEY_CACHE *keycache, uint32_t key_cache_block_size,
 
135
                            size_t use_mem, uint32_t division_limit,
 
136
                            uint32_t age_threshold);
 
137
extern unsigned char *key_cache_read(drizzled::KEY_CACHE *keycache,
 
138
                            int file, drizzled::internal::my_off_t filepos, int level,
 
139
                            unsigned char *buff, uint32_t length,
 
140
                            uint32_t block_length,int return_buffer);
 
141
extern int key_cache_insert(drizzled::KEY_CACHE *keycache,
 
142
                            int file, drizzled::internal::my_off_t filepos, int level,
 
143
                            unsigned char *buff, uint32_t length);
 
144
extern int key_cache_write(drizzled::KEY_CACHE *keycache,
 
145
                           int file, drizzled::internal::my_off_t filepos, int level,
 
146
                           unsigned char *buff, uint32_t length,
 
147
                           uint32_t block_length,int force_write);
 
148
extern int flush_key_blocks(drizzled::KEY_CACHE *keycache,
 
149
                            int file, enum flush_type type);
 
150
extern void end_key_cache(drizzled::KEY_CACHE *keycache, bool cleanup);
 
151
 
 
152
extern void reset_key_cache_counters();
 
153
 
 
154
/*
 
155
  Next highest power of two
 
156
 
 
157
  SYNOPSIS
 
158
    my_round_up_to_next_power()
 
159
    v           Value to check
 
160
 
 
161
  RETURN
 
162
    Next or equal power of 2
 
163
    Note: 0 will return 0
 
164
 
 
165
  NOTES
 
166
    Algorithm by Sean Anderson, according to:
 
167
    http://graphics.stanford.edu/~seander/bithacks.html
 
168
    (Orignal code public domain)
 
169
 
 
170
    Comments shows how this works with 01100000000000000000000000001011
 
171
*/
 
172
 
 
173
static inline uint32_t my_round_up_to_next_power(uint32_t v)
 
174
{
 
175
  v--;                  /* 01100000000000000000000000001010 */
 
176
  v|= v >> 1;           /* 01110000000000000000000000001111 */
 
177
  v|= v >> 2;           /* 01111100000000000000000000001111 */
 
178
  v|= v >> 4;           /* 01111111110000000000000000001111 */
 
179
  v|= v >> 8;           /* 01111111111111111100000000001111 */
 
180
  v|= v >> 16;          /* 01111111111111111111111111111111 */
 
181
  return v+1;           /* 10000000000000000000000000000000 */
 
182
}
 
183
 
 
184
 
 
185
#endif /* PLUGIN_MYISAM_KEYCACHE_H */