lockmgr::TableLockMgrImpl< T > Class Template Reference

#include <Catalog.h>

Inheritance diagram for lockmgr::TableLockMgrImpl< T >:

Public Member Functions
virtual	~TableLockMgrImpl ()=default
virtual MutexTracker *	getTableMutex (const ChunkKey table_key)
std::set< ChunkKey >	getLockedTables () const

Static Public Member Functions
static T &	instance ()
static WriteLock	getWriteLockForTable (Catalog_Namespace::Catalog &cat, const std::string &table_name)
static WriteLock	getWriteLockForTable (const ChunkKey table_key)
static ReadLock	getReadLockForTable (Catalog_Namespace::Catalog &cat, const std::string &table_name)
static ReadLock	getReadLockForTable (const ChunkKey table_key)

Protected Member Functions
	TableLockMgrImpl ()
virtual std::unique_ptr < heavyai::DistributedSharedMutex >	getClusterTableMutex (const ChunkKey table_key)

Protected Attributes
std::mutex	map_mutex_
std::map< ChunkKey, std::unique_ptr< MutexTracker > >	table_mutex_map_

Static Private Member Functions
static MutexTracker *	getMutexTracker (Catalog_Namespace::Catalog &catalog, const std::string &table_name)
static void	validateExistingTable (Catalog_Namespace::Catalog &catalog, const std::string &table_name)
static int32_t	validateAndGetExistingTableId (Catalog_Namespace::Catalog &catalog, const std::string &table_name)

Detailed Description

template<class T>
class lockmgr::TableLockMgrImpl< T >

Definition at line 68 of file Catalog.h.

Constructor & Destructor Documentation

template<class T>

virtual lockmgr::TableLockMgrImpl< T >::~TableLockMgrImpl ( )

virtualdefault

template<class T>

lockmgr::TableLockMgrImpl< T >::TableLockMgrImpl ( )

inlineprotected

Definition at line 252 of file LockMgrImpl.h.

{}

Member Function Documentation

template<class T>

virtual std::unique_ptr<heavyai::DistributedSharedMutex> lockmgr::TableLockMgrImpl< T >::getClusterTableMutex ( const ChunkKey  table_key )

inlineprotectedvirtual

Definition at line 254 of file LockMgrImpl.h.

Referenced by lockmgr::TableLockMgrImpl< TableDataLockMgr >::getTableMutex().

                                {
    std::unique_ptr<heavyai::DistributedSharedMutex> table_mutex;

    std::string table_key_as_text;
    for (auto n : table_key) {
      table_key_as_text += (!table_key_as_text.empty() ? "_" : "") + std::to_string(n);
    }

    // A callback used for syncing with most of the changed Catalog metadata, in-general,
    // such as the list of tables that exist, dashboards, etc. This is accomplished by
    // read locking, and immediately unlocking, dcatalogMutex_, so
    // cat->reloadCatalogMetadataUnlocked() will be called.
    auto cb_reload_catalog_metadata = [table_key](bool write) {
      if constexpr (T::kind == "insert") {
        CHECK(write);  // The insert lock is for writing, never for reading.
      }
      auto cat = Catalog_Namespace::SysCatalog::instance().getCatalog(
          table_key[CHUNK_KEY_DB_IDX]);
      CHECK(cat);
      heavyai::shared_lock<heavyai::DistributedSharedMutex> dread_lock(
          *cat->dcatalogMutex_);
    };

    if constexpr (T::kind == "schema") {
      // A callback used for reloading the Catalog schema for the one table being locked.
      auto cb_reload_table_metadata = [table_key, table_key_as_text](size_t version) {
        VLOG(2) << "reloading table metadata for: table_" << table_key_as_text;
        CHECK_EQ(table_key.size(), 2U);
        auto cat = Catalog_Namespace::SysCatalog::instance().getCatalog(
            table_key[CHUNK_KEY_DB_IDX]);
        CHECK(cat);
        heavyai::shared_lock<heavyai::DistributedSharedMutex> dread_lock(
            *cat->dcatalogMutex_);
        cat->reloadTableMetadataUnlocked(table_key[CHUNK_KEY_TABLE_IDX]);
      };

      // Create the table mutex.
      heavyai::DistributedSharedMutex::Callbacks cbs{
          /*pre_lock_callback=*/cb_reload_catalog_metadata,
          /*reload_cache_callback=*/cb_reload_table_metadata};
      auto schema_lockfile{
          std::filesystem::path(g_base_path) / shared::kLockfilesDirectoryName /
          shared::kCatalogDirectoryName /
          ("table_" + table_key_as_text + "." + T::kind.data() + ".lockfile")};
      table_mutex = std::make_unique<heavyai::DistributedSharedMutex>(
          schema_lockfile.string(), cbs);
    } else if constexpr (T::kind == "data" || T::kind == "insert") {
      // A callback used for reloading the DataMgr data for the one table being locked.
      auto cb_reload_table_data = [table_key, table_key_as_text](size_t version) {
        VLOG(2) << "invalidating table caches for new version " << version
                << " of: table_" << table_key_as_text;
        CHECK_EQ(table_key.size(), 2U);
        auto cat = Catalog_Namespace::SysCatalog::instance().getCatalog(
            table_key[CHUNK_KEY_DB_IDX]);
        CHECK(cat);
        cat->invalidateCachesForTable(table_key[CHUNK_KEY_TABLE_IDX]);
      };

      // Create the rows mutex.
      auto rows_lockfile{std::filesystem::path(g_base_path) /
                         shared::kLockfilesDirectoryName / shared::kDataDirectoryName /
                         ("table_" + table_key_as_text + ".rows.lockfile")};
      std::shared_ptr<heavyai::DistributedSharedMutex> rows_mutex =
          std::make_shared<heavyai::DistributedSharedMutex>(
              rows_lockfile.string(),
              /*reload_cache_callback=*/cb_reload_table_data);

      // A callback used for syncing with outside changes to this table's row data.
      auto cb_reload_row_data = [table_key, rows_mutex](bool /*write*/) {
        heavyai::shared_lock<heavyai::DistributedSharedMutex> rows_read_lock(*rows_mutex);
      };

      // A callback to notify other nodes about our changes to this table's row data.
      auto cb_notify_about_row_data = [table_key, rows_mutex](bool write) {
        if (write) {
          heavyai::unique_lock<heavyai::DistributedSharedMutex> rows_write_lock(
              *rows_mutex);
        }
      };

      // Create the table mutex.
      heavyai::DistributedSharedMutex::Callbacks cbs{
          /*pre_lock_callback=*/cb_reload_catalog_metadata,
          {},
          /*post_lock_callback=*/cb_reload_row_data,
          /*pre_unlock_callback=*/cb_notify_about_row_data};
      auto table_lockfile{
          std::filesystem::path(g_base_path) / shared::kLockfilesDirectoryName /
          shared::kDataDirectoryName /
          ("table_" + table_key_as_text + "." + T::kind.data() + ".lockfile")};
      table_mutex =
          std::make_unique<heavyai::DistributedSharedMutex>(table_lockfile.string(), cbs);
    } else {
      UNREACHABLE() << "unexpected lockmgr kind: " << T::kind;
    }

    return table_mutex;
  }

Here is the caller graph for this function:

template<class T>

std::set<ChunkKey> lockmgr::TableLockMgrImpl< T >::getLockedTables ( ) const

inline

Definition at line 213 of file LockMgrImpl.h.

                                           {
    std::set<ChunkKey> ret;
    std::lock_guard<std::mutex> access_map_lock(map_mutex_);
    for (const auto& kv : table_mutex_map_) {
      if (kv.second->isAcquired()) {
        ret.insert(kv.first);
      }
    }

    return ret;
  }

template<class T>

static MutexTracker* lockmgr::TableLockMgrImpl< T >::getMutexTracker ( Catalog_Namespace::Catalog &  catalog, const std::string &  table_name  )

inlinestaticprivate

Definition at line 358 of file LockMgrImpl.h.

Referenced by lockmgr::TableLockMgrImpl< TableDataLockMgr >::getReadLockForTable(), and lockmgr::TableLockMgrImpl< TableDataLockMgr >::getWriteLockForTable().

                                                                    {
    ChunkKey chunk_key{catalog.getDatabaseId(),
                       validateAndGetExistingTableId(catalog, table_name)};
    auto& table_lock_mgr = T::instance();
    MutexTracker* tracker = table_lock_mgr.getTableMutex(chunk_key);
    CHECK(tracker);
    return tracker;
  }

Here is the caller graph for this function:

template<class T>

static ReadLock lockmgr::TableLockMgrImpl< T >::getReadLockForTable ( Catalog_Namespace::Catalog &  cat, const std::string &  table_name  )

inlinestatic

Definition at line 238 of file LockMgrImpl.h.

Referenced by lockmgr::TableInsertLockContainer< ReadLock >::acquire().

                                                                   {
    auto lock = ReadLock(getMutexTracker(cat, table_name));
    // Ensure table still exists after lock is acquired.
    validateAndGetExistingTableId(cat, table_name);
    return lock;
  }

Here is the caller graph for this function:

template<class T>

static ReadLock lockmgr::TableLockMgrImpl< T >::getReadLockForTable ( const ChunkKey  table_key )

inlinestatic

Definition at line 246 of file LockMgrImpl.h.

                                                                {
    auto& table_lock_mgr = T::instance();
    return ReadLock(table_lock_mgr.getTableMutex(table_key));
  }

template<class T>

virtual MutexTracker* lockmgr::TableLockMgrImpl< T >::getTableMutex ( const ChunkKey  table_key )

inlinevirtual

Definition at line 197 of file LockMgrImpl.h.

                                                                {
    std::lock_guard<std::mutex> access_map_lock(map_mutex_);
    auto mutex_it = table_mutex_map_.find(table_key);
    if (mutex_it != table_mutex_map_.end()) {
      return mutex_it->second.get();
    }

    // NOTE(sy): Only used by --multi-instance clusters.
    std::unique_ptr<heavyai::DistributedSharedMutex> dmutex =
        getClusterTableMutex(table_key);

    return table_mutex_map_
        .emplace(table_key, std::make_unique<MutexTracker>(std::move(dmutex)))
        .first->second.get();
  }

template<class T>

static WriteLock lockmgr::TableLockMgrImpl< T >::getWriteLockForTable ( Catalog_Namespace::Catalog &  cat, const std::string &  table_name  )

inlinestatic

Definition at line 225 of file LockMgrImpl.h.

Referenced by lockmgr::TableInsertLockContainer< WriteLock >::acquire(), Parser::CopyTableStmt::execute(), Parser::InsertValuesStmt::execute(), DBHandler::import_table(), DBHandler::importGeoTableSingle(), DBHandler::insert_chunks(), DBHandler::insert_data(), DBHandler::load_table(), DBHandler::load_table_binary(), DBHandler::load_table_binary_arrow(), DBHandler::loadTableBinaryColumnarInternal(), and TableArchiver::restoreTable().

                                                                     {
    auto lock = WriteLock(getMutexTracker(cat, table_name));
    // Ensure table still exists after lock is acquired.
    validateExistingTable(cat, table_name);
    return lock;
  }

Here is the caller graph for this function:

template<class T>

static WriteLock lockmgr::TableLockMgrImpl< T >::getWriteLockForTable ( const ChunkKey  table_key )

inlinestatic

Definition at line 233 of file LockMgrImpl.h.

                                                                  {
    auto& table_lock_mgr = T::instance();
    return WriteLock(table_lock_mgr.getTableMutex(table_key));
  }

template<class T>

static T& lockmgr::TableLockMgrImpl< T >::instance ( )

inlinestatic

Definition at line 191 of file LockMgrImpl.h.

                       {
    static T mgr;
    return mgr;
  }

template<class T>

static int32_t lockmgr::TableLockMgrImpl< T >::validateAndGetExistingTableId ( Catalog_Namespace::Catalog &  catalog, const std::string &  table_name  )

inlinestaticprivate

Definition at line 373 of file LockMgrImpl.h.

Referenced by lockmgr::TableLockMgrImpl< TableDataLockMgr >::getMutexTracker(), lockmgr::TableLockMgrImpl< TableDataLockMgr >::getReadLockForTable(), and lockmgr::TableLockMgrImpl< TableDataLockMgr >::validateExistingTable().

                                                                            {
    auto table_id = catalog.getTableId(table_name);
    if (!table_id.has_value()) {
      throw std::runtime_error("Table/View " + table_name + " for catalog " +
                               catalog.name() + " does not exist");
    }
    return table_id.value();
  }

Here is the caller graph for this function:

template<class T>

static void lockmgr::TableLockMgrImpl< T >::validateExistingTable ( Catalog_Namespace::Catalog &  catalog, const std::string &  table_name  )

inlinestaticprivate

Definition at line 368 of file LockMgrImpl.h.

Referenced by lockmgr::TableLockMgrImpl< TableDataLockMgr >::getWriteLockForTable().

                                                                 {
    validateAndGetExistingTableId(catalog, table_name);
  }

Here is the caller graph for this function:

Member Data Documentation

template<class T>

std::mutex lockmgr::TableLockMgrImpl< T >::map_mutex_

mutableprotected

Definition at line 354 of file LockMgrImpl.h.

Referenced by lockmgr::TableLockMgrImpl< TableDataLockMgr >::getLockedTables(), and lockmgr::TableLockMgrImpl< TableDataLockMgr >::getTableMutex().

template<class T>

std::map<ChunkKey, std::unique_ptr<MutexTracker> > lockmgr::TableLockMgrImpl< T >::table_mutex_map_

protected

Definition at line 355 of file LockMgrImpl.h.

Referenced by lockmgr::TableLockMgrImpl< TableDataLockMgr >::getLockedTables(), and lockmgr::TableLockMgrImpl< TableDataLockMgr >::getTableMutex().

---

The documentation for this class was generated from the following files:

• /home/jenkins-slave/workspace/core-os-doxygen/Catalog/Catalog.h
• /home/jenkins-slave/workspace/core-os-doxygen/LockMgr/LockMgrImpl.h