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 (const 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) const

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

Static Private Member Functions
static MutexTracker *	getMutexTracker (const Catalog_Namespace::Catalog &catalog, const std::string &table_name)
static void	validateExistingTable (const Catalog_Namespace::Catalog &catalog, const std::string &table_name)
static int32_t	validateAndGetExistingTableId (const 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 158 of file LockMgrImpl.h.

{}

Member Function Documentation

template<class T >

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

protectedvirtual

Definition at line 168 of file LockMgr.cpp.

References cat(), CHECK, CHECK_EQ, CHUNK_KEY_DB_IDX, CHUNK_KEY_TABLE_IDX, g_base_path, Catalog_Namespace::SysCatalog::getCatalog(), Catalog_Namespace::SysCatalog::instance(), shared::kCatalogDirectoryName, shared::kDataDirectoryName, shared::kLockfilesDirectoryName, anonymous_namespace{Utm.h}::n, to_string(), UNREACHABLE, setup::version, VLOG, and File_Namespace::write().

                                                                         {
  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{
        cb_reload_catalog_metadata,  // pre_lock_callback
        cb_reload_table_metadata     // reload_cache_callback
    };
    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(),
            cb_reload_table_data  // reload_cache_callback
        );

    // 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{
        cb_reload_catalog_metadata,  // pre_lock_callback
        {},
        cb_reload_row_data,       // post_lock_callback
        cb_notify_about_row_data  // pre_unlock_callback
    };
    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 call graph for this function:

template<class T >

std::set< ChunkKey > lockmgr::TableLockMgrImpl< T >::getLockedTables

(

)

const

Definition at line 124 of file LockMgr.cpp.

                                                            {
  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 >

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

staticprivate

Definition at line 271 of file LockMgr.cpp.

References CHECK, Catalog_Namespace::Catalog::getDatabaseId(), and lockmgr::instance().

                                 {
  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 call graph for this function:

template<class T >

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

static

Definition at line 152 of file LockMgr.cpp.

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 >

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

static

Definition at line 161 of file LockMgr.cpp.

References lockmgr::instance().

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

Here is the call graph for this function:

template<class T >

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

virtual

Definition at line 107 of file LockMgr.cpp.

                                                                          {
  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 >

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

static

Definition at line 137 of file LockMgr.cpp.

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::load_table_binary_columnar(), 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 >

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

static

Definition at line 146 of file LockMgr.cpp.

References lockmgr::instance().

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

Here is the call graph for this function:

template<class T>

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

static

template<class T >

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

staticprivate

Definition at line 289 of file LockMgr.cpp.

References Catalog_Namespace::Catalog::getTableId(), and Catalog_Namespace::Catalog::name().

                                 {
  auto table_id = catalog.getTableId(table_name);
  if (!table_id.has_value()) {
    throw Catalog_Namespace::TableNotFoundException(table_name, catalog.name());
  }
  return table_id.value();
}

Here is the call graph for this function:

template<class T >

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

staticprivate

Definition at line 283 of file LockMgr.cpp.

                                                                             {
  validateAndGetExistingTableId(catalog, table_name);
}

Member Data Documentation

template<class T>

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

mutableprotected

Definition at line 163 of file LockMgrImpl.h.

template<class T>

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

protected

Definition at line 164 of file LockMgrImpl.h.

---

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
• /home/jenkins-slave/workspace/core-os-doxygen/LockMgr/LockMgr.cpp