table_cache.h

/* Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; version 2 of the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */

#ifndef TABLE_CACHE_INCLUDED
#define TABLE_CACHE_INCLUDED

#include "my_global.h"
#include "sql_class.h"
#include "sql_base.h"

class Table_cache
{
private:
  mysql_mutex_t m_lock;

  HASH m_cache;

  TABLE *m_unused_tables;

  uint m_table_count;

#ifdef HAVE_PSI_INTERFACE
  static PSI_mutex_key m_lock_key;
  static PSI_mutex_info m_mutex_keys[];
#endif 

private:

#ifdef EXTRA_DEBUG
  void check_unused();
#else
  void check_unused() {}
#endif
  inline void link_unused_table(TABLE *table);
  inline void unlink_unused_table(TABLE *table);

  inline void free_unused_tables_if_necessary(THD *thd);

public:

  bool init();
  void destroy();
  static void init_psi_keys();

  void lock() { mysql_mutex_lock(&m_lock); }
  void unlock() { mysql_mutex_unlock(&m_lock); }
  void assert_owner() { mysql_mutex_assert_owner(&m_lock); }

  inline TABLE* get_table(THD *thd, my_hash_value_type hash_value,
                          const char *key, uint key_length,
                          TABLE_SHARE **share);

  inline void release_table(THD *thd, TABLE *table);

  inline bool add_used_table(THD *thd, TABLE *table);
  inline void remove_table(TABLE *table);

  uint cached_tables() const { return m_table_count; }

  void free_all_unused_tables();

#ifndef DBUG_OFF
  void print_tables();
#endif
};


class Table_cache_manager
{
public:

  static const int MAX_TABLE_CACHES= 64;

  bool init();
  void destroy();

  Table_cache* get_cache(THD *thd)
  {
    return &m_table_cache[thd->thread_id % table_cache_instances];
  }

  uint cache_index(Table_cache *cache) const
  {
    return (cache - &m_table_cache[0]);
  }

  uint cached_tables();

  void lock_all_and_tdc();
  void unlock_all_and_tdc();
  void assert_owner_all();
  void assert_owner_all_and_tdc();

  void free_table(THD *thd,
                  enum_tdc_remove_table_type remove_type,
                  TABLE_SHARE *share);

  void free_all_unused_tables();

#ifndef DBUG_OFF
  void print_tables();
#endif

  friend class Table_cache_iterator;

private:

  Table_cache m_table_cache[MAX_TABLE_CACHES];
};


extern Table_cache_manager table_cache_manager;


class Table_cache_element
{
private:
  /*
    Doubly-linked (back-linked) lists of used and unused TABLE objects
    for this table in this table cache (one such list per table cache).
  */
  typedef I_P_List <TABLE,
                    I_P_List_adapter<TABLE,
                                     &TABLE::cache_next,
                                     &TABLE::cache_prev> > TABLE_list;

  TABLE_list used_tables;
  TABLE_list free_tables;
  TABLE_SHARE *share;

public:

  Table_cache_element(TABLE_SHARE *share_arg)
    : share(share_arg)
  {
  }

  TABLE_SHARE * get_share() const { return share; };

  friend class Table_cache;
  friend class Table_cache_manager;
  friend class Table_cache_iterator;
};


class Table_cache_iterator
{
  const TABLE_SHARE *share;
  uint current_cache_index;
  TABLE *current_table;

  inline void move_to_next_table();

public:
  inline Table_cache_iterator(const TABLE_SHARE *share_arg);
  inline TABLE* operator++(int);
  inline void rewind();
};


void Table_cache::link_unused_table(TABLE *table)
{
  if (m_unused_tables)
  {
    table->next= m_unused_tables;
    table->prev= m_unused_tables->prev;
    m_unused_tables->prev= table;
    table->prev->next= table;
  }
  else
    m_unused_tables= table->next= table->prev= table;
  check_unused();
}


void Table_cache::unlink_unused_table(TABLE *table)
{
  table->next->prev= table->prev;
  table->prev->next= table->next;
  if (table == m_unused_tables)
  {
    m_unused_tables= m_unused_tables->next;
    if (table == m_unused_tables)
      m_unused_tables= NULL;
  }
  check_unused();
}


void Table_cache::free_unused_tables_if_necessary(THD *thd)
{
  /*
    We have too many TABLE instances around let us try to get rid of them.

    Note that we might need to free more than one TABLE object, and thus
    need the below loop, in case when table_cache_size is changed dynamically,
    at server run time.
  */
  if (m_table_count > table_cache_size_per_instance && m_unused_tables)
  {
    mysql_mutex_lock(&LOCK_open);
    while (m_table_count > table_cache_size_per_instance &&
           m_unused_tables)
    {
      TABLE *table_to_free= m_unused_tables;
      remove_table(table_to_free);
      intern_close_table(table_to_free);
      thd->status_var.table_open_cache_overflows++;
    }
    mysql_mutex_unlock(&LOCK_open);
  }
}


bool Table_cache::add_used_table(THD *thd, TABLE *table)
{
  Table_cache_element *el;

  assert_owner();

  DBUG_ASSERT(table->in_use == thd);

  /*
    Try to get Table_cache_element representing this table in the cache
    from array in the TABLE_SHARE.
  */
  el= table->s->cache_element[table_cache_manager.cache_index(this)];

  if (!el)
  {
    /*
      If TABLE_SHARE doesn't have pointer to the element representing table
      in this cache, the element for the table must be absent from table the
      cache.

      Allocate new Table_cache_element object and add it to the cache
      and array in TABLE_SHARE.
    */
    DBUG_ASSERT(! my_hash_search(&m_cache,
                                 (uchar*)table->s->table_cache_key.str,
                                 table->s->table_cache_key.length));

    if (!(el= new Table_cache_element(table->s)))
      return true;

    if (my_hash_insert(&m_cache, (uchar*)el))
    {
      delete el;
      return true;
    }

    table->s->cache_element[table_cache_manager.cache_index(this)]= el;
  }

  /* Add table to the used tables list */
  el->used_tables.push_front(table);

  m_table_count++;

  free_unused_tables_if_necessary(thd);

  return false;
}


void Table_cache::remove_table(TABLE *table)
{
  Table_cache_element *el=
    table->s->cache_element[table_cache_manager.cache_index(this)];

  assert_owner();

  if (table->in_use)
  {
    /* Remove from per-table chain of used TABLE objects. */
    el->used_tables.remove(table);
  }
  else
  {
    /* Remove from per-table chain of unused TABLE objects. */
    el->free_tables.remove(table);

    /* And per-cache unused chain. */
    unlink_unused_table(table);
  }

  m_table_count--;

  if (el->used_tables.is_empty() && el->free_tables.is_empty())
  {
    (void) my_hash_delete(&m_cache, (uchar*) el);
    /*
      Remove reference to deleted cache element from array
      in the TABLE_SHARE.
    */
    table->s->cache_element[table_cache_manager.cache_index(this)]= NULL;
  }
}


TABLE* Table_cache::get_table(THD *thd, my_hash_value_type hash_value,
                              const char *key, uint key_length,
                              TABLE_SHARE **share)
{
  Table_cache_element *el;
  TABLE *table;

  assert_owner();

  *share= NULL;

  if (!(el= (Table_cache_element*) my_hash_search_using_hash_value(&m_cache,
                                     hash_value, (uchar*) key, key_length)))
    return NULL;

  *share= el->share;

  if ((table= el->free_tables.front()))
  {
    DBUG_ASSERT(!table->in_use);

    /*
      Unlink table from list of unused TABLE objects for this
      table in this cache.
    */
    el->free_tables.remove(table);

    /* Unlink table from unused tables list for this cache. */
    unlink_unused_table(table);

    /*
      Add table to list of used TABLE objects for this table
      in the table cache.
    */
    el->used_tables.push_front(table);

    table->in_use= thd;
    /* The ex-unused table must be fully functional. */
    DBUG_ASSERT(table->db_stat && table->file);
    /* The children must be detached from the table. */
    DBUG_ASSERT(! table->file->extra(HA_EXTRA_IS_ATTACHED_CHILDREN));
  }

  return table;
}


void Table_cache::release_table(THD *thd, TABLE *table)
{
  Table_cache_element *el=
    table->s->cache_element[table_cache_manager.cache_index(this)];

  assert_owner();

  DBUG_ASSERT(table->in_use);
  DBUG_ASSERT(table->file);

  /* We shouldn't put the table to 'unused' list if the share is old. */
  DBUG_ASSERT(! table->s->has_old_version());

  table->in_use= NULL;

  /* Remove TABLE from the list of used objects for the table in this cache. */
  el->used_tables.remove(table);
  /* Add TABLE to the list of unused objects for the table in this cache. */
  el->free_tables.push_front(table);
  /* Also link it last in the list of unused TABLE objects for the cache. */
  link_unused_table(table);

  /*
    We free the least used tables, not the subject table, to keep the LRU order.
    Note that in most common case the below call won't free anything.
  */
  free_unused_tables_if_necessary(thd);
}


Table_cache_iterator::Table_cache_iterator(const TABLE_SHARE *share_arg)
  : share(share_arg), current_cache_index(0), current_table(NULL)
{
  table_cache_manager.assert_owner_all();
  move_to_next_table();
}


void Table_cache_iterator::move_to_next_table()
{
  for (; current_cache_index < table_cache_instances; ++current_cache_index)
  {
    Table_cache_element *el;

    if ((el= share->cache_element[current_cache_index]))
    {
      if ((current_table= el->used_tables.front()))
        break;
    }
  }
}


TABLE* Table_cache_iterator::operator ++(int)
{
  table_cache_manager.assert_owner_all();

  TABLE *result= current_table;

  if (current_table)
  {
    Table_cache_element::TABLE_list::Iterator
      it(share->cache_element[current_cache_index]->used_tables, current_table);

    current_table= ++it;

    if (!current_table)
    {
      ++current_cache_index;
      move_to_next_table();
    }
  }

  return result;
}


void Table_cache_iterator::rewind()
{
  current_cache_index= 0;
  current_table= NULL;
  move_to_next_table();
}

#endif /* TABLE_CACHE_INCLUDED */