PageRenderTime 30ms CodeModel.GetById 21ms app.highlight 7ms RepoModel.GetById 1ms app.codeStats 0ms

/mysql/include/mysql/keycache.h

http://ghostcb.googlecode.com/
C++ Header | 143 lines | 96 code | 15 blank | 32 comment | 0 complexity | bef6256929d3324d2df79383dbb7c6f0 MD5 | raw file
  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 _keycache_h
 19#define _keycache_h
 20C_MODE_START
 21
 22/* declare structures that is used by st_key_cache */
 23
 24struct st_block_link;
 25typedef struct st_block_link BLOCK_LINK;
 26struct st_keycache_page;
 27typedef struct st_keycache_page KEYCACHE_PAGE;
 28struct st_hash_link;
 29typedef struct st_hash_link HASH_LINK;
 30
 31/* info about requests in a waiting queue */
 32typedef struct st_keycache_wqueue
 33{
 34  struct st_my_thread_var *last_thread;  /* circular list of waiting threads */
 35} KEYCACHE_WQUEUE;
 36
 37#define CHANGED_BLOCKS_HASH 128             /* must be power of 2 */
 38
 39/*
 40  The key cache structure
 41  It also contains read-only statistics parameters.
 42*/   
 43
 44typedef struct st_key_cache
 45{
 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 */
 50  size_t key_cache_mem_size;      /* specified size of the cache memory       */
 51  uint key_cache_block_size;     /* size of the page buffer of a cache block */
 52  ulong min_warm_blocks;         /* min number of warm blocks;               */
 53  ulong age_threshold;           /* age threshold for hot blocks             */
 54  ulonglong keycache_time;       /* total number of block link operations    */
 55  uint hash_entries;             /* max number of entries in the hash table  */
 56  int hash_links;                /* max number of hash links                 */
 57  int hash_links_used;           /* number of hash links currently used      */
 58  int disk_blocks;               /* max number of blocks in the cache        */
 59  ulong blocks_used; /* maximum number of concurrently used blocks */
 60  ulong blocks_unused; /* number of currently unused blocks */
 61  ulong blocks_changed;          /* number of currently dirty blocks         */
 62  ulong warm_blocks;             /* number of blocks in warm sub-chain       */
 63  ulong cnt_for_resize_op;       /* counter to block resize operation        */
 64  long blocks_available;      /* number of blocks available in the LRU chain */
 65  HASH_LINK **hash_root;         /* arr. of entries into hash table buckets  */
 66  HASH_LINK *hash_link_root;     /* memory for hash table links              */
 67  HASH_LINK *free_hash_list;     /* list of free hash links                  */
 68  BLOCK_LINK *free_block_list;   /* list of free blocks */
 69  BLOCK_LINK *block_root;        /* memory for block links                   */
 70  uchar HUGE_PTR *block_mem;     /* memory for block buffers                 */
 71  BLOCK_LINK *used_last;         /* ptr to the last block of the LRU chain   */
 72  BLOCK_LINK *used_ins;          /* ptr to the insertion block in LRU chain  */
 73  pthread_mutex_t cache_lock;    /* to lock access to the cache structure    */
 74  KEYCACHE_WQUEUE resize_queue;  /* threads waiting during resize operation  */
 75  /*
 76    Waiting for a zero resize count. Using a queue for symmetry though
 77    only one thread can wait here.
 78  */
 79  KEYCACHE_WQUEUE waiting_for_resize_cnt;
 80  KEYCACHE_WQUEUE waiting_for_hash_link; /* waiting for a free hash link     */
 81  KEYCACHE_WQUEUE waiting_for_block;    /* requests waiting for a free block */
 82  BLOCK_LINK *changed_blocks[CHANGED_BLOCKS_HASH]; /* hash for dirty file bl.*/
 83  BLOCK_LINK *file_blocks[CHANGED_BLOCKS_HASH];    /* hash for other file bl.*/
 84
 85  /*
 86    The following variables are and variables used to hold parameters for
 87    initializing the key cache.
 88  */
 89
 90  ulonglong param_buff_size;    /* size the memory allocated for the cache  */
 91  ulong param_block_size;       /* size of the blocks in the key cache      */
 92  ulong param_division_limit;   /* min. percentage of warm blocks           */
 93  ulong param_age_threshold;    /* determines when hot block is downgraded  */
 94
 95  /* Statistics variables. These are reset in reset_key_cache_counters(). */
 96  ulong global_blocks_changed;	/* number of currently dirty blocks         */
 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   */
101
102  int blocks;                   /* max number of blocks in the cache        */
103  my_bool in_init;		/* Set to 1 in MySQL during init/resize     */
104} KEY_CACHE;
105
106/* The default key cache */
107extern KEY_CACHE dflt_key_cache_var, *dflt_key_cache;
108
109extern int init_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
110			  size_t use_mem, uint division_limit,
111			  uint age_threshold);
112extern int resize_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
113			    size_t use_mem, uint division_limit,
114			    uint age_threshold);
115extern void change_key_cache_param(KEY_CACHE *keycache, uint division_limit,
116				   uint age_threshold);
117extern uchar *key_cache_read(KEY_CACHE *keycache,
118                            File file, my_off_t filepos, int level,
119                            uchar *buff, uint length,
120			    uint block_length,int return_buffer);
121extern int key_cache_insert(KEY_CACHE *keycache,
122                            File file, my_off_t filepos, int level,
123                            uchar *buff, uint length);
124extern int key_cache_write(KEY_CACHE *keycache,
125                           File file, my_off_t filepos, int level,
126                           uchar *buff, uint length,
127			   uint block_length,int force_write);
128extern int flush_key_blocks(KEY_CACHE *keycache,
129                            int file, enum flush_type type);
130extern void end_key_cache(KEY_CACHE *keycache, my_bool cleanup);
131
132/* Functions to handle multiple key caches */
133extern my_bool multi_keycache_init(void);
134extern void multi_keycache_free(void);
135extern KEY_CACHE *multi_key_cache_search(uchar *key, uint length);
136extern my_bool multi_key_cache_set(const uchar *key, uint length,
137				   KEY_CACHE *key_cache);
138extern void multi_key_cache_change(KEY_CACHE *old_data,
139				   KEY_CACHE *new_data);
140extern int reset_key_cache_counters(const char *name,
141                                    KEY_CACHE *key_cache);
142C_MODE_END
143#endif /* _keycache_h */