[yugabyte#25379] docdb: Introduce per-transaction LockTracker state

Summary:
The current LockTracker implementation for ObjectLockManager involves a multi-index
container uniquely keyed on (versioned_txn, subtxn_id, object_id) and additionally indexed on
various subsets of the unique key. This means that we have to acquire the global
mutex an additional time on lock acquire/release/wait/wakeup.

This diff refactors this map to instead be keyed on versioned_txn and point to a per-transaction
struct (TrackedTransactionLockEntry) which contains a further
subtxn_id => object_id => TrackedLockEntry mapping. This allows us to pass around this new
TrackedTransactionLockEntry and avoid the need for a repeated global mutex lock for LockTracker
functionality.

TrackedTransactionLockEntry is currently only briefly passed around through the lock acquire path
to avoid repeated global mutex locks; storing it externally to help avoid the need for the initial
global mutex lock will be addressed in a later diff.

This is also needed for the planned move of ObjectLockManager into shared memory, to avoid
partially updated indexes in the multi-index in event of PG crashing while inserting/deleting from
the container.
Jira: DB-14609

Test Plan: Jenkins.

Reviewers: bkolagani

Reviewed By: bkolagani

Subscribers: sergei, ybase

Differential Revision: https://phorge.dev.yugabyte.com/D40814

Author: es1024

src/yb/docdb/object_lock_data.h

@@ -31,29 +31,22 @@ struct VersionedTransaction {
 
   YB_STRUCT_DEFINE_HASH(VersionedTransaction, txn_id, txn_version);
 
+  auto operator<=>(const VersionedTransaction&) const = default;
+
   std::string ToString() const {
     return YB_STRUCT_TO_STRING(txn_id, txn_version);
   }
 };
 
-inline bool operator==(const VersionedTransaction& lhs, const VersionedTransaction& rhs) {
-  return YB_STRUCT_EQUALS(txn_id, txn_version);
-}
-
-inline bool operator<(const VersionedTransaction& lhs, const VersionedTransaction& rhs) {
-  if (lhs.txn_id != rhs.txn_id) {
-    return lhs.txn_id < rhs.txn_id;
-  }
-  return lhs.txn_version < rhs.txn_version;
-}
-
 struct ObjectLockOwner {
   VersionedTransaction versioned_txn;
   SubTransactionId subtxn_id;
 
   ObjectLockOwner(
       const TransactionId& txn_id_, TxnReuseVersion txn_version_, SubTransactionId subtxn_id_)
       : versioned_txn(txn_id_, txn_version_), subtxn_id(subtxn_id_) {}
+  ObjectLockOwner(const VersionedTransaction& versioned_txn_, SubTransactionId subtxn_id_)
+      : versioned_txn(versioned_txn_), subtxn_id(subtxn_id_) {}
   ObjectLockOwner(VersionedTransaction&& versioned_txn_, SubTransactionId subtxn_id_)
       : versioned_txn(std::move(versioned_txn_)), subtxn_id(subtxn_id_) {}
 
@@ -66,22 +59,13 @@ struct ObjectLockOwner {
 
   YB_STRUCT_DEFINE_HASH(ObjectLockOwner, versioned_txn, subtxn_id);
 
+  auto operator<=>(const ObjectLockOwner&) const = default;
+
   std::string ToString() const {
     return YB_STRUCT_TO_STRING(versioned_txn, subtxn_id);
   }
 };
 
-inline bool operator==(const ObjectLockOwner& lhs, const ObjectLockOwner& rhs) {
-  return YB_STRUCT_EQUALS(versioned_txn, subtxn_id);
-}
-
-inline bool operator<(const ObjectLockOwner& lhs, const ObjectLockOwner& rhs) {
-  if (lhs.versioned_txn != rhs.versioned_txn) {
-    return lhs.versioned_txn < rhs.versioned_txn;
-  }
-  return lhs.subtxn_id < rhs.subtxn_id;
-}
-
 // ObjectLockPrefix is the entity for which the ts_local_lock_manager acquires locks. In context of
 // object/table locks, when a session requests lock(s) on an object oid corresponding to a database
 // oid, an 'ObjectLockPrefix' in formed which is then passed to the ObjectLockManager.
@@ -96,23 +80,11 @@ struct ObjectLockPrefix {
 
   YB_STRUCT_DEFINE_HASH(ObjectLockPrefix, database_oid, object_oid, lock_type);
 
+  auto operator<=>(const ObjectLockPrefix&) const = default;
+
   uint64_t database_oid;
   uint64_t object_oid;
   dockv::KeyEntryType lock_type;
 };
 
-inline bool operator==(const ObjectLockPrefix& lhs, const ObjectLockPrefix& rhs) {
-  return YB_STRUCT_EQUALS(database_oid, object_oid, lock_type);
-}
-
-inline bool operator<(const ObjectLockPrefix& lhs, const ObjectLockPrefix& rhs) {
-  if (lhs.database_oid != rhs.database_oid) {
-    return lhs.database_oid < rhs.database_oid;
-  }
-  if (lhs.object_oid != rhs.object_oid) {
-    return lhs.object_oid < rhs.object_oid;
-  }
-  return lhs.lock_type < rhs.lock_type;
-}
-
 } // namespace yb::docdb