keycache.h
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:7k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2003 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. /* Key cache variable structures */
  14. #ifndef _keycache_h
  15. #define _keycache_h
  16. C_MODE_START
  17. /* declare structures that is used by st_key_cache */
  18. struct st_block_link;
  19. typedef struct st_block_link BLOCK_LINK;
  20. struct st_keycache_page;
  21. typedef struct st_keycache_page KEYCACHE_PAGE;
  22. struct st_hash_link;
  23. typedef struct st_hash_link HASH_LINK;
  24. /* info about requests in a waiting queue */
  25. typedef struct st_keycache_wqueue
  26. {
  27.   struct st_my_thread_var *last_thread;  /* circular list of waiting threads */
  28. } KEYCACHE_WQUEUE;
  29. #define CHANGED_BLOCKS_HASH 128             /* must be power of 2 */
  30. /*
  31.   The key cache structure
  32.   It also contains read-only statistics parameters.
  33. */   
  34. typedef struct st_key_cache
  35. {
  36.   my_bool key_cache_inited;
  37.   my_bool resize_in_flush;       /* true during flush of resize operation    */
  38.   my_bool can_be_used;           /* usage of cache for read/write is allowed */
  39.   uint key_cache_shift;
  40.   ulong key_cache_mem_size;      /* specified size of the cache memory       */
  41.   uint key_cache_block_size;     /* size of the page buffer of a cache block */
  42.   ulong min_warm_blocks;         /* min number of warm blocks;               */
  43.   ulong age_threshold;           /* age threshold for hot blocks             */
  44.   ulonglong keycache_time;       /* total number of block link operations    */
  45.   uint hash_entries;             /* max number of entries in the hash table  */
  46.   int hash_links;                /* max number of hash links                 */
  47.   int hash_links_used;           /* number of hash links currently used      */
  48.   int disk_blocks;               /* max number of blocks in the cache        */
  49.   ulong blocks_used; /* maximum number of concurrently used blocks */
  50.   ulong blocks_unused; /* number of currently unused blocks */
  51.   ulong blocks_changed;          /* number of currently dirty blocks         */
  52.   ulong warm_blocks;             /* number of blocks in warm sub-chain       */
  53.   ulong cnt_for_resize_op;       /* counter to block resize operation        */
  54.   long blocks_available;      /* number of blocks available in the LRU chain */
  55.   HASH_LINK **hash_root;         /* arr. of entries into hash table buckets  */
  56.   HASH_LINK *hash_link_root;     /* memory for hash table links              */
  57.   HASH_LINK *free_hash_list;     /* list of free hash links                  */
  58.   BLOCK_LINK *free_block_list; /* list of free blocks */
  59.   BLOCK_LINK *block_root;        /* memory for block links                   */
  60.   byte HUGE_PTR *block_mem;      /* memory for block buffers                 */
  61.   BLOCK_LINK *used_last;         /* ptr to the last block of the LRU chain   */
  62.   BLOCK_LINK *used_ins;          /* ptr to the insertion block in LRU chain  */
  63.   pthread_mutex_t cache_lock;    /* to lock access to the cache structure    */
  64.   KEYCACHE_WQUEUE resize_queue;  /* threads waiting during resize operation  */
  65.   KEYCACHE_WQUEUE waiting_for_hash_link; /* waiting for a free hash link     */
  66.   KEYCACHE_WQUEUE waiting_for_block;    /* requests waiting for a free block */
  67.   BLOCK_LINK *changed_blocks[CHANGED_BLOCKS_HASH]; /* hash for dirty file bl.*/
  68.   BLOCK_LINK *file_blocks[CHANGED_BLOCKS_HASH];    /* hash for other file bl.*/
  69.   /*
  70.     The following variables are and variables used to hold parameters for
  71.     initializing the key cache.
  72.   */
  73.   ulonglong param_buff_size;    /* size the memory allocated for the cache  */
  74.   ulong param_block_size;       /* size of the blocks in the key cache      */
  75.   ulong param_division_limit;   /* min. percentage of warm blocks           */
  76.   ulong param_age_threshold;    /* determines when hot block is downgraded  */
  77.   /* Statistics variables. These are reset in reset_key_cache_counters(). */
  78.   ulong global_blocks_changed; /* number of currently dirty blocks         */
  79.   ulonglong global_cache_w_requests;/* number of write requests (write hits) */
  80.   ulonglong global_cache_write;     /* number of writes from cache to files  */
  81.   ulonglong global_cache_r_requests;/* number of read requests (read hits)   */
  82.   ulonglong global_cache_read;      /* number of reads from files to cache   */
  83.   int blocks;                   /* max number of blocks in the cache        */
  84.   my_bool in_init; /* Set to 1 in MySQL during init/resize     */
  85. } KEY_CACHE;
  86. /* The default key cache */
  87. extern KEY_CACHE dflt_key_cache_var, *dflt_key_cache;
  88. extern int init_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
  89.   ulong use_mem, uint division_limit,
  90.   uint age_threshold);
  91. extern int resize_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
  92.     ulong use_mem, uint division_limit,
  93.     uint age_threshold);
  94. extern void change_key_cache_param(KEY_CACHE *keycache, uint division_limit,
  95.    uint age_threshold);
  96. extern byte *key_cache_read(KEY_CACHE *keycache,
  97.                             File file, my_off_t filepos, int level,
  98.                             byte *buff, uint length,
  99.     uint block_length,int return_buffer);
  100. extern int key_cache_insert(KEY_CACHE *keycache,
  101.                             File file, my_off_t filepos, int level,
  102.                             byte *buff, uint length);
  103. extern int key_cache_write(KEY_CACHE *keycache,
  104.                            File file, my_off_t filepos, int level,
  105.                            byte *buff, uint length,
  106.    uint block_length,int force_write);
  107. extern int flush_key_blocks(KEY_CACHE *keycache,
  108.                             int file, enum flush_type type);
  109. extern void end_key_cache(KEY_CACHE *keycache, my_bool cleanup);
  110. /* Functions to handle multiple key caches */
  111. extern my_bool multi_keycache_init(void);
  112. extern void multi_keycache_free(void);
  113. extern KEY_CACHE *multi_key_cache_search(byte *key, uint length);
  114. extern my_bool multi_key_cache_set(const byte *key, uint length,
  115.    KEY_CACHE *key_cache);
  116. extern void multi_key_cache_change(KEY_CACHE *old_data,
  117.    KEY_CACHE *new_data);
  118. extern int reset_key_cache_counters(const char *name,
  119.                                     KEY_CACHE *key_cache);
  120. C_MODE_END
  121. #endif /* _keycache_h */