WL#86: Partitioned key cache for MyISAM.

This is the base patch for the task.

1 files changed, 108 insertions, 71 deletions

diff --git a/include/keycache.h b/include/keycache.h
index 8c4ee4afe81..8bfe6044ac5 100644
--- a/include/keycache.h
+++ b/include/keycache.h
@@ -19,96 +19,121 @@
 #define _keycache_h
 C_MODE_START
 
-/* declare structures that is used by st_key_cache */
 
-struct st_block_link;
-typedef struct st_block_link BLOCK_LINK;
-struct st_keycache_page;
-typedef struct st_keycache_page KEYCACHE_PAGE;
-struct st_hash_link;
-typedef struct st_hash_link HASH_LINK;
 
-/* info about requests in a waiting queue */
-typedef struct st_keycache_wqueue
+/* 
+  Currently the default key cache is created as non-partitioned at 
+  the start of the server unless the server is started with the parameter 
+  --key-cache-partitions that is greater than 0
+*/
+
+#define DEFAULT_KEY_CACHE_PARTITIONS    0
+
+/* 
+  MAX_KEY_CACHE_PARTITIONS cannot be greater than 
+  sizeof(MYISAM_SHARE::dirty_part_map)
+  Currently sizeof(MYISAM_SHARE::dirty_part_map)=sizeof(ulonglong)
+*/
+
+#define MAX_KEY_CACHE_PARTITIONS    64
+
+
+/* The structure to get statistical data about a key cache */
+
+typedef struct st_key_cache_statistics
 {
-  struct st_my_thread_var *last_thread;  /* circular list of waiting threads */
-} KEYCACHE_WQUEUE;
+  ulonglong mem_size;       /* memory for cache buffers/auxiliary structures */
+  ulonglong block_size;     /* size of the each buffers in the key cache     */
+  ulonglong blocks_used;    /* maximum number of used blocks/buffers         */ 
+  ulonglong blocks_unused;  /* number of currently unused blocks             */
+  ulonglong blocks_changed; /* number of currently dirty blocks              */
+  ulonglong read_requests;  /* number of read requests (read hits)           */
+  ulonglong reads;        /* number of actual reads from files into buffers  */
+  ulonglong write_requests; /* number of write requests (write hits)         */
+  ulonglong writes;       /* number of actual writes from buffers into files */
+} KEY_CACHE_STATISTICS;
+
+/* The type of a key cache object */
+typedef enum key_cache_type
+{
+  SIMPLE_KEY_CACHE,         
+  PARTITIONED_KEY_CACHE
+} KEY_CACHE_TYPE;
 
-#define CHANGED_BLOCKS_HASH 128             /* must be power of 2 */
 
 /*
-  The key cache structure
-  It also contains read-only statistics parameters.
+  An object of the type KEY_CACHE_FUNCS contains pointers to all functions
+  from the key cache interface.
+  Currently a key cache can be of two types: simple and partitioned.
+  For each of them its own static structure of the type KEY_CACHE_FUNCS is
+  defined . The structures contain the pointers to the implementations of
+  the interface functions used by simple key caches and partitioned key
+  caches respectively. Pointers to these structures are assigned to key cache
+  objects at the time of their creation.
 */   
 
+typedef struct st_key_cache_funcs 
+{
+  int    (*init)    (void *, uint key_cache_block_size,
+                     size_t use_mem, uint division_limit, uint age_threshold);
+  int    (*resize)  (void *, uint key_cache_block_size,
+                     size_t use_mem, uint division_limit, uint age_threshold);
+  void   (*change_param) (void *keycache_cb,
+                          uint division_limit, uint age_threshold);      
+  uchar* (*read)    (void *keycache_cb,
+                     File file, my_off_t filepos, int level,
+                     uchar *buff, uint length,
+                     uint block_length, int return_buffer);
+  int   (*insert)   (void *keycache_cb,
+                     File file, my_off_t filepos, int level,
+                     uchar *buff, uint length);
+  int   (*write)    (void *keycache_cb,
+                     File file, void *file_extra,
+                     my_off_t filepos, int level,
+                     uchar *buff, uint length, 
+                     uint block_length, int force_write);
+  int   (*flush)    (void *keycache_cb,
+                     int file, void *file_extra,
+                     enum flush_type type); 
+  int (*reset_counters) (const char *name, void *keycache_cb); 
+  void (*end)    (void *keycache_cb, my_bool cleanup);
+  void (*get_stats) (void *keycache_cb, uint partition_no, 
+                     KEY_CACHE_STATISTICS *key_cache_stats); 
+  ulonglong (*get_stat_val) (void *keycache_cb, uint var_no);
+} KEY_CACHE_FUNCS;
+
+
 typedef struct st_key_cache
 {
-  my_bool key_cache_inited;
-  my_bool in_resize;             /* true during resize operation             */
-  my_bool resize_in_flush;       /* true during flush of resize operation    */
+  KEY_CACHE_TYPE key_cache_type; /* type of the key cache used for debugging */
+  void *keycache_cb;             /* control block of the used key cache      */
+  KEY_CACHE_FUNCS *interface_funcs; /* interface functions of the key cache  */
+  ulonglong param_buff_size;     /* size the memory allocated for the cache  */
+  ulong param_block_size;        /* size of the blocks in the key cache      */
+  ulong param_division_limit;    /* min. percentage of warm blocks           */
+  ulong param_age_threshold;     /* determines when hot block is downgraded  */
+  ulong param_partitions;        /* number of the key cache partitions       */
+  my_bool key_cache_inited;      /* <=> key cache has been created           */
   my_bool can_be_used;           /* usage of cache for read/write is allowed */
-  size_t key_cache_mem_size;      /* specified size of the cache memory       */
-  uint key_cache_block_size;     /* size of the page buffer of a cache block */
-  ulong min_warm_blocks;         /* min number of warm blocks;               */
-  ulong age_threshold;           /* age threshold for hot blocks             */
-  ulonglong keycache_time;       /* total number of block link operations    */
-  uint hash_entries;             /* max number of entries in the hash table  */
-  int hash_links;                /* max number of hash links                 */
-  int hash_links_used;           /* number of hash links currently used      */
-  int disk_blocks;               /* max number of blocks in the cache        */
-  ulong blocks_used; /* maximum number of concurrently used blocks */
-  ulong blocks_unused; /* number of currently unused blocks */
-  ulong blocks_changed;          /* number of currently dirty blocks         */
-  ulong warm_blocks;             /* number of blocks in warm sub-chain       */
-  ulong cnt_for_resize_op;       /* counter to block resize operation        */
-  long blocks_available;      /* number of blocks available in the LRU chain */
-  HASH_LINK **hash_root;         /* arr. of entries into hash table buckets  */
-  HASH_LINK *hash_link_root;     /* memory for hash table links              */
-  HASH_LINK *free_hash_list;     /* list of free hash links                  */
-  BLOCK_LINK *free_block_list;   /* list of free blocks */
-  BLOCK_LINK *block_root;        /* memory for block links                   */
-  uchar HUGE_PTR *block_mem;     /* memory for block buffers                 */
-  BLOCK_LINK *used_last;         /* ptr to the last block of the LRU chain   */
-  BLOCK_LINK *used_ins;          /* ptr to the insertion block in LRU chain  */
-  pthread_mutex_t cache_lock;    /* to lock access to the cache structure    */
-  KEYCACHE_WQUEUE resize_queue;  /* threads waiting during resize operation  */
-  /*
-    Waiting for a zero resize count. Using a queue for symmetry though
-    only one thread can wait here.
-  */
-  KEYCACHE_WQUEUE waiting_for_resize_cnt;
-  KEYCACHE_WQUEUE waiting_for_hash_link; /* waiting for a free hash link     */
-  KEYCACHE_WQUEUE waiting_for_block;    /* requests waiting for a free block */
-  BLOCK_LINK *changed_blocks[CHANGED_BLOCKS_HASH]; /* hash for dirty file bl.*/
-  BLOCK_LINK *file_blocks[CHANGED_BLOCKS_HASH];    /* hash for other file bl.*/
-
-  /*
-    The following variables are and variables used to hold parameters for
-    initializing the key cache.
-  */
-
-  ulonglong param_buff_size;    /* size the memory allocated for the cache  */
-  ulong param_block_size;       /* size of the blocks in the key cache      */
-  ulong param_division_limit;   /* min. percentage of warm blocks           */
-  ulong param_age_threshold;    /* determines when hot block is downgraded  */
-
-  /* Statistics variables. These are reset in reset_key_cache_counters(). */
-  ulong global_blocks_changed;	/* number of currently dirty blocks         */
+  my_bool in_init;		 /* Set to 1 in MySQL during init/resize     */
+  uint partitions;               /* actual number of partitions              */
+  size_t key_cache_mem_size;     /* specified size of the cache memory       */
+  ulong blocks_used;           /* maximum number of concurrently used blocks */
+  ulong blocks_unused;           /* number of currently unused blocks        */
+  ulong global_blocks_changed;	 /* number of currently dirty blocks         */
   ulonglong global_cache_w_requests;/* number of write requests (write hits) */
   ulonglong global_cache_write;     /* number of writes from cache to files  */
   ulonglong global_cache_r_requests;/* number of read requests (read hits)   */
   ulonglong global_cache_read;      /* number of reads from files to cache   */
-
-  int blocks;                   /* max number of blocks in the cache        */
-  my_bool in_init;		/* Set to 1 in MySQL during init/resize     */
 } KEY_CACHE;
 
+
 /* The default key cache */
 extern KEY_CACHE dflt_key_cache_var, *dflt_key_cache;
 
 extern int init_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
 			  size_t use_mem, uint division_limit,
-			  uint age_threshold);
+			  uint age_threshold, uint partitions);
 extern int resize_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
 			    size_t use_mem, uint division_limit,
 			    uint age_threshold);
@@ -122,12 +147,18 @@ extern int key_cache_insert(KEY_CACHE *keycache,
                             File file, my_off_t filepos, int level,
                             uchar *buff, uint length);
 extern int key_cache_write(KEY_CACHE *keycache,
-                           File file, my_off_t filepos, int level,
+                           File file, void *file_extra,
+                           my_off_t filepos, int level,
                            uchar *buff, uint length,
-			   uint block_length,int force_write);
+			   uint block_length, int force_write);
 extern int flush_key_blocks(KEY_CACHE *keycache,
-                            int file, enum flush_type type);
+                            int file, void *file_extra,
+                            enum flush_type type);
 extern void end_key_cache(KEY_CACHE *keycache, my_bool cleanup);
+extern void get_key_cache_statistics(KEY_CACHE *keycache,
+                                     uint partition_no, 
+                                     KEY_CACHE_STATISTICS *key_cache_stats);
+extern ulonglong get_key_cache_stat_value(KEY_CACHE *keycache, uint var_no);
 
 /* Functions to handle multiple key caches */
 extern my_bool multi_keycache_init(void);
@@ -140,5 +171,11 @@ extern void multi_key_cache_change(KEY_CACHE *old_data,
 				   KEY_CACHE *new_data);
 extern int reset_key_cache_counters(const char *name,
                                     KEY_CACHE *key_cache);
+extern int repartition_key_cache(KEY_CACHE *keycache,
+                                 uint key_cache_block_size,
+			         size_t use_mem, 
+                                 uint division_limit,
+			         uint age_threshold,
+                                 uint partitions);
 C_MODE_END
 #endif /* _keycache_h */