home *** CD-ROM | disk | FTP | other *** search
/ PC World 2008 March (DVD) / PCWorld_2008-03_DVD.iso / komunikace / mysql / mysql-essential-5.0.45-win32.msi / product.cab / fili250 < prev    next >
Encoding:
Text File  |  2007-07-06  |  6.6 KB  |  139 lines
  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
  20. C_MODE_START
  21.  
  22. /* declare structures that is used by st_key_cache */
  23.  
  24. struct st_block_link;
  25. typedef struct st_block_link BLOCK_LINK;
  26. struct st_keycache_page;
  27. typedef struct st_keycache_page KEYCACHE_PAGE;
  28. struct st_hash_link;
  29. typedef struct st_hash_link HASH_LINK;
  30.  
  31. /* info about requests in a waiting queue */
  32. typedef 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.  
  44. typedef struct st_key_cache
  45. {
  46.   my_bool key_cache_inited;
  47.   my_bool resize_in_flush;       /* true during flush of resize operation    */
  48.   my_bool can_be_used;           /* usage of cache for read/write is allowed */
  49.   uint key_cache_shift;
  50.   ulong 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.   byte 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.   KEYCACHE_WQUEUE waiting_for_hash_link; /* waiting for a free hash link     */
  76.   KEYCACHE_WQUEUE waiting_for_block;    /* requests waiting for a free block */
  77.   BLOCK_LINK *changed_blocks[CHANGED_BLOCKS_HASH]; /* hash for dirty file bl.*/
  78.   BLOCK_LINK *file_blocks[CHANGED_BLOCKS_HASH];    /* hash for other file bl.*/
  79.  
  80.   /*
  81.     The following variables are and variables used to hold parameters for
  82.     initializing the key cache.
  83.   */
  84.  
  85.   ulonglong param_buff_size;    /* size the memory allocated for the cache  */
  86.   ulong param_block_size;       /* size of the blocks in the key cache      */
  87.   ulong param_division_limit;   /* min. percentage of warm blocks           */
  88.   ulong param_age_threshold;    /* determines when hot block is downgraded  */
  89.  
  90.   /* Statistics variables. These are reset in reset_key_cache_counters(). */
  91.   ulong global_blocks_changed;    /* number of currently dirty blocks         */
  92.   ulonglong global_cache_w_requests;/* number of write requests (write hits) */
  93.   ulonglong global_cache_write;     /* number of writes from cache to files  */
  94.   ulonglong global_cache_r_requests;/* number of read requests (read hits)   */
  95.   ulonglong global_cache_read;      /* number of reads from files to cache   */
  96.  
  97.   int blocks;                   /* max number of blocks in the cache        */
  98.   my_bool in_init;        /* Set to 1 in MySQL during init/resize     */
  99. } KEY_CACHE;
  100.  
  101. /* The default key cache */
  102. extern KEY_CACHE dflt_key_cache_var, *dflt_key_cache;
  103.  
  104. extern int init_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
  105.               ulong use_mem, uint division_limit,
  106.               uint age_threshold);
  107. extern int resize_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
  108.                 ulong use_mem, uint division_limit,
  109.                 uint age_threshold);
  110. extern void change_key_cache_param(KEY_CACHE *keycache, uint division_limit,
  111.                    uint age_threshold);
  112. extern byte *key_cache_read(KEY_CACHE *keycache,
  113.                             File file, my_off_t filepos, int level,
  114.                             byte *buff, uint length,
  115.                 uint block_length,int return_buffer);
  116. extern int key_cache_insert(KEY_CACHE *keycache,
  117.                             File file, my_off_t filepos, int level,
  118.                             byte *buff, uint length);
  119. extern int key_cache_write(KEY_CACHE *keycache,
  120.                            File file, my_off_t filepos, int level,
  121.                            byte *buff, uint length,
  122.                uint block_length,int force_write);
  123. extern int flush_key_blocks(KEY_CACHE *keycache,
  124.                             int file, enum flush_type type);
  125. extern void end_key_cache(KEY_CACHE *keycache, my_bool cleanup);
  126.  
  127. /* Functions to handle multiple key caches */
  128. extern my_bool multi_keycache_init(void);
  129. extern void multi_keycache_free(void);
  130. extern KEY_CACHE *multi_key_cache_search(byte *key, uint length);
  131. extern my_bool multi_key_cache_set(const byte *key, uint length,
  132.                    KEY_CACHE *key_cache);
  133. extern void multi_key_cache_change(KEY_CACHE *old_data,
  134.                    KEY_CACHE *new_data);
  135. extern int reset_key_cache_counters(const char *name,
  136.                                     KEY_CACHE *key_cache);
  137. C_MODE_END
  138. #endif /* _keycache_h */
  139.