PR comments

Author: anmolanmol1234

hadoop-tools/hadoop-azure/src/main/java/org/apache/hadoop/fs/azurebfs/JvmIdProvider.java

@@ -21,37 +21,50 @@
 import java.util.Random;
 
 /**
- * Provides a JVM-scoped unique identifier.
+ * Provides a JVM-scoped identifier.
  *
  * <p>The identifier is generated once when the class is loaded and remains
- * constant for the lifetime of the JVM. The value is a random 6-digit number
- * in the range {@code [100000, 999999]}.</p>
+ * constant for the lifetime of the JVM. It is derived using a combination of
+ * the current system time and random entropy to reduce the likelihood of
+ * collisions across JVM instances.</p>
+ *
+ * <p>The identifier is intended for lightweight JVM-level identification,
+ * such as tagging metrics or log entries. It provides best-effort uniqueness
+ * and is not guaranteed to be globally unique.</p>
  *
  * <p>This class is utility-only and cannot be instantiated.</p>
  */
 public final class JvmIdProvider {
 
-  /**
-   * A JVM-wide unique identifier generated at class load time.
-   */
-  private static final long JVM_UNIQUE_ID;
+  /** Lower bound (inclusive) for the generated JVM identifier. */
+  private static final int MIN_JVM_ID = 100_000;
+
+  /** Size of the identifier value range. */
+  private static final int JVM_ID_RANGE = 900_000;
+
+  /** Upper bound for random entropy mixed into the identifier. */
+  private static final int RANDOM_ENTROPY_BOUND = 1_000;
+
+  /** JVM-scoped identifier generated at class initialization time. */
+  private static final int JVM_UNIQUE_ID;
 
   static {
-    JVM_UNIQUE_ID = 100000L + new Random().nextInt(900000);
+    long time = System.currentTimeMillis();
+    int random = new Random().nextInt(RANDOM_ENTROPY_BOUND);
+    JVM_UNIQUE_ID = (int) ((time + random) % JVM_ID_RANGE) + MIN_JVM_ID;
   }
 
-  /**
-   * Prevents instantiation.
-   */
+  /** Prevents instantiation. */
   private JvmIdProvider() {
   }
 
   /**
-   * Returns the JVM-scoped unique identifier.
+   * Returns the JVM-scoped identifier.
    *
-   * @return the unique ID for this JVM instance
+   * @return an identifier that remains constant for the lifetime of the JVM
    */
-  public static long getJvmId() {
+  public static int getJvmId() {
     return JVM_UNIQUE_ID;
   }
 }
+

hadoop-tools/hadoop-azure/src/main/java/org/apache/hadoop/fs/azurebfs/services/AbstractAbfsResourceUtilizationMetrics.java

@@ -19,8 +19,6 @@
 package org.apache.hadoop.fs.azurebfs.services;
 
 import java.util.Arrays;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicLong;
 import java.util.stream.Stream;
 
 import org.slf4j.Logger;

hadoop-tools/hadoop-azure/src/main/java/org/apache/hadoop/fs/azurebfs/services/ReadBufferManagerV2.java

@@ -52,7 +52,6 @@
 import static org.apache.hadoop.fs.azurebfs.constants.FileSystemConfigurations.SCALE_DIRECTION_NO_UP_AT_MAX;
 import static org.apache.hadoop.fs.azurebfs.constants.FileSystemConfigurations.SCALE_DIRECTION_UP;
 import static org.apache.hadoop.fs.azurebfs.constants.FileSystemConfigurations.ZERO;
-import static org.apache.hadoop.fs.azurebfs.constants.FileSystemConfigurations.ZERO_D;
 
 /**
  * The Improved Read Buffer Manager for Rest AbfsClient.

hadoop-tools/hadoop-azure/src/test/java/org/apache/hadoop/fs/azurebfs/TestWriteThreadPoolSizeManager.java

@@ -26,9 +26,13 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Random;
+import java.util.concurrent.Callable;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
 import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.ScheduledThreadPoolExecutor;
 import java.util.concurrent.ThreadPoolExecutor;
@@ -178,7 +182,7 @@ void testAdjustThreadPoolSizeBasedOnLowCPU()
     try (AzureBlobFileSystem abfs = (AzureBlobFileSystem) fileSystem) {
       WriteThreadPoolSizeManager instance
           = WriteThreadPoolSizeManager.getInstance(abfs.getFileSystemId(),
-          getAbfsStore(abfs).getAbfsConfiguration(),
+         mockConfig,
           abfs.getAbfsClient().getAbfsCounters());
       ExecutorService executor = instance.getExecutorService();
       int initialSize = ((ThreadPoolExecutor) executor).getMaximumPoolSize();
@@ -833,8 +837,11 @@ void testThreadPoolOnLowCpuLoadAndMetricsUpdate()
               .getAbfsWriteResourceUtilizationMetrics();
 
       WriteThreadPoolSizeManager.WriteThreadPoolStats statsBefore =
-          instance.getCurrentStats(ResourceUtilizationUtils.getJvmCpuLoad(), ResourceUtilizationUtils.getMemoryLoad(), ResourceUtilizationUtils.getUsedHeapMemory(),
-              ResourceUtilizationUtils.getAvailableHeapMemory(), ResourceUtilizationUtils.getCommittedHeapMemory());
+          instance.getCurrentStats(ResourceUtilizationUtils.getJvmCpuLoad(),
+              ResourceUtilizationUtils.getMemoryLoad(),
+              ResourceUtilizationUtils.getUsedHeapMemory(),
+              ResourceUtilizationUtils.getAvailableHeapMemory(),
+              ResourceUtilizationUtils.getCommittedHeapMemory());
 
       ThreadPoolExecutor executor =
           (ThreadPoolExecutor) instance.getExecutorService();
@@ -869,8 +876,11 @@ void testThreadPoolOnLowCpuLoadAndMetricsUpdate()
       Thread.sleep(SLEEP_DURATION_30S_MS);
 
       WriteThreadPoolSizeManager.WriteThreadPoolStats statsAfter =
-          instance.getCurrentStats(ResourceUtilizationUtils.getJvmCpuLoad(), ResourceUtilizationUtils.getMemoryLoad(), ResourceUtilizationUtils.getUsedHeapMemory(),
-          ResourceUtilizationUtils.getAvailableHeapMemory(), ResourceUtilizationUtils.getCommittedHeapMemory());
+          instance.getCurrentStats(ResourceUtilizationUtils.getJvmCpuLoad(),
+              ResourceUtilizationUtils.getMemoryLoad(),
+              ResourceUtilizationUtils.getUsedHeapMemory(),
+              ResourceUtilizationUtils.getAvailableHeapMemory(),
+              ResourceUtilizationUtils.getCommittedHeapMemory());
 
       //--- Validate that metrics and stats changed ---
       Assertions.assertThat(statsAfter)
@@ -900,5 +910,54 @@ void testThreadPoolOnLowCpuLoadAndMetricsUpdate()
       instance.close();
     }
   }
+
+  /**
+   * Verifies that the JVM identifier is initialized once and remains
+   * constant across multiple invocations within the same JVM process.
+   */
+  @Test
+  public void testJvmIdIsSingletonWithinJvm() {
+    int firstId = JvmIdProvider.getJvmId();
+    int secondId = JvmIdProvider.getJvmId();
+    int thirdId = JvmIdProvider.getJvmId();
+
+    assertEquals(firstId, secondId,
+        "Subsequent calls to getJvmId() should return the same value");
+    assertEquals(secondId, thirdId,
+        "JVM-scoped identifier must remain constant for the lifetime of the JVM");
+  }
+
+  /**
+   * Verifies that the JVM identifier is safely shared across multiple threads
+   * and that concurrent access returns the same value.
+   *
+   * <p>This test ensures that static initialization of the identifier is
+   * thread-safe and occurs only once per JVM.</p>
+   */
+  @Test
+  public void testJvmIdIsSameAcrossThreads()
+      throws ExecutionException, InterruptedException {
+
+    ExecutorService executor = Executors.newFixedThreadPool(4);
+
+    try {
+      Callable<Integer> task = JvmIdProvider::getJvmId;
+      Future<Integer> f1 = executor.submit(task);
+      Future<Integer> f2 = executor.submit(task);
+      Future<Integer> f3 = executor.submit(task);
+      Future<Integer> f4 = executor.submit(task);
+
+      int expectedId = f1.get();
+      assertEquals(expectedId, f2.get(),
+          "JVM ID should be identical when accessed from different threads");
+      assertEquals(expectedId, f3.get(),
+          "JVM ID should be identical when accessed concurrently");
+      assertEquals(expectedId, f4.get(),
+          "JVM ID should be initialized once and shared across all threads");
+    } finally {
+      executor.shutdown();
+      executor.awaitTermination(5, TimeUnit.SECONDS);
+    }
+  }
 }