set_var.cc, mysqld.cc, handler.cc, set_var.h, handler.h:

  Added key cache parameters for midpoint insertion strategy
Many files:
  Added midpoint insertion strategy for key cache
mi_test2.c:
  Added a parameter to resize_key_cache


mysys/mf_keycache.c:
  Added midpoint insertion strategy for key cache
myisam/mi_check.c:
  Added midpoint insertion strategy for key cache
myisam/mi_page.c:
  Added midpoint insertion strategy for key cache
myisam/mi_range.c:
  Added midpoint insertion strategy for key cache
myisam/rt_index.c:
  Added midpoint insertion strategy for key cache
myisam/rt_split.c:
  Added midpoint insertion strategy for key cache
myisam/mi_delete.c:
  Added midpoint insertion strategy for key cache
myisam/mi_preload.c:
  Added midpoint insertion strategy for key cache
myisam/mi_search.c:
  Added midpoint insertion strategy for key cache
myisam/mi_write.c:
  Added midpoint insertion strategy for key cache
myisam/rt_key.c:
  Added midpoint insertion strategy for key cache
myisam/mi_test2.c:
  Added a parameter to resize_key_cache
isam/_page.c:
  Added midpoint insertion strategy for key cache
include/my_sys.h:
  Added midpoint insertion strategy for key cache
myisam/myisamdef.h:
  Added midpoint insertion strategy for key cache
sql/handler.h:
  Added key cache parameters for midpoint insertion strategy.
sql/set_var.h:
  Added key cache parameters for midpoint insertion strategy.
sql/handler.cc:
  Added key cache parameters for midpoint insertion strategy.
sql/mysqld.cc:
  Added key cache parameters for midpoint insertion strategy.
sql/set_var.cc:
  Added key cache parameters for midpoint insertion strategy.

include/my_sys.h

@@ -516,6 +516,8 @@ typedef struct st_key_cache_var
 {
   ulonglong buff_size;           /* size the memory allocated for the cache  */
   ulong block_size;              /* size of the blocks in the key cache      */
+  ulong division_limit;          /* min. percentage of warm blocks           */
+  ulong age_threshold;           /* determines when hot block is downgraded  */
   KEY_CACHE_HANDLE cache;        /* handles for the current and registered   */
   ulong blocks_used;             /* number of currently used blocks          */
   ulong blocks_changed;          /* number of currently dirty blocks         */
@@ -530,6 +532,7 @@ typedef struct st_key_cache_var
 #define DEFAULT_KEY_CACHE_NAME "default"
 extern KEY_CACHE_HANDLE *dflt_keycache;
 extern KEY_CACHE_VAR dflt_key_cache_var;
+#define DFLT_INIT_HITS  3
 
 #include <my_alloc.h>
 
@@ -670,17 +673,21 @@ extern long my_clock(void);
 extern sig_handler sigtstp_handler(int signal_number);
 extern void handle_recived_signals(void);
 extern int init_key_cache(KEY_CACHE_HANDLE *pkeycache,
-                          uint key_cache_block_sie,
+                          uint key_cache_block_size,
                           ulong use_mem, KEY_CACHE_VAR* env);
-extern int resize_key_cache(KEY_CACHE_HANDLE *pkeycache, ulong use_mem);
+extern int resize_key_cache(KEY_CACHE_HANDLE *pkeycache,
+                            uint key_cache_block_size, ulong use_mem);
+extern void change_key_cache_param(KEY_CACHE_HANDLE keycache);
 extern byte *key_cache_read(KEY_CACHE_HANDLE keycache,
-                            File file,my_off_t filepos,byte* buff,uint length,
+                            File file, my_off_t filepos, int level,
+                            byte* buff, uint length,
 			    uint block_length,int return_buffer);
 extern int key_cache_insert(KEY_CACHE_HANDLE keycache,
-                            File file, my_off_t filepos,
+                            File file, my_off_t filepos, int level,
                             byte *buff, uint length);
 extern int key_cache_write(KEY_CACHE_HANDLE keycache,
-                           File file,my_off_t filepos,byte* buff,uint length,
+                           File file, my_off_t filepos, int level,
+                           byte* buff, uint length,
 			   uint block_length,int force_write);
 extern int flush_key_blocks(KEY_CACHE_HANDLE keycache,
                             int file, enum flush_type type);

isam/_page.c

@@ -28,7 +28,7 @@ uchar *_nisam_fetch_keypage(register N_INFO *info, N_KEYDEF *keyinfo,
 {
   uchar *tmp;
   tmp=(uchar*) key_cache_read(*dflt_keycache,
-                              info->s->kfile,page,(byte*) buff,
+                              info->s->kfile,page,DFLT_INIT_HITS,(byte*) buff,
 			      (uint) keyinfo->base.block_length,
 			      (uint) keyinfo->base.block_length,
 			      return_buffer);
@@ -85,7 +85,8 @@ int _nisam_write_keypage(register N_INFO *info, register N_KEYDEF *keyinfo,
   }
 #endif
   return (key_cache_write(*dflt_keycache,
-                          info->s->kfile,page,(byte*) buff,length,
+                          info->s->kfile,page,DFLT_INIT_HITS,
+                          (byte*) buff,length,
 			  (uint) keyinfo->base.block_length,
 			  (int) (info->lock_type != F_UNLCK)));
 } /* nisam_write_keypage */
@@ -102,7 +103,8 @@ int _nisam_dispose(register N_INFO *info, N_KEYDEF *keyinfo, my_off_t pos)
   old_link=info->s->state.key_del[keynr];
   info->s->state.key_del[keynr]=(ulong) pos;
   DBUG_RETURN(key_cache_write(*dflt_keycache,
-                              info->s->kfile,pos,(byte*) &old_link,
+                              info->s->kfile,pos,DFLT_INIT_HITS,
+                              (byte*) &old_link,
 			      sizeof(long),
 			      (uint) keyinfo->base.block_length,
 			      (int) (info->lock_type != F_UNLCK)));
@@ -130,7 +132,7 @@ ulong _nisam_new(register N_INFO *info, N_KEYDEF *keyinfo)
   else
   {
     if (!key_cache_read(*dflt_keycache,
-                        info->s->kfile,pos,
+                        info->s->kfile,pos,DFLT_INIT_HITS,
 			(byte*) &info->s->state.key_del[keynr],
 			(uint) sizeof(long),
 			(uint) keyinfo->base.block_length,0))

myisam/mi_check.c

@@ -231,7 +231,8 @@ static int check_k_link(MI_CHECK *param, register MI_INFO *info, uint nr)
 	next_link & (info->s->blocksize-1))
       DBUG_RETURN(1);
     if (!(buff=key_cache_read(*info->s->keycache,
-                              info->s->kfile, next_link, (byte*) info->buff,
+                              info->s->kfile, next_link, DFLT_INIT_HITS,
+                              (byte*) info->buff,
 			      myisam_block_size, block_size, 1)))
       DBUG_RETURN(1);
     next_link=mi_sizekorr(buff);
@@ -371,8 +372,8 @@ int chk_key(MI_CHECK *param, register MI_INFO *info)
     if (share->state.key_root[key] == HA_OFFSET_ERROR &&
 	(info->state->records == 0 || keyinfo->flag & HA_FULLTEXT))
       continue;
-    if (!_mi_fetch_keypage(info,keyinfo,share->state.key_root[key],info->buff,
-			   0))
+    if (!_mi_fetch_keypage(info,keyinfo,share->state.key_root[key],
+                           DFLT_INIT_HITS,info->buff,0))
     {
       mi_check_print_error(param,"Can't read indexpage from filepos: %s",
 		  llstr(share->state.key_root[key],buff));
@@ -550,7 +551,8 @@ static int chk_index(MI_CHECK *param, MI_INFO *info, MI_KEYDEF *keyinfo,
 	info->state->key_file_length=(max_length &
 				      ~ (my_off_t) (info->s->blocksize-1));
       }
-      if (!_mi_fetch_keypage(info,keyinfo,next_page,temp_buff,0))
+      if (!_mi_fetch_keypage(info,keyinfo,next_page,
+                             DFLT_INIT_HITS,temp_buff,0))
       {
 	mi_check_print_error(param,"Can't read key from filepos: %s",llstr(next_page,llbuff));
 	goto err;
@@ -1443,7 +1445,8 @@ int movepoint(register MI_INFO *info, byte *record, my_off_t oldpos,
 	nod_flag=mi_test_if_nod(info->buff);
 	_mi_dpointer(info,info->int_keypos-nod_flag-
 		     info->s->rec_reflength,newpos);
-	if (_mi_write_keypage(info,keyinfo,info->last_keypage,info->buff))
+	if (_mi_write_keypage(info,keyinfo,info->last_keypage,
+                              DFLT_INIT_HITS,info->buff))
 	  DBUG_RETURN(-1);
       }
       else
@@ -1600,7 +1603,7 @@ static int sort_one_index(MI_CHECK *param, MI_INFO *info, MI_KEYDEF *keyinfo,
     mi_check_print_error(param,"Not Enough memory");
     DBUG_RETURN(-1);
   }
-  if (!_mi_fetch_keypage(info,keyinfo,pagepos,buff,0))
+  if (!_mi_fetch_keypage(info,keyinfo,pagepos,DFLT_INIT_HITS,buff,0))
   {
     mi_check_print_error(param,"Can't read key block from filepos: %s",
 		llstr(pagepos,llbuff));
@@ -3334,13 +3337,13 @@ static int sort_insert_key(MI_SORT_PARAM *sort_param,
   bzero((byte*) anc_buff+key_block->last_length,
 	keyinfo->block_length- key_block->last_length);
   key_file_length=info->state->key_file_length;
-  if ((filepos=_mi_new(info,keyinfo)) == HA_OFFSET_ERROR)
+  if ((filepos=_mi_new(info,keyinfo,DFLT_INIT_HITS)) == HA_OFFSET_ERROR)
     DBUG_RETURN(1);
 
   /* If we read the page from the key cache, we have to write it back to it */
   if (key_file_length == info->state->key_file_length)
   {
-    if (_mi_write_keypage(info, keyinfo, filepos, anc_buff))
+    if (_mi_write_keypage(info, keyinfo, filepos, DFLT_INIT_HITS, anc_buff))
       DBUG_RETURN(1);
   }
   else if (my_pwrite(info->s->kfile,(byte*) anc_buff,
@@ -3438,13 +3441,14 @@ int flush_pending_blocks(MI_SORT_PARAM *sort_param)
       _mi_kpointer(info,key_block->end_pos,filepos);
     key_file_length=info->state->key_file_length;
     bzero((byte*) key_block->buff+length, keyinfo->block_length-length);
-    if ((filepos=_mi_new(info,keyinfo)) == HA_OFFSET_ERROR)
+    if ((filepos=_mi_new(info,keyinfo,DFLT_INIT_HITS)) == HA_OFFSET_ERROR)
       DBUG_RETURN(1);
 
     /* If we read the page from the key cache, we have to write it back */
     if (key_file_length == info->state->key_file_length)
     {
-      if (_mi_write_keypage(info, keyinfo, filepos, key_block->buff))
+      if (_mi_write_keypage(info, keyinfo, filepos,
+                            DFLT_INIT_HITS, key_block->buff))
 	DBUG_RETURN(1);
     }
     else if (my_pwrite(info->s->kfile,(byte*) key_block->buff,

myisam/mi_delete.c

@@ -155,7 +155,7 @@ static int _mi_ck_real_delete(register MI_INFO *info, MI_KEYDEF *keyinfo,
     DBUG_RETURN(my_errno=ENOMEM);
   }
   DBUG_PRINT("info",("root_page: %ld",old_root));
-  if (!_mi_fetch_keypage(info,keyinfo,old_root,root_buff,0))
+  if (!_mi_fetch_keypage(info,keyinfo,old_root,DFLT_INIT_HITS,root_buff,0))
   {
     error= -1;
     goto err;
@@ -179,11 +179,12 @@ static int _mi_ck_real_delete(register MI_INFO *info, MI_KEYDEF *keyinfo,
 	  *root=_mi_kpos(nod_flag,root_buff+2+nod_flag);
 	else
 	  *root=HA_OFFSET_ERROR;
-	if (_mi_dispose(info,keyinfo,old_root))
+	if (_mi_dispose(info,keyinfo,old_root,DFLT_INIT_HITS))
 	  error= -1;
       }
       else
-	error=_mi_write_keypage(info,keyinfo,old_root,root_buff);
+	error=_mi_write_keypage(info,keyinfo,old_root,
+                                DFLT_INIT_HITS,root_buff);
     }
   }
 err:
@@ -253,7 +254,7 @@ static int d_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
       {
         /* the last entry in sub-tree */
         DBUG_PRINT("info",("FT2: the last entry"));
-        _mi_dispose(info, keyinfo, root);
+        _mi_dispose(info, keyinfo, root,DFLT_INIT_HITS);
         /* fall through to normal delete */
       }
       else
@@ -268,7 +269,8 @@ static int d_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
         subkeys++;
         ft_intXstore(kpos, subkeys);
         if (!ret_value)
-          ret_value=_mi_write_keypage(info,keyinfo,page,anc_buff);
+          ret_value=_mi_write_keypage(info,keyinfo,page,
+                                      DFLT_INIT_HITS,anc_buff);
         DBUG_PRINT("exit",("Return: %d",ret_value));
         DBUG_RETURN(ret_value);
       }
@@ -287,7 +289,7 @@ static int d_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
       DBUG_PRINT("exit",("Return: %d",-1));
       DBUG_RETURN(-1);
     }
-    if (!_mi_fetch_keypage(info,keyinfo,leaf_page,leaf_buff,0))
+    if (!_mi_fetch_keypage(info,keyinfo,leaf_page,DFLT_INIT_HITS,leaf_buff,0))
       goto err;
   }
 
@@ -319,7 +321,7 @@ static int d_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
     mi_putint(anc_buff,length,nod_flag);
     if (!nod_flag)
     {						/* On leaf page */
-      if (_mi_write_keypage(info,keyinfo,page,anc_buff))
+      if (_mi_write_keypage(info,keyinfo,page,DFLT_INIT_HITS,anc_buff))
       {
         DBUG_PRINT("exit",("Return: %d",-1));
 	DBUG_RETURN(-1);
@@ -354,7 +356,7 @@ static int d_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
     ret_value=_mi_split_page(info,keyinfo,key,anc_buff,lastkey,0) | 2;
   }
   if (save_flag && ret_value != 1)
-    ret_value|=_mi_write_keypage(info,keyinfo,page,anc_buff);
+    ret_value|=_mi_write_keypage(info,keyinfo,page,DFLT_INIT_HITS,anc_buff);
   else
   {
     DBUG_DUMP("page",(byte*) anc_buff,mi_getint(anc_buff));
@@ -398,7 +400,7 @@ static int del(register MI_INFO *info, register MI_KEYDEF *keyinfo, uchar *key,
     if (!(next_buff= (uchar*) my_alloca((uint) keyinfo->block_length+
 					MI_MAX_KEY_BUFF*2)))
       DBUG_RETURN(-1);
-    if (!_mi_fetch_keypage(info,keyinfo,next_page,next_buff,0))
+    if (!_mi_fetch_keypage(info,keyinfo,next_page,DFLT_INIT_HITS,next_buff,0))
       ret_value= -1;
     else
     {
@@ -426,7 +428,7 @@ static int del(register MI_INFO *info, register MI_KEYDEF *keyinfo, uchar *key,
 			       (uchar*) 0,(uchar*) 0,(my_off_t) 0,0);
 	}
       }
-      if (_mi_write_keypage(info,keyinfo,leaf_page,leaf_buff))
+      if (_mi_write_keypage(info,keyinfo,leaf_page,DFLT_INIT_HITS,leaf_buff))
 	goto err;
     }
     my_afree((byte*) next_buff);
@@ -436,7 +438,7 @@ static int del(register MI_INFO *info, register MI_KEYDEF *keyinfo, uchar *key,
 	/* Remove last key from leaf page */
 
   mi_putint(leaf_buff,key_start-leaf_buff,nod_flag);
-  if (_mi_write_keypage(info,keyinfo,leaf_page,leaf_buff))
+  if (_mi_write_keypage(info,keyinfo,leaf_page,DFLT_INIT_HITS,leaf_buff))
     goto err;
 
 	/* Place last key in ancestor page on deleted key position */
@@ -524,7 +526,7 @@ static int underflow(register MI_INFO *info, register MI_KEYDEF *keyinfo,
       goto err;
     }
     next_page= _mi_kpos(key_reflength,next_keypos);
-    if (!_mi_fetch_keypage(info,keyinfo,next_page,buff,0))
+    if (!_mi_fetch_keypage(info,keyinfo,next_page,DFLT_INIT_HITS,buff,0))
       goto err;
     buff_length=mi_getint(buff);
     DBUG_DUMP("next",(byte*) buff,buff_length);
@@ -563,7 +565,7 @@ static int underflow(register MI_INFO *info, register MI_KEYDEF *keyinfo,
     if (buff_length <= keyinfo->block_length)
     {						/* Keys in one page */
       memcpy((byte*) leaf_buff,(byte*) buff,(size_t) buff_length);
-      if (_mi_dispose(info,keyinfo,next_page))
+      if (_mi_dispose(info,keyinfo,next_page,DFLT_INIT_HITS))
        goto err;
     }
     else
@@ -612,10 +614,10 @@ static int underflow(register MI_INFO *info, register MI_KEYDEF *keyinfo,
       (*keyinfo->store_key)(keyinfo,buff+p_length,&s_temp);
       mi_putint(buff,length+t_length+p_length,nod_flag);
 
-      if (_mi_write_keypage(info,keyinfo,next_page,buff))
+      if (_mi_write_keypage(info,keyinfo,next_page,DFLT_INIT_HITS,buff))
 	goto err;
     }
-    if (_mi_write_keypage(info,keyinfo,leaf_page,leaf_buff))
+    if (_mi_write_keypage(info,keyinfo,leaf_page,DFLT_INIT_HITS,leaf_buff))
       goto err;
     DBUG_RETURN(anc_length <= ((info->quick_mode ? MI_MIN_BLOCK_LENGTH :
 				(uint) keyinfo->underflow_block_length)));
@@ -627,7 +629,7 @@ static int underflow(register MI_INFO *info, register MI_KEYDEF *keyinfo,
   if (!keypos)
     goto err;
   next_page= _mi_kpos(key_reflength,keypos);
-  if (!_mi_fetch_keypage(info,keyinfo,next_page,buff,0))
+  if (!_mi_fetch_keypage(info,keyinfo,next_page,DFLT_INIT_HITS,buff,0))
       goto err;
   buff_length=mi_getint(buff);
   endpos=buff+buff_length;
@@ -671,7 +673,7 @@ static int underflow(register MI_INFO *info, register MI_KEYDEF *keyinfo,
 
   if (buff_length <= keyinfo->block_length)
   {						/* Keys in one page */
-    if (_mi_dispose(info,keyinfo,leaf_page))
+    if (_mi_dispose(info,keyinfo,leaf_page,DFLT_INIT_HITS))
       goto err;
   }
   else
@@ -718,11 +720,11 @@ static int underflow(register MI_INFO *info, register MI_KEYDEF *keyinfo,
 	  (size_t) length);
     (*keyinfo->store_key)(keyinfo,leaf_buff+p_length,&s_temp);
     mi_putint(leaf_buff,length+t_length+p_length,nod_flag);
-    if (_mi_write_keypage(info,keyinfo,leaf_page,leaf_buff))
+    if (_mi_write_keypage(info,keyinfo,leaf_page,DFLT_INIT_HITS,leaf_buff))
       goto err;
     mi_putint(buff,endpos-buff,nod_flag);
   }
-  if (_mi_write_keypage(info,keyinfo,next_page,buff))
+  if (_mi_write_keypage(info,keyinfo,next_page,DFLT_INIT_HITS,buff))
     goto err;
   DBUG_RETURN(anc_length <= (uint) keyinfo->block_length/2);
 err:

myisam/mi_page.c

@@ -24,7 +24,8 @@
 	/* Fetch a key-page in memory */
 
 uchar *_mi_fetch_keypage(register MI_INFO *info, MI_KEYDEF *keyinfo,
-			 my_off_t page, uchar *buff, int return_buffer)
+			 my_off_t page, int level, 
+                         uchar *buff, int return_buffer)
 {
   uchar *tmp;
   uint page_size;
@@ -32,7 +33,7 @@ uchar *_mi_fetch_keypage(register MI_INFO *info, MI_KEYDEF *keyinfo,
   DBUG_PRINT("enter",("page: %ld",page));
 
   tmp=(uchar*) key_cache_read(*info->s->keycache,
-                             info->s->kfile,page,(byte*) buff,
+                             info->s->kfile, page, level, (byte*) buff,
 			     (uint) keyinfo->block_length,
 			     (uint) keyinfo->block_length,
 			     return_buffer);
@@ -62,7 +63,7 @@ uchar *_mi_fetch_keypage(register MI_INFO *info, MI_KEYDEF *keyinfo,
 	/* Write a key-page on disk */
 
 int _mi_write_keypage(register MI_INFO *info, register MI_KEYDEF *keyinfo,
-		      my_off_t page, uchar *buff)
+		      my_off_t page, int level, uchar *buff)
 {
   reg3 uint length;
   DBUG_ENTER("_mi_write_keypage");
@@ -94,7 +95,7 @@ int _mi_write_keypage(register MI_INFO *info, register MI_KEYDEF *keyinfo,
   }
 #endif
   DBUG_RETURN((key_cache_write(*info->s->keycache,
-                         info->s->kfile,page,(byte*) buff,length,
+                         info->s->kfile,page, level, (byte*) buff,length,
 			 (uint) keyinfo->block_length,
 			 (int) ((info->lock_type != F_UNLCK) ||
 				info->s->delay_key_write))));
@@ -103,7 +104,8 @@ int _mi_write_keypage(register MI_INFO *info, register MI_KEYDEF *keyinfo,
 
 	/* Remove page from disk */
 
-int _mi_dispose(register MI_INFO *info, MI_KEYDEF *keyinfo, my_off_t pos)
+int _mi_dispose(register MI_INFO *info, MI_KEYDEF *keyinfo, my_off_t pos,
+                int level)
 {
   my_off_t old_link;
   char buff[8];
@@ -115,7 +117,7 @@ int _mi_dispose(register MI_INFO *info, MI_KEYDEF *keyinfo, my_off_t pos)
   mi_sizestore(buff,old_link);
   info->s->state.changed|= STATE_NOT_SORTED_PAGES;
   DBUG_RETURN(key_cache_write(*info->s->keycache,
-                              info->s->kfile,pos,buff,
+                              info->s->kfile, pos , level, buff,
 			      sizeof(buff),
 			      (uint) keyinfo->block_length,
 			      (int) (info->lock_type != F_UNLCK)));
@@ -124,7 +126,7 @@ int _mi_dispose(register MI_INFO *info, MI_KEYDEF *keyinfo, my_off_t pos)
 
 	/* Make new page on disk */
 
-my_off_t _mi_new(register MI_INFO *info, MI_KEYDEF *keyinfo)
+my_off_t _mi_new(register MI_INFO *info, MI_KEYDEF *keyinfo, int level)
 {
   my_off_t pos;
   char buff[8];
@@ -144,7 +146,7 @@ my_off_t _mi_new(register MI_INFO *info, MI_KEYDEF *keyinfo)
   else
   {
     if (!key_cache_read(*info->s->keycache,
-                        info->s->kfile,pos,
+                        info->s->kfile, pos, level,
 			buff,
 			(uint) sizeof(buff),
 			(uint) keyinfo->block_length,0))

myisam/mi_preload.c

@@ -88,7 +88,8 @@ int mi_preload(MI_INFO *info, ulonglong key_map, my_bool ignore_leaves)
         if (mi_test_if_nod(buff))
         {
           if (key_cache_insert(*share->keycache,
-                               share->kfile, pos, (byte*) buff, block_length))
+                               share->kfile, pos, DFLT_INIT_HITS, 
+                              (byte*) buff, block_length))
 	    goto err;
 	}
         pos+= block_length;
@@ -99,7 +100,8 @@ int mi_preload(MI_INFO *info, ulonglong key_map, my_bool ignore_leaves)
     else
     {
       if (key_cache_insert(*share->keycache,
-                           share->kfile, pos, (byte*) buff, length))
+                           share->kfile, pos, DFLT_INIT_HITS,
+                           (byte*) buff, length))
 	goto err;
       pos+= length;
     }

myisam/mi_range.c

@@ -142,7 +142,7 @@ static double _mi_search_pos(register MI_INFO *info,
   if (pos == HA_OFFSET_ERROR)
     DBUG_RETURN(0.5);
 
-  if (!(buff=_mi_fetch_keypage(info,keyinfo,pos,info->buff,1)))
+  if (!(buff=_mi_fetch_keypage(info,keyinfo,pos,DFLT_INIT_HITS,info->buff,1)))
     goto err;
   flag=(*keyinfo->bin_search)(info,keyinfo,buff,key,key_len,nextflag,
 			      &keypos,info->lastkey, &after_key);

myisam/mi_search.c

@@ -76,7 +76,7 @@ int _mi_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
     DBUG_RETURN(1);                             /* Search at upper levels */
   }
 
-  if (!(buff=_mi_fetch_keypage(info,keyinfo,pos,info->buff,
+  if (!(buff=_mi_fetch_keypage(info,keyinfo,pos,DFLT_INIT_HITS,info->buff,
                                test(!(nextflag & SEARCH_SAVE_BUFF)))))
     goto err;
   DBUG_DUMP("page",(byte*) buff,mi_getint(buff));
@@ -119,7 +119,7 @@ int _mi_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
   if (pos != info->last_keypage)
   {
     uchar *old_buff=buff;
-    if (!(buff=_mi_fetch_keypage(info,keyinfo,pos,info->buff,
+    if (!(buff=_mi_fetch_keypage(info,keyinfo,pos,DFLT_INIT_HITS,info->buff,
                                  test(!(nextflag & SEARCH_SAVE_BUFF)))))
       goto err;
     keypos=buff+(keypos-old_buff);
@@ -1105,7 +1105,7 @@ int _mi_search_next(register MI_INFO *info, register MI_KEYDEF *keyinfo,
   if (info->buff_used)
   {
     if (!_mi_fetch_keypage(info,keyinfo,info->last_search_keypage,
-                           info->buff,0))
+                           DFLT_INIT_HITS,info->buff,0))
       DBUG_RETURN(-1);
     info->buff_used=0;
   }
@@ -1174,7 +1174,7 @@ int _mi_search_first(register MI_INFO *info, register MI_KEYDEF *keyinfo,
 
   do
   {
-    if (!_mi_fetch_keypage(info,keyinfo,pos,info->buff,0))
+    if (!_mi_fetch_keypage(info,keyinfo,pos,DFLT_INIT_HITS,info->buff,0))
     {
       info->lastpos= HA_OFFSET_ERROR;
       DBUG_RETURN(-1);
@@ -1217,7 +1217,7 @@ int _mi_search_last(register MI_INFO *info, register MI_KEYDEF *keyinfo,
   buff=info->buff;
   do
   {
-    if (!_mi_fetch_keypage(info,keyinfo,pos,buff,0))
+    if (!_mi_fetch_keypage(info,keyinfo,pos,DFLT_INIT_HITS,buff,0))
     {
       info->lastpos= HA_OFFSET_ERROR;
       DBUG_RETURN(-1);

myisam/mi_test2.c

@@ -275,7 +275,7 @@ int main(int argc, char *argv[])
       goto end;
     }
     if (key_cacheing)
-      resize_key_cache(dflt_keycache,key_cache_size*2);
+      resize_key_cache(dflt_keycache,key_cache_block_size,key_cache_size*2);
   }
 
   if (!silent)

myisam/mi_write.c

@@ -290,8 +290,8 @@ int _mi_enlarge_root(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
   mi_putint(info->buff,t_length+2+nod_flag,nod_flag);
   (*keyinfo->store_key)(keyinfo,info->buff+2+nod_flag,&s_temp);
   info->buff_used=info->page_changed=1;		/* info->buff is used */
-  if ((*root= _mi_new(info,keyinfo)) == HA_OFFSET_ERROR ||
-      _mi_write_keypage(info,keyinfo,*root,info->buff))
+  if ((*root= _mi_new(info,keyinfo,DFLT_INIT_HITS)) == HA_OFFSET_ERROR ||
+      _mi_write_keypage(info,keyinfo,*root,DFLT_INIT_HITS,info->buff))
     DBUG_RETURN(-1);
   DBUG_RETURN(0);
 } /* _mi_enlarge_root */
@@ -322,7 +322,7 @@ static int w_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
   if (!(temp_buff= (uchar*) my_alloca((uint) keyinfo->block_length+
 				      MI_MAX_KEY_BUFF*2)))
     DBUG_RETURN(-1);
-  if (!_mi_fetch_keypage(info,keyinfo,page,temp_buff,0))
+  if (!_mi_fetch_keypage(info,keyinfo,page,DFLT_INIT_HITS,temp_buff,0))
     goto err;
 
   flag=(*keyinfo->bin_search)(info,keyinfo,temp_buff,key,search_key_length,
@@ -368,7 +368,7 @@ static int w_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
         subkeys--; /* should there be underflow protection ? */
         ft_intXstore(keypos, subkeys);
         if (!error)
-          error=_mi_write_keypage(info,keyinfo,page,temp_buff);
+          error=_mi_write_keypage(info,keyinfo,page,DFLT_INIT_HITS,temp_buff);
         my_afree((byte*) temp_buff);
         DBUG_RETURN(error);
       }
@@ -391,7 +391,7 @@ static int w_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
   {
     error=_mi_insert(info,keyinfo,key,temp_buff,keypos,keybuff,father_buff,
 		     father_keypos,father_page, insert_last);
-    if (_mi_write_keypage(info,keyinfo,page,temp_buff))
+    if (_mi_write_keypage(info,keyinfo,page,DFLT_INIT_HITS,temp_buff))
       goto err;
   }
   my_afree((byte*) temp_buff);
@@ -515,7 +515,7 @@ int _mi_split_page(register MI_INFO *info, register MI_KEYDEF *keyinfo,
   }
 
 	/* Move middle item to key and pointer to new page */
-  if ((new_pos=_mi_new(info,keyinfo)) == HA_OFFSET_ERROR)
+  if ((new_pos=_mi_new(info,keyinfo,DFLT_INIT_HITS)) == HA_OFFSET_ERROR)
     DBUG_RETURN(-1);
   _mi_kpointer(info,_mi_move_key(keyinfo,key,key_buff),new_pos);
 
@@ -531,7 +531,7 @@ int _mi_split_page(register MI_INFO *info, register MI_KEYDEF *keyinfo,
   (*keyinfo->store_key)(keyinfo,info->buff+key_ref_length,&s_temp);
   mi_putint(info->buff,length+t_length+key_ref_length,nod_flag);
 
-  if (_mi_write_keypage(info,keyinfo,new_pos,info->buff))
+  if (_mi_write_keypage(info,keyinfo,new_pos,DFLT_INIT_HITS,info->buff))
     DBUG_RETURN(-1);
   DBUG_DUMP("key",(byte*) key,_mi_keylength(keyinfo,key));
   DBUG_RETURN(2);				/* Middle key up */
@@ -682,7 +682,7 @@ static int _mi_balance_page(register MI_INFO *info, MI_KEYDEF *keyinfo,
     DBUG_PRINT("test",("use left page: %lu",next_page));
   }					/* father_key_pos ptr to parting key */
 
-  if (!_mi_fetch_keypage(info,keyinfo,next_page,info->buff,0))
+  if (!_mi_fetch_keypage(info,keyinfo,next_page,DFLT_INIT_HITS,info->buff,0))
     goto err;
   DBUG_DUMP("next",(byte*) info->buff,mi_getint(info->buff));
 
@@ -722,8 +722,8 @@ static int _mi_balance_page(register MI_INFO *info, MI_KEYDEF *keyinfo,
       memcpy((byte*) buff+2,(byte*) pos+k_length,(size_t) length);
     }
 
-    if (_mi_write_keypage(info,keyinfo,next_page,info->buff) ||
-	_mi_write_keypage(info,keyinfo,father_page,father_buff))
+    if (_mi_write_keypage(info,keyinfo,next_page,DFLT_INIT_HITS,info->buff) ||
+	_mi_write_keypage(info,keyinfo,father_page,DFLT_INIT_HITS,father_buff))
       goto err;
     DBUG_RETURN(0);
   }
@@ -763,12 +763,13 @@ static int _mi_balance_page(register MI_INFO *info, MI_KEYDEF *keyinfo,
   memcpy((byte*) (right ? key : father_key_pos),pos,(size_t) k_length);
   memcpy((byte*) (right ? father_key_pos : key),tmp_part_key, k_length);
 
-  if ((new_pos=_mi_new(info,keyinfo)) == HA_OFFSET_ERROR)
+  if ((new_pos=_mi_new(info,keyinfo,DFLT_INIT_HITS)) == HA_OFFSET_ERROR)
     goto err;
   _mi_kpointer(info,key+k_length,new_pos);
   if (_mi_write_keypage(info,keyinfo,(right ? new_pos : next_page),
-			info->buff) ||
-      _mi_write_keypage(info,keyinfo,(right ? next_page : new_pos),extra_buff))
+			DFLT_INIT_HITS,info->buff) ||
+      _mi_write_keypage(info,keyinfo,(right ? next_page : new_pos),
+                        DFLT_INIT_HITS,extra_buff))
     goto err;
 
   DBUG_RETURN(1);				/* Middle key up */

myisam/myisamdef.h

@@ -548,11 +548,12 @@ extern int _mi_search_next(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *key,
 extern int _mi_search_first(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t pos);
 extern int _mi_search_last(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t pos);
 extern uchar *_mi_fetch_keypage(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t page,
-				uchar *buff,int return_buffer);
+				int level,uchar *buff,int return_buffer);
 extern int _mi_write_keypage(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t page,
-			     uchar *buff);
-extern int _mi_dispose(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t pos);
-extern my_off_t _mi_new(MI_INFO *info,MI_KEYDEF *keyinfo);
+			     int level, uchar *buff);
+extern int _mi_dispose(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t pos,
+                      int level);
+extern my_off_t _mi_new(MI_INFO *info,MI_KEYDEF *keyinfo,int level);
 extern uint _mi_make_key(MI_INFO *info,uint keynr,uchar *key,
 			 const byte *record,my_off_t filepos);
 extern uint _mi_pack_key(MI_INFO *info,uint keynr,uchar *key,uchar *old,

myisam/rt_index.c

@@ -60,7 +60,7 @@ static int rtree_find_req(MI_INFO *info, MI_KEYDEF *keyinfo, uint search_flag, u
     my_errno = HA_ERR_OUT_OF_MEM;
     return -1;
   }
-  if (!_mi_fetch_keypage(info, keyinfo, page, page_buf, 0))
+  if (!_mi_fetch_keypage(info, keyinfo, page, DFLT_INIT_HITS, page_buf, 0))
     goto err1;
   nod_flag = mi_test_if_nod(page_buf);
 
@@ -257,7 +257,7 @@ static int rtree_get_req(MI_INFO *info, MI_KEYDEF *keyinfo, uint key_length,
   
   if (!(page_buf = (uchar*)my_alloca((uint)keyinfo->block_length)))
     return -1;
-  if (!_mi_fetch_keypage(info, keyinfo, page, page_buf, 0))
+  if (!_mi_fetch_keypage(info, keyinfo, page, DFLT_INIT_HITS, page_buf, 0))
     goto err1;
   nod_flag = mi_test_if_nod(page_buf);
 
@@ -429,7 +429,7 @@ static int rtree_insert_req(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
     my_errno = HA_ERR_OUT_OF_MEM;
     return -1;
   }
-  if (!_mi_fetch_keypage(info, keyinfo, page, page_buf, 0))
+  if (!_mi_fetch_keypage(info, keyinfo, page, DFLT_INIT_HITS, page_buf, 0))
     goto err1;
   nod_flag = mi_test_if_nod(page_buf);
 
@@ -445,7 +445,7 @@ static int rtree_insert_req(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
       case 0: /* child was not split */
       {
         rtree_combine_rect(keyinfo->seg, k, key, k, key_length);
-        if (_mi_write_keypage(info, keyinfo, page, page_buf))
+        if (_mi_write_keypage(info, keyinfo, page, DFLT_INIT_HITS, page_buf))
           goto err1;
         goto ok;
       }
@@ -462,7 +462,7 @@ static int rtree_insert_req(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
           goto err1;
         res = rtree_add_key(info, keyinfo, new_key, key_length, 
                            page_buf, new_page);
-        if (_mi_write_keypage(info, keyinfo, page, page_buf))
+        if (_mi_write_keypage(info, keyinfo, page, DFLT_INIT_HITS, page_buf))
           goto err1;
         goto ok;
       }
@@ -476,7 +476,7 @@ static int rtree_insert_req(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
   else
   { 
     res = rtree_add_key(info, keyinfo, key, key_length, page_buf, new_page);
-    if (_mi_write_keypage(info, keyinfo, page, page_buf))
+    if (_mi_write_keypage(info, keyinfo, page, DFLT_INIT_HITS, page_buf))
       goto err1;
     goto ok;
   }
@@ -509,12 +509,12 @@ static int rtree_insert_level(MI_INFO *info, uint keynr, uchar *key,
   {
     int res;
 
-    if ((old_root = _mi_new(info, keyinfo)) == HA_OFFSET_ERROR)
+    if ((old_root = _mi_new(info, keyinfo, DFLT_INIT_HITS)) == HA_OFFSET_ERROR)
       return -1;
     info->buff_used = 1;
     mi_putint(info->buff, 2, 0);
     res = rtree_add_key(info, keyinfo, key, key_length, info->buff, NULL);
-    if (_mi_write_keypage(info, keyinfo, old_root, info->buff))
+    if (_mi_write_keypage(info, keyinfo, old_root, DFLT_INIT_HITS, info->buff))
       return 1;
     info->s->state.key_root[keynr] = old_root;
     return res;
@@ -542,7 +542,8 @@ static int rtree_insert_level(MI_INFO *info, uint keynr, uchar *key,
       }
 
       mi_putint(new_root_buf, 2, nod_flag);
-      if ((new_root = _mi_new(info, keyinfo)) == HA_OFFSET_ERROR)
+      if ((new_root = _mi_new(info, keyinfo, DFLT_INIT_HITS)) ==
+                                                             HA_OFFSET_ERROR)
         goto err1;
 
       new_key = new_root_buf + keyinfo->block_length + nod_flag;
@@ -559,7 +560,8 @@ static int rtree_insert_level(MI_INFO *info, uint keynr, uchar *key,
       if (rtree_add_key(info, keyinfo, new_key, key_length, new_root_buf, NULL) 
           == -1)
         goto err1;
-      if (_mi_write_keypage(info, keyinfo, new_root, new_root_buf))
+      if (_mi_write_keypage(info, keyinfo, new_root,
+                            DFLT_INIT_HITS, new_root_buf))
         goto err1;
       info->s->state.key_root[keynr] = new_root;
 
@@ -636,7 +638,7 @@ static int rtree_delete_req(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
     my_errno = HA_ERR_OUT_OF_MEM;
     return -1;
   }
-  if (!_mi_fetch_keypage(info, keyinfo, page, page_buf, 0))
+  if (!_mi_fetch_keypage(info, keyinfo, page, DFLT_INIT_HITS, page_buf, 0))
     goto err1;
   nod_flag = mi_test_if_nod(page_buf);
 
@@ -662,7 +664,8 @@ static int rtree_delete_req(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
               if (rtree_set_key_mbr(info, keyinfo, k, key_length, 
                                   _mi_kpos(nod_flag, k)))
                 goto err1;
-              if (_mi_write_keypage(info, keyinfo, page, page_buf))
+              if (_mi_write_keypage(info, keyinfo, page,
+                                    DFLT_INIT_HITS, page_buf))
                 goto err1;
             }
             else
@@ -672,7 +675,8 @@ static int rtree_delete_req(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
                                            level + 1))
                 goto err1;
               rtree_delete_key(info, page_buf, k, key_length, nod_flag);
-              if (_mi_write_keypage(info, keyinfo, page, page_buf))
+              if (_mi_write_keypage(info, keyinfo, page,
+                                    DFLT_INIT_HITS, page_buf))
                 goto err1;
               *page_size = mi_getint(page_buf);
             }
@@ -686,7 +690,8 @@ static int rtree_delete_req(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
           case 2: /* vacuous case: last key in the leaf */
           {
             rtree_delete_key(info, page_buf, k, key_length, nod_flag);
-            if (_mi_write_keypage(info, keyinfo, page, page_buf))
+            if (_mi_write_keypage(info, keyinfo, page,
+                                  DFLT_INIT_HITS, page_buf))
               goto err1;
             *page_size = mi_getint(page_buf);
             res = 0;
@@ -711,13 +716,13 @@ static int rtree_delete_req(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
         {
           /* last key in the leaf */
           res = 2;
-          if (_mi_dispose(info, keyinfo, page))
+          if (_mi_dispose(info, keyinfo, page, DFLT_INIT_HITS))
             goto err1;
         }
         else
         {
           res = 0;
-          if (_mi_write_keypage(info, keyinfo, page, page_buf))
+          if (_mi_write_keypage(info, keyinfo, page, DFLT_INIT_HITS, page_buf))
             goto err1;
         }
         goto ok;
@@ -783,7 +788,7 @@ int rtree_delete(MI_INFO *info, uint keynr, uchar *key, uint key_length)
           goto err1;
         }
         if (!_mi_fetch_keypage(info, keyinfo, ReinsertList.pages[i].offs, 
-                               page_buf, 0))
+                               DFLT_INIT_HITS, page_buf, 0))
           goto err1;
         nod_flag = mi_test_if_nod(page_buf);
         k = rt_PAGE_FIRST_KEY(page_buf, nod_flag);
@@ -798,7 +803,8 @@ int rtree_delete(MI_INFO *info, uint keynr, uchar *key, uint key_length)
           }
         }
         my_afree((byte*)page_buf);
-        if (_mi_dispose(info, keyinfo, ReinsertList.pages[i].offs))
+        if (_mi_dispose(info, keyinfo, ReinsertList.pages[i].offs,
+            DFLT_INIT_HITS))
           goto err1;
       }
       if (ReinsertList.pages)
@@ -807,7 +813,8 @@ int rtree_delete(MI_INFO *info, uint keynr, uchar *key, uint key_length)
       /* check for redundant root (not leaf, 1 child) and eliminate */
       if ((old_root = info->s->state.key_root[keynr]) == HA_OFFSET_ERROR)
         goto err1;
-      if (!_mi_fetch_keypage(info, keyinfo, old_root, info->buff, 0))
+      if (!_mi_fetch_keypage(info, keyinfo, old_root, DFLT_INIT_HITS, 
+                             info->buff, 0))
         goto err1;
       nod_flag = mi_test_if_nod(info->buff);
       page_size = mi_getint(info->buff);
@@ -816,7 +823,7 @@ int rtree_delete(MI_INFO *info, uint keynr, uchar *key, uint key_length)
       {
         my_off_t new_root = _mi_kpos(nod_flag, 
                                      rt_PAGE_FIRST_KEY(info->buff, nod_flag));
-        if (_mi_dispose(info, keyinfo, old_root))
+        if (_mi_dispose(info, keyinfo, old_root, DFLT_INIT_HITS))
           goto err1;
         info->s->state.key_root[keynr] = new_root;
       }
@@ -863,7 +870,7 @@ ha_rows rtree_estimate(MI_INFO *info, uint keynr, uchar *key,
     return HA_POS_ERROR;
   if (!(page_buf = (uchar*)my_alloca((uint)keyinfo->block_length)))
     return HA_POS_ERROR;
-  if (!_mi_fetch_keypage(info, keyinfo, root, page_buf, 0))
+  if (!_mi_fetch_keypage(info, keyinfo, root, DFLT_INIT_HITS, page_buf, 0))
     goto err1;
   nod_flag = mi_test_if_nod(page_buf);
 

myisam/rt_key.c

@@ -88,7 +88,8 @@ int rtree_delete_key(MI_INFO *info, uchar *page_buf, uchar *key,
 int rtree_set_key_mbr(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key, 
 		      uint key_length, my_off_t child_page)
 {
-  if (!_mi_fetch_keypage(info, keyinfo, child_page, info->buff, 0))
+  if (!_mi_fetch_keypage(info, keyinfo, child_page,
+                         DFLT_INIT_HITS, info->buff, 0))
     return -1;
 
   return rtree_page_mbr(info, keyinfo->seg, info->buff, key, key_length);

myisam/rt_split.c

@@ -332,10 +332,12 @@ int rtree_split_page(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page, uchar *key,
   mi_putint(page, 2 + n1 * full_length, nod_flag);
   mi_putint(new_page, 2 + n2 * full_length, nod_flag);
 
-  if ((*new_page_offs= _mi_new(info, keyinfo)) == HA_OFFSET_ERROR)
+  if ((*new_page_offs= _mi_new(info, keyinfo, DFLT_INIT_HITS)) == 
+                                                               HA_OFFSET_ERROR)
     err_code= -1;
   else
-    err_code= _mi_write_keypage(info, keyinfo, *new_page_offs, new_page);
+    err_code= _mi_write_keypage(info, keyinfo, *new_page_offs,
+                                DFLT_INIT_HITS, new_page);
 
   my_afree((byte*)new_page);
 

sql/handler.cc

@@ -1009,12 +1009,21 @@ int ha_resize_key_cache(KEY_CACHE_VAR *key_cache)
 {
   if (key_cache->cache)
   {
-    return !resize_key_cache(&key_cache->cache, 
+    return !resize_key_cache(&key_cache->cache, key_cache->block_size,
                            key_cache->buff_size);
   }
   return 0;
 }
 
+int ha_change_key_cache_param(KEY_CACHE_VAR *key_cache)
+{
+  if (key_cache->cache)
+  {
+    change_key_cache_param(key_cache->cache);
+  }
+  return 0;
+}
+
 int ha_end_key_cache(KEY_CACHE_VAR *key_cache)
 {
   if (key_cache->cache)

sql/handler.h

@@ -389,6 +389,7 @@ int ha_delete_table(enum db_type db_type, const char *path);
 void ha_drop_database(char* path);
 int ha_key_cache(KEY_CACHE_VAR *key_cache);
 int ha_resize_key_cache(KEY_CACHE_VAR *key_cache);
+int ha_change_key_cache_param(KEY_CACHE_VAR *key_cache);
 int ha_end_key_cache(KEY_CACHE_VAR *key_cache);
 int ha_start_stmt(THD *thd); 
 int ha_report_binlog_offset_and_commit(THD *thd, char *log_file_name,

sql/mysqld.cc

@@ -3441,7 +3441,9 @@ enum options
   OPT_FLUSH_TIME, OPT_FT_MIN_WORD_LEN,
   OPT_FT_MAX_WORD_LEN, OPT_FT_MAX_WORD_LEN_FOR_SORT, OPT_FT_STOPWORD_FILE,
   OPT_INTERACTIVE_TIMEOUT, OPT_JOIN_BUFF_SIZE,
-  OPT_KEY_BUFFER_SIZE, OPT_KEY_CACHE_BLOCK_SIZE, OPT_LONG_QUERY_TIME,
+  OPT_KEY_BUFFER_SIZE, OPT_KEY_CACHE_BLOCK_SIZE,
+  OPT_KEY_CACHE_DIVISION_LIMIT, OPT_KEY_CACHE_AGE_THRESHOLD,
+  OPT_LONG_QUERY_TIME,
   OPT_LOWER_CASE_TABLE_NAMES, OPT_MAX_ALLOWED_PACKET,
   OPT_MAX_BINLOG_CACHE_SIZE, OPT_MAX_BINLOG_SIZE,
   OPT_MAX_CONNECTIONS, OPT_MAX_CONNECT_ERRORS,
@@ -4133,6 +4135,16 @@ replicating a LOAD DATA INFILE command.",
    (gptr*) &dflt_key_cache_var.block_size,
    (gptr*) &dflt_key_cache_var.block_size, 0, GET_ULONG,
    REQUIRED_ARG, KEY_CACHE_BLOCK_SIZE , 512, 1024*16, MALLOC_OVERHEAD, 512, 0},
+  {"key_cache_division_limit", OPT_KEY_CACHE_DIVISION_LIMIT,
+   "The minimum percentage of warm blocks in key cache",
+   (gptr*) &dflt_key_cache_var.division_limit,
+   (gptr*) &dflt_key_cache_var.division_limit, 0, GET_ULONG,
+   REQUIRED_ARG, 100, 1, 100, 0, 1, 0},
+  {"key_cache_division_age_threshold", OPT_KEY_CACHE_AGE_THRESHOLD,
+   "This characterizes the number of hits a hot block has to be untouched until it is considered aged enough to be downgraded to a warm block. This specifies the percentage ratio of that number of hits to the total number of blocks in key cache",
+   (gptr*) &dflt_key_cache_var.age_threshold,
+   (gptr*) &dflt_key_cache_var.age_threshold, 0, GET_ULONG,
+   REQUIRED_ARG, 300, 100, ~0L, 0, 100, 0},
   {"long_query_time", OPT_LONG_QUERY_TIME,
    "Log all queries that have taken more than long_query_time seconds to execute to file.",
    (gptr*) &global_system_variables.long_query_time,
@@ -5352,21 +5364,26 @@ mysql_getopt_value(const char *keyname, uint key_length,
 {
   switch (option->id) {
   case OPT_KEY_BUFFER_SIZE:
-  {
-    KEY_CACHE_VAR *key_cache;
-    if (!(key_cache= get_or_create_key_cache(keyname, key_length)))
-      exit(1);
-    return (gptr*) &key_cache->buff_size;
-  }
   case OPT_KEY_CACHE_BLOCK_SIZE:
+  case OPT_KEY_CACHE_DIVISION_LIMIT:
+  case OPT_KEY_CACHE_AGE_THRESHOLD:
   {
     KEY_CACHE_VAR *key_cache;
     if (!(key_cache= get_or_create_key_cache(keyname, key_length)))
       exit(1);
-    return (gptr*) &key_cache->block_size;
+    switch (option->id) {
+    case OPT_KEY_BUFFER_SIZE:
+      return (gptr*) &key_cache->buff_size;
+    case OPT_KEY_CACHE_BLOCK_SIZE:
+      return (gptr*) &key_cache->block_size;
+    case OPT_KEY_CACHE_DIVISION_LIMIT:
+      return (gptr*) &key_cache->division_limit;
+    case OPT_KEY_CACHE_AGE_THRESHOLD:
+      return (gptr*) &key_cache->age_threshold;
+    }
   }
   }
-  return option->value;
+ return option->value;
 }
 
 
@@ -5426,6 +5443,8 @@ static void get_options(int argc,char **argv)
   KEY_CACHE_VAR *key_cache= &dflt_key_cache_var;
   dflt_key_cache_block_size= key_cache->block_size;
   dflt_key_buff_size= key_cache->buff_size;
+  dflt_key_cache_division_limit= key_cache->division_limit;
+  dflt_key_cache_age_threshold= key_cache->age_threshold;
 }
 
 

sql/set_var.cc

@@ -59,8 +59,10 @@
 #include "ha_innodb.h"
 #endif
 
-ulong dflt_key_buff_size;
+ulonglong dflt_key_buff_size;
 uint dflt_key_cache_block_size;
+uint dflt_key_cache_division_limit;
+uint dflt_key_cache_age_threshold;
 
 static HASH system_variable_hash;
 const char *bool_type_names[]= { "OFF", "ON", NullS };
@@ -141,6 +143,10 @@ sys_var_thd_ulong	sys_join_buffer_size("join_buffer_size",
 					     &SV::join_buff_size);
 sys_var_key_buffer_size	sys_key_buffer_size("key_buffer_size");
 sys_var_key_cache_block_size  sys_key_cache_block_size("key_cache_block_size");
+sys_var_key_cache_division_limit
+  sys_key_cache_division_limit("key_cache_division_limit");
+sys_var_key_cache_age_threshold
+  sys_key_cache_age_threshold("key_cache_age_threshold");
 sys_var_bool_ptr	sys_local_infile("local_infile",
 					 &opt_local_infile);
 sys_var_thd_bool	sys_log_warnings("log_warnings", &SV::log_warnings);
@@ -395,6 +401,8 @@ sys_var *sys_variables[]=
   &sys_join_buffer_size,
   &sys_key_buffer_size,
   &sys_key_cache_block_size,
+  &sys_key_cache_division_limit,
+  &sys_key_cache_age_threshold,
   &sys_last_insert_id,
   &sys_local_infile,
   &sys_log_binlog,
@@ -554,6 +562,10 @@ struct show_var_st init_vars[]= {
   {sys_key_buffer_size.name,	(char*) &sys_key_buffer_size,	    SHOW_SYS},
   {sys_key_cache_block_size.name,   (char*) &sys_key_cache_block_size,
                                                          	    SHOW_SYS},
+  {sys_key_cache_division_limit.name,   (char*) &sys_key_cache_division_limit,
+                                                         	    SHOW_SYS},
+  {sys_key_cache_age_threshold.name,   (char*) &sys_key_cache_age_threshold,
+                                                         	    SHOW_SYS},
   {"language",                language,                             SHOW_CHAR},
   {"large_files_support",     (char*) &opt_large_files,             SHOW_BOOL},	
   {sys_local_infile.name,     (char*) &sys_local_infile,	    SHOW_SYS},
@@ -1421,7 +1433,7 @@ void sys_var_collation_connection::set_default(THD *thd, enum_var_type type)
 
 static LEX_STRING default_key_cache_base= {(char *) DEFAULT_KEY_CACHE_NAME, 7};
 
-static KEY_CACHE_VAR zero_key_cache= { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+static KEY_CACHE_VAR zero_key_cache= { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 
 static KEY_CACHE_VAR *get_key_cache(LEX_STRING *cache_name)
 {
@@ -1443,7 +1455,7 @@ byte *sys_var_key_cache_param::value_ptr(THD *thd, enum_var_type type,
     key_cache= &zero_key_cache;
   return (byte*) key_cache + offset ;
 }
-  
+    
 bool sys_var_key_buffer_size::update(THD *thd, set_var *var)
 {
   int rc;
@@ -1507,6 +1519,48 @@ bool sys_var_key_cache_block_size::update(THD *thd, set_var *var)
   return 0;
 }
 
+bool sys_var_key_cache_division_limit::update(THD *thd, set_var *var)
+{
+  ulong tmp= var->value->val_int();
+
+  if (!base_name.length)
+    base_name= default_key_cache_base;
+  KEY_CACHE_VAR *key_cache= get_key_cache(&base_name);
+                            
+  if (!key_cache && !(key_cache= create_key_cache(base_name.str,
+				                  base_name.length)))
+    return 1;
+ 
+  key_cache->division_limit=
+    (ulong) getopt_ull_limit_value(tmp, option_limits);
+
+  if (key_cache->cache)
+    /* Do not build a new key cache here */ 
+    return (bool) (ha_change_key_cache_param(key_cache));
+  return 0;
+}
+
+bool sys_var_key_cache_age_threshold::update(THD *thd, set_var *var)
+{
+  ulong tmp= var->value->val_int();
+
+  if (!base_name.length)
+    base_name= default_key_cache_base;
+  KEY_CACHE_VAR *key_cache= get_key_cache(&base_name);
+                            
+  if (!key_cache && !(key_cache= create_key_cache(base_name.str,
+				                  base_name.length)))
+    return 1;
+ 
+  key_cache->division_limit=
+    (ulong) getopt_ull_limit_value(tmp, option_limits);
+
+  if (key_cache->cache)
+    /* Do not build a new key cache here */ 
+    return (bool) (ha_change_key_cache_param(key_cache));
+  return 0;
+}
+
 
 /*****************************************************************************
   Functions to handle SET NAMES and SET CHARACTER SET

sql/set_var.h

@@ -29,8 +29,11 @@ class sys_var;
 class set_var;
 typedef struct system_variables SV;
 extern TYPELIB bool_typelib, delay_key_write_typelib, sql_mode_typelib;
+
+extern ulonglong dflt_key_buff_size;
 extern uint dflt_key_cache_block_size;
-extern ulong dflt_key_buff_size;
+extern uint dflt_key_cache_division_limit;
+extern uint dflt_key_cache_age_threshold;
 
 enum enum_var_type
 {
@@ -572,6 +575,34 @@ class sys_var_key_cache_block_size :public sys_var_key_cache_param
   bool is_struct() { return 1; }
 };
 
+class sys_var_key_cache_division_limit :public sys_var_key_cache_param
+{
+public:
+  sys_var_key_cache_division_limit(const char *name_arg)
+    :sys_var_key_cache_param(name_arg)
+  {
+    offset= offsetof(KEY_CACHE_VAR, division_limit);
+  }
+  bool update(THD *thd, set_var *var);
+  SHOW_TYPE type() { return SHOW_LONG; }
+  bool check_default(enum_var_type type) { return 1; }
+  bool is_struct() { return 1; }
+};
+
+class sys_var_key_cache_age_threshold :public sys_var_key_cache_param
+{
+public:
+  sys_var_key_cache_age_threshold(const char *name_arg)
+    :sys_var_key_cache_param(name_arg)
+  {
+    offset= offsetof(KEY_CACHE_VAR, age_threshold);
+  }
+  bool update(THD *thd, set_var *var);
+  SHOW_TYPE type() { return SHOW_LONG; }
+  bool check_default(enum_var_type type) { return 1; }
+  bool is_struct() { return 1; }
+};
+
 
 /* Variable that you can only read from */