3rdparty/mysql/include/keycache.h

   1 /* Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.
   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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA */
  15
  16 /* Key cache variable structures */
  17
  18 #ifndef _keycache_h
  19 #define _keycache_h
  20
  21 #include "my_sys.h"                             /* flush_type */
  22
  23 C_MODE_START
  24
  25 /* declare structures that is used by st_key_cache */
  26
  27 struct st_block_link;
  28 typedef struct st_block_link BLOCK_LINK;
  29 struct st_hash_link;
  30 typedef struct st_hash_link HASH_LINK;
  31
  32 /* Thread specific variables */
  33 typedef struct st_keycache_thread_var
  34 {
  35   mysql_cond_t suspend;
  36   struct st_keycache_thread_var *next,**prev;
  37   void *opt_info;
  38 } st_keycache_thread_var;
  39
  40 /* info about requests in a waiting queue */
  41 typedef struct st_keycache_wqueue
  42 {
  43   st_keycache_thread_var *last_thread;  /* circular list of waiting threads */
  44 } KEYCACHE_WQUEUE;
  45
  46 #define CHANGED_BLOCKS_HASH 128             /* must be power of 2 */
  47
  48 /*
  49   The key cache structure
  50   It also contains read-only statistics parameters.
  51 */
  52
  53 typedef struct st_key_cache
  54 {
  55   my_bool key_cache_inited;
  56   my_bool in_resize;             /* true during resize operation             */
  57   my_bool resize_in_flush;       /* true during flush of resize operation    */
  58   my_bool can_be_used;           /* usage of cache for read/write is allowed */
  59   size_t key_cache_mem_size;      /* specified size of the cache memory       */
  60   uint key_cache_block_size;     /* size of the page buffer of a cache block */
  61   ulonglong min_warm_blocks;     /* min number of warm blocks;               */
  62   ulonglong age_threshold;       /* age threshold for hot blocks             */
  63   ulonglong keycache_time;       /* total number of block link operations    */
  64   uint hash_entries;             /* max number of entries in the hash table  */
  65   int hash_links;                /* max number of hash links                 */
  66   int hash_links_used;           /* number of hash links currently used      */
  67   int disk_blocks;               /* max number of blocks in the cache        */
  68   ulong blocks_used; /* maximum number of concurrently used blocks */
  69   ulong blocks_unused; /* number of currently unused blocks */
  70   ulong blocks_changed;          /* number of currently dirty blocks         */
  71   ulong warm_blocks;             /* number of blocks in warm sub-chain       */
  72   ulong cnt_for_resize_op;       /* counter to block resize operation        */
  73   long blocks_available;      /* number of blocks available in the LRU chain */
  74   HASH_LINK **hash_root;         /* arr. of entries into hash table buckets  */
  75   HASH_LINK *hash_link_root;     /* memory for hash table links              */
  76   HASH_LINK *free_hash_list;     /* list of free hash links                  */
  77   BLOCK_LINK *free_block_list;   /* list of free blocks */
  78   BLOCK_LINK *block_root;        /* memory for block links                   */
  79   uchar *block_mem;              /* memory for block buffers                 */
  80   BLOCK_LINK *used_last;         /* ptr to the last block of the LRU chain   */
  81   BLOCK_LINK *used_ins;          /* ptr to the insertion block in LRU chain  */
  82   mysql_mutex_t cache_lock;      /* to lock access to the cache structure    */
  83   KEYCACHE_WQUEUE resize_queue;  /* threads waiting during resize operation  */
  84   /*
  85     Waiting for a zero resize count. Using a queue for symmetry though
  86     only one thread can wait here.
  87   */
  88   KEYCACHE_WQUEUE waiting_for_resize_cnt;
  89   KEYCACHE_WQUEUE waiting_for_hash_link; /* waiting for a free hash link     */
  90   KEYCACHE_WQUEUE waiting_for_block;    /* requests waiting for a free block */
  91   BLOCK_LINK *changed_blocks[CHANGED_BLOCKS_HASH]; /* hash for dirty file bl.*/
  92   BLOCK_LINK *file_blocks[CHANGED_BLOCKS_HASH];    /* hash for other file bl.*/
  93
  94   /*
  95     The following variables are and variables used to hold parameters for
  96     initializing the key cache.
  97   */
  98
  99   ulonglong param_buff_size;      /* size the memory allocated for the cache  */
 100   ulonglong param_block_size;     /* size of the blocks in the key cache      */
 101   ulonglong param_division_limit; /* min. percentage of warm blocks           */
 102   ulonglong param_age_threshold;  /* determines when hot block is downgraded  */
 103
 104   /* Statistics variables. These are reset in reset_key_cache_counters(). */
 105   ulong global_blocks_changed;  /* number of currently dirty blocks         */
 106   ulonglong global_cache_w_requests;/* number of write requests (write hits) */
 107   ulonglong global_cache_write;     /* number of writes from cache to files  */
 108   ulonglong global_cache_r_requests;/* number of read requests (read hits)   */
 109   ulonglong global_cache_read;      /* number of reads from files to cache   */
 110
 111   int blocks;                   /* max number of blocks in the cache        */
 112   my_bool in_init;              /* Set to 1 in MySQL during init/resize     */
 113 } KEY_CACHE;
 114
 115 /* The default key cache */
 116 extern KEY_CACHE dflt_key_cache_var, *dflt_key_cache;
 117
 118 extern int init_key_cache(KEY_CACHE *keycache, ulonglong key_cache_block_size,
 119                           size_t use_mem, ulonglong division_limit,
 120                           ulonglong age_threshold);
 121 extern int resize_key_cache(KEY_CACHE *keycache,
 122                             st_keycache_thread_var *thread_var,
 123                             ulonglong key_cache_block_size,
 124                             size_t use_mem, ulonglong division_limit,
 125                             ulonglong age_threshold);
 126 extern uchar *key_cache_read(KEY_CACHE *keycache,
 127                              st_keycache_thread_var *thread_var,
 128                              File file, my_off_t filepos, int level,
 129                              uchar *buff, uint length,
 130                              uint block_length,int return_buffer);
 131 extern int key_cache_insert(KEY_CACHE *keycache,
 132                             st_keycache_thread_var *thread_var,
 133                             File file, my_off_t filepos, int level,
 134                             uchar *buff, uint length);
 135 extern int key_cache_write(KEY_CACHE *keycache,
 136                            st_keycache_thread_var *thread_var,
 137                            File file, my_off_t filepos, int level,
 138                            uchar *buff, uint length,
 139                            uint block_length,int force_write);
 140 extern int flush_key_blocks(KEY_CACHE *keycache,
 141                             st_keycache_thread_var *thread_var,
 142                             int file, enum flush_type type);
 143 extern void end_key_cache(KEY_CACHE *keycache, my_bool cleanup);
 144
 145 /* Functions to handle multiple key caches */
 146 extern my_bool multi_keycache_init(void);
 147 extern void multi_keycache_free(void);
 148 extern KEY_CACHE *multi_key_cache_search(uchar *key, uint length);
 149 extern my_bool multi_key_cache_set(const uchar *key, uint length,
 150                                    KEY_CACHE *key_cache);
 151 extern void multi_key_cache_change(KEY_CACHE *old_data,
 152                                    KEY_CACHE *new_data);
 153 extern int reset_key_cache_counters(const char *name,
 154                                     KEY_CACHE *key_cache);
 155 C_MODE_END
 156 #endif /* _keycache_h */