9
3

keycache.h 6.8 KB

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