HDDS-13031. Implement a Flat Lock resource in OzoneManagerLock

hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/om/lock/IOzoneManagerLock.java

@@ -25,46 +25,128 @@
  */
 public interface IOzoneManagerLock {
 
-  OMLockDetails acquireReadLock(OzoneManagerLock.LeveledResource resource,
+  OMLockDetails acquireReadLock(Resource resource,
                                 String... resources);
 
-  OMLockDetails acquireReadLocks(OzoneManagerLock.LeveledResource resource, Collection<String[]> resources);
+  OMLockDetails acquireReadLocks(Resource resource, Collection<String[]> resources);
 
-  OMLockDetails acquireWriteLock(OzoneManagerLock.LeveledResource resource,
+  OMLockDetails acquireWriteLock(Resource resource,
                                  String... resources);
 
-  OMLockDetails acquireWriteLocks(OzoneManagerLock.LeveledResource resource,
+  OMLockDetails acquireWriteLocks(Resource resource,
                                  Collection<String[]> resources);
 
   boolean acquireMultiUserLock(String firstUser, String secondUser);
 
   void releaseMultiUserLock(String firstUser, String secondUser);
 
-  OMLockDetails releaseWriteLock(OzoneManagerLock.LeveledResource resource,
+  OMLockDetails releaseWriteLock(Resource resource,
                         String... resources);
 
-  OMLockDetails releaseWriteLocks(OzoneManagerLock.LeveledResource resource,
+  OMLockDetails releaseWriteLocks(Resource resource,
                                  Collection<String[]> resources);
 
-  OMLockDetails releaseReadLock(OzoneManagerLock.LeveledResource resource,
+  OMLockDetails releaseReadLock(Resource resource,
                                 String... resources);
 
-  OMLockDetails releaseReadLocks(OzoneManagerLock.LeveledResource resource,
+  OMLockDetails releaseReadLocks(Resource resource,
                                 Collection<String[]> resources);
 
   @VisibleForTesting
-  int getReadHoldCount(OzoneManagerLock.LeveledResource resource,
+  int getReadHoldCount(Resource resource,
       String... resources);
 
   @VisibleForTesting
-  int getWriteHoldCount(OzoneManagerLock.LeveledResource resource,
+  int getWriteHoldCount(Resource resource,
       String... resources);
 
   @VisibleForTesting
-  boolean isWriteLockedByCurrentThread(OzoneManagerLock.LeveledResource resource,
+  boolean isWriteLockedByCurrentThread(Resource resource,
       String... resources);
 
   void cleanup();
 
   OMLockMetrics getOMLockMetrics();
+
+  /**
+   * Defines a resource interface used to represent entities that can be
+   * associated with locks in the Ozone Manager Lock mechanism. A resource
+   * implementation provides a name and an associated {@link ResourceManager}
+   * to manage its locking behavior.
+   */
+  interface Resource {
+
+    String getName();
+
+    ResourceManager getResourceManager();
+  }
+
+  /**
+   * The ResourceManager class provides functionality for managing
+   * information about resource read and write lock usage. It tracks the time of
+   * read and write locks acquired and held by individual threads, enabling
+   * more granular lock usage metrics.
+   */
+  class ResourceManager {
+    // This helps in maintaining read lock related variables locally confined
+    // to a given thread.
+    private final ThreadLocal<LockUsageInfo> readLockTimeStampNanos =
+        ThreadLocal.withInitial(LockUsageInfo::new);
+
+    // This helps in maintaining write lock related variables locally confined
+    // to a given thread.
+    private final ThreadLocal<LockUsageInfo> writeLockTimeStampNanos =
+        ThreadLocal.withInitial(LockUsageInfo::new);
+
+    ResourceManager() {
+    }
+
+    /**
+     * Sets the time (ns) when the read lock holding period begins specific to a
+     * thread.
+     *
+     * @param startReadHeldTimeNanos read lock held start time (ns)
+     */
+    void setStartReadHeldTimeNanos(long startReadHeldTimeNanos) {
+      readLockTimeStampNanos.get()
+          .setStartReadHeldTimeNanos(startReadHeldTimeNanos);
+    }
+
+    /**
+     * Sets the time (ns) when the write lock holding period begins specific to
+     * a thread.
+     *
+     * @param startWriteHeldTimeNanos write lock held start time (ns)
+     */
+    void setStartWriteHeldTimeNanos(long startWriteHeldTimeNanos) {
+      writeLockTimeStampNanos.get()
+          .setStartWriteHeldTimeNanos(startWriteHeldTimeNanos);
+    }
+
+    /**
+     * Returns the time (ns) when the read lock holding period began specific to
+     * a thread.
+     *
+     * @return read lock held start time (ns)
+     */
+    long getStartReadHeldTimeNanos() {
+      long startReadHeldTimeNanos =
+          readLockTimeStampNanos.get().getStartReadHeldTimeNanos();
+      readLockTimeStampNanos.remove();
+      return startReadHeldTimeNanos;
+    }
+
+    /**
+     * Returns the time (ns) when the write lock holding period began specific
+     * to a thread.
+     *
+     * @return write lock held start time (ns)
+     */
+    long getStartWriteHeldTimeNanos() {
+      long startWriteHeldTimeNanos =
+          writeLockTimeStampNanos.get().getStartWriteHeldTimeNanos();
+      writeLockTimeStampNanos.remove();
+      return startWriteHeldTimeNanos;
+    }
+  }
 }

hadoop-ozone/common/src/main/java/org/apache/hadoop/ozone/om/lock/OmReadOnlyLock.java

@@ -21,7 +21,6 @@
 import static org.apache.hadoop.ozone.om.lock.OMLockDetails.EMPTY_DETAILS_LOCK_NOT_ACQUIRED;
 
 import java.util.Collection;
-import org.apache.hadoop.ozone.om.lock.OzoneManagerLock.LeveledResource;
 
 /**
  * Read only "lock" for snapshots
@@ -31,23 +30,23 @@
 public class OmReadOnlyLock implements IOzoneManagerLock {
 
   @Override
-  public OMLockDetails acquireReadLock(LeveledResource resource, String... resources) {
+  public OMLockDetails acquireReadLock(Resource resource, String... resources) {
     return EMPTY_DETAILS_LOCK_ACQUIRED;
   }
 
   @Override
-  public OMLockDetails acquireReadLocks(LeveledResource resource, Collection<String[]> resources) {
+  public OMLockDetails acquireReadLocks(Resource resource, Collection<String[]> resources) {
     return EMPTY_DETAILS_LOCK_ACQUIRED;
   }
 
   @Override
-  public OMLockDetails acquireWriteLock(LeveledResource resource,
+  public OMLockDetails acquireWriteLock(Resource resource,
       String... resources) {
     return EMPTY_DETAILS_LOCK_NOT_ACQUIRED;
   }
 
   @Override
-  public OMLockDetails acquireWriteLocks(LeveledResource resource, Collection<String[]> resources) {
+  public OMLockDetails acquireWriteLocks(Resource resource, Collection<String[]> resources) {
     return EMPTY_DETAILS_LOCK_NOT_ACQUIRED;
   }
 
@@ -62,38 +61,38 @@ public void releaseMultiUserLock(String firstUser, String secondUser) {
   }
 
   @Override
-  public OMLockDetails releaseWriteLock(LeveledResource resource,
+  public OMLockDetails releaseWriteLock(Resource resource,
       String... resources) {
     return EMPTY_DETAILS_LOCK_NOT_ACQUIRED;
   }
 
   @Override
-  public OMLockDetails releaseWriteLocks(LeveledResource resource, Collection<String[]> resources) {
+  public OMLockDetails releaseWriteLocks(Resource resource, Collection<String[]> resources) {
     return EMPTY_DETAILS_LOCK_NOT_ACQUIRED;
   }
 
   @Override
-  public OMLockDetails releaseReadLock(LeveledResource resource, String... resources) {
+  public OMLockDetails releaseReadLock(Resource resource, String... resources) {
     return EMPTY_DETAILS_LOCK_NOT_ACQUIRED;
   }
 
   @Override
-  public OMLockDetails releaseReadLocks(LeveledResource resource, Collection<String[]> resources) {
+  public OMLockDetails releaseReadLocks(Resource resource, Collection<String[]> resources) {
     return EMPTY_DETAILS_LOCK_NOT_ACQUIRED;
   }
 
   @Override
-  public int getReadHoldCount(LeveledResource resource, String... resources) {
+  public int getReadHoldCount(Resource resource, String... resources) {
     return 0;
   }
 
   @Override
-  public int getWriteHoldCount(LeveledResource resource, String... resources) {
+  public int getWriteHoldCount(Resource resource, String... resources) {
     return 0;
   }
 
   @Override
-  public boolean isWriteLockedByCurrentThread(LeveledResource resource,
+  public boolean isWriteLockedByCurrentThread(Resource resource,
       String... resources) {
     return false;
   }