Function resize_key_cache

mysys/mf_keycache.c:560–656

*/

int resize_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
                     size_t use_mem, uint division_limit,
                     uint age_threshold)
{
  int blocks;
  DBUG_ENTER("resize_key_cache");

  if (!keycache->key_cache_inited)
    DBUG_RETURN(keycache->disk_blocks);

  if(key_cache_block_size == keycache->key_cache_block_size &&
     use_mem == keycache->key_cache_mem_size)
  {
    change_key_cache_param(keycache, division_limit, age_threshold);
    DBUG_RETURN(keycache->disk_blocks);
  }

  keycache_pthread_mutex_lock(&keycache->cache_lock);

  /*
    We may need to wait for another thread which is doing a resize
    already. This cannot happen in the MySQL server though. It allows
    one resizer only. In set_var.cc keycache->in_init is used to block
    multiple attempts.
  */
  while (keycache->in_resize)
  {
    /* purecov: begin inspected */
    wait_on_queue(&keycache->resize_queue, &keycache->cache_lock);
    /* purecov: end */
  }

  /*
    Mark the operation in progress. This blocks other threads from doing
    a resize in parallel. It prohibits new blocks to enter the cache.
    Read/write requests can bypass the cache during the flush phase.
  */
  keycache->in_resize= 1;

  /* Need to flush only if keycache is enabled. */
  if (keycache->can_be_used)
  {
    /* Start the flush phase. */
    keycache->resize_in_flush= 1;

    if (flush_all_key_blocks(keycache))
    {
      /* TODO: if this happens, we should write a warning in the log file ! */
      keycache->resize_in_flush= 0;
      blocks= 0;
      keycache->can_be_used= 0;
      goto finish;
    }
    DBUG_ASSERT(cache_empty(keycache));

    /* End the flush phase. */
    keycache->resize_in_flush= 0;
  }