Adding upstream version 1:10.11.6.upstream/1%10.11.6

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1315 insertions, 0 deletions

diff --git a/sql/table_cache.cc b/sql/table_cache.cc
new file mode 100644
index 00000000..0039c96a
--- /dev/null
+++ b/sql/table_cache.cc
@@ -0,0 +1,1315 @@
+/* Copyright (c) 2000, 2012, Oracle and/or its affiliates.
+   Copyright (c) 2010, 2022, MariaDB Corporation.
+   Copyright (C) 2013 Sergey Vojtovich and MariaDB Foundation
+
+   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-1335  USA */
+
+/**
+  @file
+  Table definition cache and table cache implementation.
+
+  Table definition cache actions:
+  - add new TABLE_SHARE object to cache (tdc_acquire_share())
+  - acquire TABLE_SHARE object from cache (tdc_acquire_share())
+  - release TABLE_SHARE object to cache (tdc_release_share())
+  - purge unused TABLE_SHARE objects from cache (tdc_purge())
+  - remove TABLE_SHARE object from cache (tdc_remove_table())
+  - get number of TABLE_SHARE objects in cache (tdc_records())
+
+  Table cache actions:
+  - add new TABLE object to cache (tc_add_table())
+  - acquire TABLE object from cache (tc_acquire_table())
+  - release TABLE object to cache (tc_release_table())
+  - purge unused TABLE objects from cache (tc_purge())
+  - purge unused TABLE objects of a table from cache (tdc_remove_table())
+  - get number of TABLE objects in cache (tc_records())
+
+  Dependencies:
+  - close_cached_tables(): flush tables on shutdown
+  - alloc_table_share()
+  - free_table_share()
+
+  Table cache invariants:
+  - TABLE_SHARE::free_tables shall not contain objects with TABLE::in_use != 0
+  - TABLE_SHARE::free_tables shall not receive new objects if
+    TABLE_SHARE::tdc.flushed is true
+*/
+
+#include "mariadb.h"
+#include "lf.h"
+#include "table.h"
+#include "sql_base.h"
+#include "aligned.h"
+
+
+/** Configuration. */
+ulong tdc_size; /**< Table definition cache threshold for LRU eviction. */
+ulong tc_size; /**< Table cache threshold for LRU eviction. */
+uint32 tc_instances;
+static size_t tc_allocated_size;
+static std::atomic<uint32_t> tc_active_instances(1);
+static std::atomic<bool> tc_contention_warning_reported;
+
+/** Data collections. */
+static LF_HASH tdc_hash; /**< Collection of TABLE_SHARE objects. */
+/** Collection of unused TABLE_SHARE objects. */
+static
+I_P_List <TDC_element,
+          I_P_List_adapter<TDC_element, &TDC_element::next, &TDC_element::prev>,
+          I_P_List_null_counter,
+          I_P_List_fast_push_back<TDC_element> > unused_shares;
+
+static bool tdc_inited;
+
+
+/**
+  Protects unused shares list.
+
+  TDC_element::prev
+  TDC_element::next
+  unused_shares
+*/
+
+static mysql_mutex_t LOCK_unused_shares;
+
+#ifdef HAVE_PSI_INTERFACE
+static PSI_mutex_key key_LOCK_unused_shares, key_TABLE_SHARE_LOCK_table_share,
+                     key_LOCK_table_cache;
+static PSI_mutex_info all_tc_mutexes[]=
+{
+  { &key_LOCK_unused_shares, "LOCK_unused_shares", PSI_FLAG_GLOBAL },
+  { &key_TABLE_SHARE_LOCK_table_share, "TABLE_SHARE::tdc.LOCK_table_share", 0 },
+  { &key_LOCK_table_cache, "LOCK_table_cache", 0 }
+};
+
+static PSI_cond_key key_TABLE_SHARE_COND_release;
+static PSI_cond_info all_tc_conds[]=
+{
+  { &key_TABLE_SHARE_COND_release, "TABLE_SHARE::tdc.COND_release", 0 }
+};
+#endif
+
+
+static int fix_thd_pins(THD *thd)
+{
+  return thd->tdc_hash_pins ? 0 :
+         (thd->tdc_hash_pins= lf_hash_get_pins(&tdc_hash)) == 0;
+}
+
+
+/*
+  Auxiliary routines for manipulating with per-share all/unused lists
+  and tc_count counter.
+  Responsible for preserving invariants between those lists, counter
+  and TABLE::in_use member.
+  In fact those routines implement sort of implicit table cache as
+  part of table definition cache.
+*/
+
+struct Table_cache_instance
+{
+  /**
+    Protects free_tables (TABLE::global_free_next and TABLE::global_free_prev),
+    records, Share_free_tables::List (TABLE::prev and TABLE::next),
+    TABLE::in_use.
+  */
+  alignas(CPU_LEVEL1_DCACHE_LINESIZE)
+  mysql_mutex_t LOCK_table_cache;
+  I_P_List <TABLE, I_P_List_adapter<TABLE, &TABLE::global_free_next,
+                                    &TABLE::global_free_prev>,
+            I_P_List_null_counter, I_P_List_fast_push_back<TABLE> >
+    free_tables;
+  ulong records;
+  uint mutex_waits;
+  uint mutex_nowaits;
+
+  Table_cache_instance(): records(0), mutex_waits(0), mutex_nowaits(0)
+  {
+    static_assert(!(sizeof(*this) % CPU_LEVEL1_DCACHE_LINESIZE), "alignment");
+    mysql_mutex_init(key_LOCK_table_cache, &LOCK_table_cache,
+                     MY_MUTEX_INIT_FAST);
+  }
+
+  ~Table_cache_instance()
+  {
+    mysql_mutex_destroy(&LOCK_table_cache);
+    DBUG_ASSERT(free_tables.is_empty());
+    DBUG_ASSERT(records == 0);
+  }
+
+  static void *operator new[](size_t size)
+  { return aligned_malloc(size, CPU_LEVEL1_DCACHE_LINESIZE); }
+  static void operator delete[](void *ptr) { aligned_free(ptr); }
+  static void mark_memory_freed()
+  {
+    update_malloc_size(-(longlong) tc_allocated_size, 0);
+  }
+
+  /**
+    Lock table cache mutex and check contention.
+
+    Instance is considered contested if more than 20% of mutex acquisiotions
+    can't be served immediately. Up to 100 000 probes may be performed to avoid
+    instance activation on short sporadic peaks. 100 000 is estimated maximum
+    number of queries one instance can serve in one second.
+
+    These numbers work well on a 2 socket / 20 core / 40 threads Intel Broadwell
+    system, that is expected number of instances is activated within reasonable
+    warmup time. It may have to be adjusted for other systems.
+
+    Only TABLE object acquistion is instrumented. We intentionally avoid this
+    overhead on TABLE object release. All other table cache mutex acquistions
+    are considered out of hot path and are not instrumented either.
+  */
+  void lock_and_check_contention(uint32_t n_instances, uint32_t instance)
+  {
+    if (mysql_mutex_trylock(&LOCK_table_cache))
+    {
+      mysql_mutex_lock(&LOCK_table_cache);
+      if (++mutex_waits == 20000)
+      {
+        if (n_instances < tc_instances)
+        {
+          if (tc_active_instances.
+              compare_exchange_weak(n_instances, n_instances + 1,
+                                    std::memory_order_relaxed,
+                                    std::memory_order_relaxed))
+          {
+            sql_print_information("Detected table cache mutex contention at instance %d: "
+                                  "%d%% waits. Additional table cache instance "
+                                  "activated. Number of instances after "
+                                  "activation: %d.",
+                                  instance + 1,
+                                  mutex_waits * 100 / (mutex_nowaits + mutex_waits),
+                                  n_instances + 1);
+          }
+        }
+        else if (!tc_contention_warning_reported.exchange(true,
+                                                 std::memory_order_relaxed))
+        {
+          sql_print_warning("Detected table cache mutex contention at instance %d: "
+                            "%d%% waits. Additional table cache instance "
+                            "cannot be activated: consider raising "
+                            "table_open_cache_instances. Number of active "
+                            "instances: %d.",
+                            instance + 1,
+                            mutex_waits * 100 / (mutex_nowaits + mutex_waits),
+                            n_instances);
+        }
+        mutex_waits= 0;
+        mutex_nowaits= 0;
+      }
+    }
+    else if (++mutex_nowaits == 80000)
+    {
+      mutex_waits= 0;
+      mutex_nowaits= 0;
+    }
+  }
+};
+
+
+static Table_cache_instance *tc;
+
+
+static void intern_close_table(TABLE *table)
+{
+  delete table->triggers;
+  DBUG_ASSERT(table->file);
+  closefrm(table);
+  tdc_release_share(table->s);
+  my_free(table);
+}
+
+
+/**
+  Get number of TABLE objects (used and unused) in table cache.
+*/
+
+uint tc_records(void)
+{
+  ulong total= 0;
+  for (uint32 i= 0; i < tc_instances; i++)
+  {
+    mysql_mutex_lock(&tc[i].LOCK_table_cache);
+    total+= tc[i].records;
+    mysql_mutex_unlock(&tc[i].LOCK_table_cache);
+  }
+  return total;
+}
+
+
+/**
+  Remove TABLE object from table cache.
+*/
+
+static void tc_remove_table(TABLE *table)
+{
+  TDC_element *element= table->s->tdc;
+
+  mysql_mutex_lock(&element->LOCK_table_share);
+  /* Wait for MDL deadlock detector to complete traversing tdc.all_tables. */
+  while (element->all_tables_refs)
+    mysql_cond_wait(&element->COND_release, &element->LOCK_table_share);
+  element->all_tables.remove(table);
+  mysql_mutex_unlock(&element->LOCK_table_share);
+
+  intern_close_table(table);
+}
+
+
+static void tc_remove_all_unused_tables(TDC_element *element,
+                                        Share_free_tables::List *purge_tables)
+{
+  for (uint32 i= 0; i < tc_instances; i++)
+  {
+    mysql_mutex_lock(&tc[i].LOCK_table_cache);
+    while (auto table= element->free_tables[i].list.pop_front())
+    {
+      tc[i].records--;
+      tc[i].free_tables.remove(table);
+      DBUG_ASSERT(element->all_tables_refs == 0);
+      element->all_tables.remove(table);
+      purge_tables->push_front(table);
+    }
+    mysql_mutex_unlock(&tc[i].LOCK_table_cache);
+  }
+}
+
+
+/**
+  Free all unused TABLE objects.
+
+  While locked:
+  - remove unused objects from TABLE_SHARE::tdc.free_tables and
+    TABLE_SHARE::tdc.all_tables
+  - decrement tc_count
+
+  While unlocked:
+  - free resources related to unused objects
+
+  @note This is called by 'handle_manager' when one wants to
+        periodicly flush all not used tables.
+*/
+
+static my_bool tc_purge_callback(TDC_element *element,
+                                 Share_free_tables::List *purge_tables)
+{
+  mysql_mutex_lock(&element->LOCK_table_share);
+  tc_remove_all_unused_tables(element, purge_tables);
+  mysql_mutex_unlock(&element->LOCK_table_share);
+  return FALSE;
+}
+
+
+void tc_purge()
+{
+  Share_free_tables::List purge_tables;
+
+  tdc_iterate(0, (my_hash_walk_action) tc_purge_callback, &purge_tables);
+  while (auto table= purge_tables.pop_front())
+    intern_close_table(table);
+}
+
+
+/**
+  Add new TABLE object to table cache.
+
+  @pre TABLE object is used by caller.
+
+  Added object cannot be evicted or acquired.
+
+  While locked:
+  - add object to TABLE_SHARE::tdc.all_tables
+  - increment tc_count
+  - evict LRU object from table cache if we reached threshold
+
+  While unlocked:
+  - free evicted object
+*/
+
+void tc_add_table(THD *thd, TABLE *table)
+{
+  uint32_t i=
+    thd->thread_id % tc_active_instances.load(std::memory_order_relaxed);
+  TABLE *LRU_table= 0;
+  TDC_element *element= table->s->tdc;
+
+  DBUG_ASSERT(table->in_use == thd);
+  table->instance= i;
+  mysql_mutex_lock(&element->LOCK_table_share);
+  /* Wait for MDL deadlock detector to complete traversing tdc.all_tables. */
+  while (element->all_tables_refs)
+    mysql_cond_wait(&element->COND_release, &element->LOCK_table_share);
+  element->all_tables.push_front(table);
+  mysql_mutex_unlock(&element->LOCK_table_share);
+
+  mysql_mutex_lock(&tc[i].LOCK_table_cache);
+  if (tc[i].records == tc_size)
+  {
+    if ((LRU_table= tc[i].free_tables.pop_front()))
+    {
+      LRU_table->s->tdc->free_tables[i].list.remove(LRU_table);
+      /* Needed if MDL deadlock detector chimes in before tc_remove_table() */
+      LRU_table->in_use= thd;
+      mysql_mutex_unlock(&tc[i].LOCK_table_cache);
+      /* Keep out of locked LOCK_table_cache */
+      tc_remove_table(LRU_table);
+    }
+    else
+    {
+      tc[i].records++;
+      mysql_mutex_unlock(&tc[i].LOCK_table_cache);
+    }
+    /* Keep out of locked LOCK_table_cache */
+    status_var_increment(thd->status_var.table_open_cache_overflows);
+  }
+  else
+  {
+    tc[i].records++;
+    mysql_mutex_unlock(&tc[i].LOCK_table_cache);
+  }
+}
+
+
+/**
+  Acquire TABLE object from table cache.
+
+  @pre share must be protected against removal.
+
+  Acquired object cannot be evicted or acquired again.
+
+  @return TABLE object, or NULL if no unused objects.
+*/
+
+TABLE *tc_acquire_table(THD *thd, TDC_element *element)
+{
+  uint32_t n_instances= tc_active_instances.load(std::memory_order_relaxed);
+  uint32_t i= thd->thread_id % n_instances;
+  TABLE *table;
+
+  tc[i].lock_and_check_contention(n_instances, i);
+  table= element->free_tables[i].list.pop_front();
+  if (table)
+  {
+    DBUG_ASSERT(!table->in_use);
+    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));
+    tc[i].free_tables.remove(table);
+  }
+  mysql_mutex_unlock(&tc[i].LOCK_table_cache);
+  return table;
+}
+
+
+/**
+  Release TABLE object to table cache.
+
+  @pre object is used by caller.
+
+  Released object may be evicted or acquired again.
+
+  While locked:
+  - if object is marked for purge, decrement tc_count
+  - add object to TABLE_SHARE::tdc.free_tables
+  - evict LRU object from table cache if we reached threshold
+
+  While unlocked:
+  - mark object not in use by any thread
+  - free evicted/purged object
+
+  @note Another thread may mark share for purge any moment (even
+  after version check). It means to-be-purged object may go to
+  unused lists. This other thread is expected to call tc_purge(),
+  which is synchronized with us on TABLE_SHARE::tdc.LOCK_table_share.
+
+  @return
+    @retval true  object purged
+    @retval false object released
+*/
+
+void tc_release_table(TABLE *table)
+{
+  uint32 i= table->instance;
+  DBUG_ENTER("tc_release_table");
+  DBUG_ASSERT(table->in_use);
+  DBUG_ASSERT(table->file);
+  DBUG_ASSERT(!table->pos_in_locked_tables);
+
+  mysql_mutex_lock(&tc[i].LOCK_table_cache);
+  if (table->needs_reopen() || table->s->tdc->flushed ||
+      tc[i].records > tc_size)
+  {
+    tc[i].records--;
+    mysql_mutex_unlock(&tc[i].LOCK_table_cache);
+    tc_remove_table(table);
+  }
+  else
+  {
+    table->in_use= 0;
+    table->s->tdc->free_tables[i].list.push_front(table);
+    tc[i].free_tables.push_back(table);
+    mysql_mutex_unlock(&tc[i].LOCK_table_cache);
+  }
+  DBUG_VOID_RETURN;
+}
+
+
+static void tdc_assert_clean_share(TDC_element *element)
+{
+  DBUG_ASSERT(element->share == 0);
+  DBUG_ASSERT(element->ref_count == 0);
+  DBUG_ASSERT(element->m_flush_tickets.is_empty());
+  DBUG_ASSERT(element->all_tables.is_empty());
+#ifndef DBUG_OFF
+  for (uint32 i= 0; i < tc_instances; i++)
+    DBUG_ASSERT(element->free_tables[i].list.is_empty());
+#endif
+  DBUG_ASSERT(element->all_tables_refs == 0);
+  DBUG_ASSERT(element->next == 0);
+  DBUG_ASSERT(element->prev == 0);
+}
+
+
+/**
+  Delete share from hash and free share object.
+*/
+
+static void tdc_delete_share_from_hash(TDC_element *element)
+{
+  THD *thd= current_thd;
+  LF_PINS *pins;
+  TABLE_SHARE *share;
+  DBUG_ENTER("tdc_delete_share_from_hash");
+
+  mysql_mutex_assert_owner(&element->LOCK_table_share);
+  share= element->share;
+  DBUG_ASSERT(share);
+  element->share= 0;
+  PSI_CALL_release_table_share(share->m_psi);
+  share->m_psi= 0;
+
+  if (!element->m_flush_tickets.is_empty())
+  {
+    Wait_for_flush_list::Iterator it(element->m_flush_tickets);
+    Wait_for_flush *ticket;
+    while ((ticket= it++))
+      (void) ticket->get_ctx()->m_wait.set_status(MDL_wait::GRANTED);
+
+    do
+    {
+      mysql_cond_wait(&element->COND_release, &element->LOCK_table_share);
+    } while (!element->m_flush_tickets.is_empty());
+  }
+
+  mysql_mutex_unlock(&element->LOCK_table_share);
+
+  if (thd)
+  {
+    fix_thd_pins(thd);
+    pins= thd->tdc_hash_pins;
+  }
+  else
+    pins= lf_hash_get_pins(&tdc_hash);
+
+  DBUG_ASSERT(pins); // What can we do about it?
+  tdc_assert_clean_share(element);
+  lf_hash_delete(&tdc_hash, pins, element->m_key, element->m_key_length);
+  if (!thd)
+    lf_hash_put_pins(pins);
+  free_table_share(share);
+  DBUG_VOID_RETURN;
+}
+
+
+/**
+  Prepeare table share for use with table definition cache.
+*/
+
+static void lf_alloc_constructor(uchar *arg)
+{
+  TDC_element *element= (TDC_element*) (arg + LF_HASH_OVERHEAD);
+  DBUG_ENTER("lf_alloc_constructor");
+  mysql_mutex_init(key_TABLE_SHARE_LOCK_table_share,
+                   &element->LOCK_table_share, MY_MUTEX_INIT_FAST);
+  mysql_cond_init(key_TABLE_SHARE_COND_release, &element->COND_release, 0);
+  element->m_flush_tickets.empty();
+  element->all_tables.empty();
+  for (uint32 i= 0; i < tc_instances; i++)
+    element->free_tables[i].list.empty();
+  element->all_tables_refs= 0;
+  element->share= 0;
+  element->ref_count= 0;
+  element->next= 0;
+  element->prev= 0;
+  DBUG_VOID_RETURN;
+}
+
+
+/**
+  Release table definition cache specific resources of table share.
+*/
+
+static void lf_alloc_destructor(uchar *arg)
+{
+  TDC_element *element= (TDC_element*) (arg + LF_HASH_OVERHEAD);
+  DBUG_ENTER("lf_alloc_destructor");
+  tdc_assert_clean_share(element);
+  mysql_cond_destroy(&element->COND_release);
+  mysql_mutex_destroy(&element->LOCK_table_share);
+  DBUG_VOID_RETURN;
+}
+
+
+static void tdc_hash_initializer(LF_HASH *,
+                                 TDC_element *element, LEX_STRING *key)
+{
+  memcpy(element->m_key, key->str, key->length);
+  element->m_key_length= (uint)key->length;
+  tdc_assert_clean_share(element);
+}
+
+
+static uchar *tdc_hash_key(const TDC_element *element, size_t *length,
+                           my_bool)
+{
+  *length= element->m_key_length;
+  return (uchar*) element->m_key;
+}
+
+
+/**
+  Initialize table definition cache.
+*/
+
+bool tdc_init(void)
+{
+  DBUG_ENTER("tdc_init");
+#ifdef HAVE_PSI_INTERFACE
+  mysql_mutex_register("sql", all_tc_mutexes, array_elements(all_tc_mutexes));
+  mysql_cond_register("sql", all_tc_conds, array_elements(all_tc_conds));
+#endif
+  /* Extra instance is allocated to avoid false sharing */
+  if (!(tc= new Table_cache_instance[tc_instances + 1]))
+    DBUG_RETURN(true);
+  tc_allocated_size= (tc_instances + 1) * sizeof *tc;
+  update_malloc_size(tc_allocated_size, 0);
+  tdc_inited= true;
+  mysql_mutex_init(key_LOCK_unused_shares, &LOCK_unused_shares,
+                   MY_MUTEX_INIT_FAST);
+  lf_hash_init(&tdc_hash, sizeof(TDC_element) +
+                          sizeof(Share_free_tables) * (tc_instances - 1),
+               LF_HASH_UNIQUE, 0, 0,
+               (my_hash_get_key) tdc_hash_key,
+               &my_charset_bin);
+  tdc_hash.alloc.constructor= lf_alloc_constructor;
+  tdc_hash.alloc.destructor= lf_alloc_destructor;
+  tdc_hash.initializer= (lf_hash_initializer) tdc_hash_initializer;
+  DBUG_RETURN(false);
+}
+
+
+/**
+  Notify table definition cache that process of shutting down server
+  has started so it has to keep number of TABLE and TABLE_SHARE objects
+  minimal in order to reduce number of references to pluggable engines.
+*/
+
+void tdc_start_shutdown(void)
+{
+  DBUG_ENTER("tdc_start_shutdown");
+  if (tdc_inited)
+  {
+    /*
+      Ensure that TABLE and TABLE_SHARE objects which are created for
+      tables that are open during process of plugins' shutdown are
+      immediately released. This keeps number of references to engine
+      plugins minimal and allows shutdown to proceed smoothly.
+    */
+    tdc_size= 0;
+    tc_size= 0;
+    /* Free all cached but unused TABLEs and TABLE_SHAREs. */
+    purge_tables();
+  }
+  DBUG_VOID_RETURN;
+}
+
+
+/**
+  Deinitialize table definition cache.
+*/
+
+void tdc_deinit(void)
+{
+  DBUG_ENTER("tdc_deinit");
+  if (tdc_inited)
+  {
+    tdc_inited= false;
+    lf_hash_destroy(&tdc_hash);
+    mysql_mutex_destroy(&LOCK_unused_shares);
+    if (tc)
+    {
+      tc->mark_memory_freed();
+      delete [] tc;
+      tc= 0;
+    }
+  }
+  DBUG_VOID_RETURN;
+}
+
+
+/**
+  Get number of cached table definitions.
+
+  @return Number of cached table definitions
+*/
+
+ulong tdc_records(void)
+{
+  return lf_hash_size(&tdc_hash);
+}
+
+
+void tdc_purge(bool all)
+{
+  DBUG_ENTER("tdc_purge");
+  while (all || tdc_records() > tdc_size)
+  {
+    TDC_element *element;
+
+    mysql_mutex_lock(&LOCK_unused_shares);
+    if (!(element= unused_shares.pop_front()))
+    {
+      mysql_mutex_unlock(&LOCK_unused_shares);
+      break;
+    }
+
+    /* Concurrent thread may start using share again, reset prev and next. */
+    element->prev= 0;
+    element->next= 0;
+    mysql_mutex_lock(&element->LOCK_table_share);
+    if (element->ref_count)
+    {
+      mysql_mutex_unlock(&element->LOCK_table_share);
+      mysql_mutex_unlock(&LOCK_unused_shares);
+      continue;
+    }
+    mysql_mutex_unlock(&LOCK_unused_shares);
+
+    tdc_delete_share_from_hash(element);
+  }
+  DBUG_VOID_RETURN;
+}
+
+
+/**
+  Lock table share.
+
+  Find table share with given db.table_name in table definition cache. Return
+  locked table share if found.
+
+  Locked table share means:
+  - table share is protected against removal from table definition cache
+  - no other thread can acquire/release table share
+
+  Caller is expected to unlock table share with tdc_unlock_share().
+
+  @retval 0 Share not found
+  @retval MY_ERRPTR OOM
+  @retval ptr Pointer to locked table share
+*/
+
+TDC_element *tdc_lock_share(THD *thd, const char *db, const char *table_name)
+{
+  TDC_element *element;
+  char key[MAX_DBKEY_LENGTH];
+
+  DBUG_ENTER("tdc_lock_share");
+  if (unlikely(fix_thd_pins(thd)))
+    DBUG_RETURN((TDC_element*) MY_ERRPTR);
+
+  element= (TDC_element *) lf_hash_search(&tdc_hash, thd->tdc_hash_pins,
+                                          (uchar*) key,
+                                          tdc_create_key(key, db, table_name));
+  if (element)
+  {
+    mysql_mutex_lock(&element->LOCK_table_share);
+    if (unlikely(!element->share || element->share->error))
+    {
+      mysql_mutex_unlock(&element->LOCK_table_share);
+      element= 0;
+    }
+    lf_hash_search_unpin(thd->tdc_hash_pins);
+  }
+
+  DBUG_RETURN(element);
+}
+
+
+/**
+  Unlock share locked by tdc_lock_share().
+*/
+
+void tdc_unlock_share(TDC_element *element)
+{
+  DBUG_ENTER("tdc_unlock_share");
+  mysql_mutex_unlock(&element->LOCK_table_share);
+  DBUG_VOID_RETURN;
+}
+
+
+int tdc_share_is_cached(THD *thd, const char *db, const char *table_name)
+{
+  char key[MAX_DBKEY_LENGTH];
+
+  if (unlikely(fix_thd_pins(thd)))
+    return -1;
+
+  if (lf_hash_search(&tdc_hash, thd->tdc_hash_pins, (uchar*) key,
+                     tdc_create_key(key, db, table_name)))
+  {
+    lf_hash_search_unpin(thd->tdc_hash_pins);
+    return 1;
+  }
+  return 0;
+}
+
+
+/*
+  Get TABLE_SHARE for a table.
+
+  tdc_acquire_share()
+  thd                   Thread handle
+  tl                    Table that should be opened
+  flags                 operation: what to open table or view
+  out_table             TABLE for the requested table
+
+  IMPLEMENTATION
+    Get a table definition from the table definition cache.
+    If it doesn't exist, create a new from the table definition file.
+
+  RETURN
+   0  Error
+   #  Share for table
+*/
+
+TABLE_SHARE *tdc_acquire_share(THD *thd, TABLE_LIST *tl, uint flags,
+                               TABLE **out_table)
+{
+  TABLE_SHARE *share;
+  TDC_element *element;
+  const char *key;
+  uint key_length= get_table_def_key(tl, &key);
+  my_hash_value_type hash_value= tl->mdl_request.key.tc_hash_value();
+  bool was_unused;
+  DBUG_ENTER("tdc_acquire_share");
+
+  if (fix_thd_pins(thd))
+    DBUG_RETURN(0);
+
+retry:
+  while (!(element= (TDC_element*) lf_hash_search_using_hash_value(&tdc_hash,
+                    thd->tdc_hash_pins, hash_value, (uchar*) key, key_length)))
+  {
+    LEX_STRING tmp= { const_cast<char*>(key), key_length };
+    int res= lf_hash_insert(&tdc_hash, thd->tdc_hash_pins, (uchar*) &tmp);
+
+    if (res == -1)
+      DBUG_RETURN(0);
+    else if (res == 1)
+      continue;
+
+    element= (TDC_element*) lf_hash_search_using_hash_value(&tdc_hash,
+             thd->tdc_hash_pins, hash_value, (uchar*) key, key_length);
+    /* It's safe to unpin the pins here, because an empty element was inserted
+    above, "empty" means at least element->share = 0. Some other thread can't
+    delete it while element->share == 0. And element->share is also protected
+    with element->LOCK_table_share mutex. */
+    lf_hash_search_unpin(thd->tdc_hash_pins);
+    DBUG_ASSERT(element);
+
+    if (!(share= alloc_table_share(tl->db.str, tl->table_name.str, key, key_length)))
+    {
+      lf_hash_delete(&tdc_hash, thd->tdc_hash_pins, key, key_length);
+      DBUG_RETURN(0);
+    }
+
+    /* note that tdc_acquire_share() *always* uses discovery */
+    open_table_def(thd, share, flags | GTS_USE_DISCOVERY);
+
+    if (checked_unlikely(share->error))
+    {
+      free_table_share(share);
+      lf_hash_delete(&tdc_hash, thd->tdc_hash_pins, key, key_length);
+      DBUG_RETURN(0);
+    }
+
+    mysql_mutex_lock(&element->LOCK_table_share);
+    element->share= share;
+    share->tdc= element;
+    element->ref_count++;
+    element->flushed= false;
+    mysql_mutex_unlock(&element->LOCK_table_share);
+
+    tdc_purge(false);
+    if (out_table)
+    {
+      status_var_increment(thd->status_var.table_open_cache_misses);
+      *out_table= 0;
+    }
+    share->m_psi= PSI_CALL_get_table_share(false, share);
+    goto end;
+  }
+
+  /* cannot force discovery of a cached share */
+  DBUG_ASSERT(!(flags & GTS_FORCE_DISCOVERY));
+
+  if (out_table && (flags & GTS_TABLE))
+  {
+    if ((*out_table= tc_acquire_table(thd, element)))
+    {
+      lf_hash_search_unpin(thd->tdc_hash_pins);
+      DBUG_ASSERT(!(flags & GTS_NOLOCK));
+      DBUG_ASSERT(element->share);
+      DBUG_ASSERT(!element->share->error);
+      DBUG_ASSERT(!element->share->is_view);
+      status_var_increment(thd->status_var.table_open_cache_hits);
+      DBUG_RETURN(element->share);
+    }
+    status_var_increment(thd->status_var.table_open_cache_misses);
+  }
+
+  mysql_mutex_lock(&element->LOCK_table_share);
+  if (!(share= element->share))
+  {
+    mysql_mutex_unlock(&element->LOCK_table_share);
+    lf_hash_search_unpin(thd->tdc_hash_pins);
+    goto retry;
+  }
+  lf_hash_search_unpin(thd->tdc_hash_pins);
+
+  /*
+     We found an existing table definition. Return it if we didn't get
+     an error when reading the table definition from file.
+  */
+  if (unlikely(share->error))
+  {
+    open_table_error(share, share->error, share->open_errno);
+    goto err;
+  }
+
+  if (share->is_view && !(flags & GTS_VIEW))
+  {
+    open_table_error(share, OPEN_FRM_NOT_A_TABLE, ENOENT);
+    goto err;
+  }
+  if (!share->is_view && !(flags & GTS_TABLE))
+  {
+    open_table_error(share, OPEN_FRM_NOT_A_VIEW, ENOENT);
+    goto err;
+  }
+
+  was_unused= !element->ref_count;
+  element->ref_count++;
+  mysql_mutex_unlock(&element->LOCK_table_share);
+  if (was_unused)
+  {
+    mysql_mutex_lock(&LOCK_unused_shares);
+    if (element->prev)
+    {
+      /*
+        Share was not used before and it was in the old_unused_share list
+        Unlink share from this list
+      */
+      DBUG_PRINT("info", ("Unlinking from not used list"));
+      unused_shares.remove(element);
+      element->next= 0;
+      element->prev= 0;
+    }
+    mysql_mutex_unlock(&LOCK_unused_shares);
+  }
+
+end:
+  DBUG_PRINT("exit", ("share: %p  ref_count: %u",
+                      share, share->tdc->ref_count));
+  if (flags & GTS_NOLOCK)
+  {
+    tdc_release_share(share);
+    /*
+      if GTS_NOLOCK is requested, the returned share pointer cannot be used,
+      the share it points to may go away any moment.
+      But perhaps the caller is only interested to know whether a share or
+      table existed?
+      Let's return an invalid pointer here to catch dereferencing attempts.
+    */
+    share= UNUSABLE_TABLE_SHARE;
+  }
+  DBUG_RETURN(share);
+
+err:
+  mysql_mutex_unlock(&element->LOCK_table_share);
+  DBUG_RETURN(0);
+}
+
+
+/**
+  Release table share acquired by tdc_acquire_share().
+*/
+
+void tdc_release_share(TABLE_SHARE *share)
+{
+  DBUG_ENTER("tdc_release_share");
+
+  mysql_mutex_lock(&share->tdc->LOCK_table_share);
+  DBUG_PRINT("enter",
+             ("share: %p  table: %s.%s  ref_count: %u",
+              share, share->db.str, share->table_name.str,
+              share->tdc->ref_count));
+  DBUG_ASSERT(share->tdc->ref_count);
+
+  if (share->tdc->ref_count > 1)
+  {
+    share->tdc->ref_count--;
+    if (!share->is_view)
+      mysql_cond_broadcast(&share->tdc->COND_release);
+    mysql_mutex_unlock(&share->tdc->LOCK_table_share);
+    DBUG_VOID_RETURN;
+  }
+  mysql_mutex_unlock(&share->tdc->LOCK_table_share);
+
+  mysql_mutex_lock(&LOCK_unused_shares);
+  mysql_mutex_lock(&share->tdc->LOCK_table_share);
+  if (--share->tdc->ref_count)
+  {
+    if (!share->is_view)
+      mysql_cond_broadcast(&share->tdc->COND_release);
+    mysql_mutex_unlock(&share->tdc->LOCK_table_share);
+    mysql_mutex_unlock(&LOCK_unused_shares);
+    DBUG_VOID_RETURN;
+  }
+  if (share->tdc->flushed || tdc_records() > tdc_size)
+  {
+    mysql_mutex_unlock(&LOCK_unused_shares);
+    tdc_delete_share_from_hash(share->tdc);
+    DBUG_VOID_RETURN;
+  }
+  /* Link share last in used_table_share list */
+  DBUG_PRINT("info", ("moving share to unused list"));
+  DBUG_ASSERT(share->tdc->next == 0);
+  unused_shares.push_back(share->tdc);
+  mysql_mutex_unlock(&share->tdc->LOCK_table_share);
+  mysql_mutex_unlock(&LOCK_unused_shares);
+  DBUG_VOID_RETURN;
+}
+
+
+void tdc_remove_referenced_share(THD *thd, TABLE_SHARE *share)
+{
+  DBUG_ASSERT(thd->mdl_context.is_lock_owner(MDL_key::TABLE, share->db.str,
+                                             share->table_name.str,
+                                             MDL_EXCLUSIVE));
+  share->tdc->flush_unused(true);
+  mysql_mutex_lock(&share->tdc->LOCK_table_share);
+  DEBUG_SYNC(thd, "before_wait_for_refs");
+  share->tdc->wait_for_refs(1);
+  DBUG_ASSERT(share->tdc->all_tables.is_empty());
+  share->tdc->ref_count--;
+  tdc_delete_share_from_hash(share->tdc);
+}
+
+
+/**
+   Removes all TABLE instances and corresponding TABLE_SHARE
+
+   @param  thd          Thread context
+   @param  db           Name of database
+   @param  table_name   Name of table
+
+   @note It assumes that table instances are already not used by any
+   (other) thread (this should be achieved by using meta-data locks).
+*/
+
+void tdc_remove_table(THD *thd, const char *db, const char *table_name)
+{
+  TDC_element *element;
+  DBUG_ENTER("tdc_remove_table");
+  DBUG_PRINT("enter", ("name: %s", table_name));
+
+  DBUG_ASSERT(thd->mdl_context.is_lock_owner(MDL_key::TABLE, db, table_name,
+                                             MDL_EXCLUSIVE));
+
+  mysql_mutex_lock(&LOCK_unused_shares);
+  if (!(element= tdc_lock_share(thd, db, table_name)))
+  {
+    mysql_mutex_unlock(&LOCK_unused_shares);
+    DBUG_VOID_RETURN;
+  }
+
+  DBUG_ASSERT(element != MY_ERRPTR); // What can we do about it?
+
+  if (!element->ref_count)
+  {
+    if (element->prev)
+    {
+      unused_shares.remove(element);
+      element->prev= 0;
+      element->next= 0;
+    }
+    mysql_mutex_unlock(&LOCK_unused_shares);
+
+    tdc_delete_share_from_hash(element);
+    DBUG_VOID_RETURN;
+  }
+  mysql_mutex_unlock(&LOCK_unused_shares);
+
+  element->ref_count++;
+  mysql_mutex_unlock(&element->LOCK_table_share);
+
+  /* We have to relock the mutex to avoid code duplication. Sigh. */
+  tdc_remove_referenced_share(thd, element->share);
+  DBUG_VOID_RETURN;
+}
+
+
+/**
+  Check if table's share is being removed from the table definition
+  cache and, if yes, wait until the flush is complete.
+
+  @param thd             Thread context.
+  @param table_list      Table which share should be checked.
+  @param timeout         Timeout for waiting.
+  @param deadlock_weight Weight of this wait for deadlock detector.
+
+  @retval 0       Success. Share is up to date or has been flushed.
+  @retval 1       Error (OOM, was killed, the wait resulted
+                  in a deadlock or timeout). Reported.
+*/
+
+int tdc_wait_for_old_version(THD *thd, const char *db, const char *table_name,
+                             ulong wait_timeout, uint deadlock_weight)
+{
+  TDC_element *element;
+
+  if (!(element= tdc_lock_share(thd, db, table_name)))
+    return FALSE;
+  else if (element == MY_ERRPTR)
+    return TRUE;
+  else if (element->flushed)
+  {
+    struct timespec abstime;
+    set_timespec(abstime, wait_timeout);
+    return element->share->wait_for_old_version(thd, &abstime, deadlock_weight);
+  }
+  tdc_unlock_share(element);
+  return FALSE;
+}
+
+
+/**
+  Iterate table definition cache.
+
+  Object is protected against removal from table definition cache.
+
+  @note Returned TABLE_SHARE is not guaranteed to be fully initialized:
+  tdc_acquire_share() added new share, but didn't open it yet. If caller
+  needs fully initializer share, it must lock table share mutex.
+*/
+
+struct eliminate_duplicates_arg
+{
+  HASH hash;
+  MEM_ROOT root;
+  my_hash_walk_action action;
+  void *argument;
+};
+
+
+static uchar *eliminate_duplicates_get_key(const uchar *element, size_t *length,
+                                       my_bool not_used __attribute__((unused)))
+{
+  LEX_STRING *key= (LEX_STRING *) element;
+  *length= key->length;
+  return (uchar *) key->str;
+}
+
+
+static my_bool eliminate_duplicates(TDC_element *element,
+                                    eliminate_duplicates_arg *arg)
+{
+  LEX_STRING *key= (LEX_STRING *) alloc_root(&arg->root, sizeof(LEX_STRING));
+
+  if (!key || !(key->str= (char*) memdup_root(&arg->root, element->m_key,
+                                              element->m_key_length)))
+    return TRUE;
+
+  key->length= element->m_key_length;
+
+  if (my_hash_insert(&arg->hash, (uchar *) key))
+    return FALSE;
+
+  return arg->action(element, arg->argument);
+}
+
+
+int tdc_iterate(THD *thd, my_hash_walk_action action, void *argument,
+                bool no_dups)
+{
+  eliminate_duplicates_arg no_dups_argument;
+  LF_PINS *pins;
+  myf alloc_flags= 0;
+  uint hash_flags= HASH_UNIQUE;
+  int res;
+
+  if (thd)
+  {
+    fix_thd_pins(thd);
+    pins= thd->tdc_hash_pins;
+    alloc_flags= MY_THREAD_SPECIFIC;
+    hash_flags|= HASH_THREAD_SPECIFIC;
+  }
+  else
+    pins= lf_hash_get_pins(&tdc_hash);
+
+  if (!pins)
+    return ER_OUTOFMEMORY;
+
+  if (no_dups)
+  {
+    init_alloc_root(PSI_INSTRUMENT_ME, &no_dups_argument.root, 4096, 4096, MYF(alloc_flags));
+    my_hash_init(PSI_INSTRUMENT_ME, &no_dups_argument.hash, &my_charset_bin,
+                 tdc_records(), 0, 0, eliminate_duplicates_get_key, 0,
+                 hash_flags);
+    no_dups_argument.action= action;
+    no_dups_argument.argument= argument;
+    action= (my_hash_walk_action) eliminate_duplicates;
+    argument= &no_dups_argument;
+  }
+
+  res= lf_hash_iterate(&tdc_hash, pins, action, argument);
+
+  if (!thd)
+    lf_hash_put_pins(pins);
+
+  if (no_dups)
+  {
+    my_hash_free(&no_dups_argument.hash);
+    free_root(&no_dups_argument.root, MYF(0));
+  }
+  return res;
+}
+
+
+int show_tc_active_instances(THD *thd, SHOW_VAR *var, char *buff,
+                             enum enum_var_type scope)
+{
+  var->type= SHOW_UINT;
+  var->value= buff;
+  *(reinterpret_cast<uint32_t*>(buff))=
+    tc_active_instances.load(std::memory_order_relaxed);
+  return 0;
+}
+
+
+/**
+  Waits until ref_count goes down to given number
+
+  @param  my_refs  Number of references owned by the caller
+
+  Caller must own at least one TABLE_SHARE reference.
+
+  Even though current thread holds exclusive metadata lock on this share,
+  concurrent FLUSH TABLES threads may be in process of closing unused table
+  instances belonging to this share. E.g.:
+  thr1 (FLUSH TABLES): table= share->tdc.free_tables.pop_front();
+  thr1 (FLUSH TABLES): share->tdc.all_tables.remove(table);
+  thr2 (ALTER TABLE): tdc_remove_table();
+  thr1 (FLUSH TABLES): intern_close_table(table);
+
+  Current remove type assumes that all table instances (except for those
+  that are owned by current thread) must be closed before
+  thd_remove_table() returns. Wait for such tables now.
+
+  intern_close_table() decrements ref_count and signals COND_release. When
+  ref_count drops down to number of references owned by current thread
+  waiting is completed.
+
+  Unfortunately TABLE_SHARE::wait_for_old_version() cannot be used here
+  because it waits for all table instances, whereas we have to wait only
+  for those that are not owned by current thread.
+*/
+
+void TDC_element::wait_for_refs(uint my_refs)
+{
+  while (ref_count > my_refs)
+    mysql_cond_wait(&COND_release, &LOCK_table_share);
+}
+
+
+/**
+  Flushes unused TABLE instances
+
+  @param  thd          Thread context
+  @param  mark_flushed Whether to destroy TABLE_SHARE when released
+
+  Caller is allowed to own used TABLE instances.
+  There must be no TABLE objects used by other threads and caller must own
+  exclusive metadata lock on the table.
+*/
+
+void TDC_element::flush(THD *thd, bool mark_flushed)
+{
+  DBUG_ASSERT(thd->mdl_context.is_lock_owner(MDL_key::TABLE, share->db.str,
+                                             share->table_name.str,
+                                             MDL_EXCLUSIVE));
+
+  flush_unused(mark_flushed);
+
+  mysql_mutex_lock(&LOCK_table_share);
+  All_share_tables_list::Iterator it(all_tables);
+  uint my_refs= 0;
+  while (auto table= it++)
+  {
+    if (table->in_use == thd)
+      my_refs++;
+  }
+  wait_for_refs(my_refs);
+#ifndef DBUG_OFF
+  it.rewind();
+  while (auto table= it++)
+    DBUG_ASSERT(table->in_use == thd);
+#endif
+  mysql_mutex_unlock(&LOCK_table_share);
+}
+
+
+/**
+  Flushes unused TABLE instances
+*/
+
+void TDC_element::flush_unused(bool mark_flushed)
+{
+  Share_free_tables::List purge_tables;
+
+  mysql_mutex_lock(&LOCK_table_share);
+  if (mark_flushed)
+    flushed= true;
+  tc_remove_all_unused_tables(this, &purge_tables);
+  mysql_mutex_unlock(&LOCK_table_share);
+
+  while (auto table= purge_tables.pop_front())
+    intern_close_table(table);
+}