whitepaper: 352/169 — wave4 MEDIUM (hadoop/hbase/nova/neutron/openstack) + fix odl-0002 dup

2026-03-27 15:33:17 -04:00 · 2026-03-27 15:33:17 -04:00 · 835ae73b0f
commit 835ae73b0f
parent 9934133dcf
82 changed files with 5931 additions and 6 deletions
--- a/defects/hbase/unit/HBaseStoreFileManagerTest.java
+++ b/defects/hbase/unit/HBaseStoreFileManagerTest.java
@ -0,0 +1,104 @@
+package unit;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * hbase-0001: DefaultStoreFileManager.getUnneededFiles() — ArrayList.contains() O(C)
+ * called inside a filter over all store files. Total: O(F * C).
+ *
+ * Root cause: HStore.filesCompacting = Lists.newArrayList() (ArrayList).
+ * Fix: build a local HashSet<HStoreFile> at start of getUnneededFiles() for O(1) lookup.
+ *
+ * Standalone unit test — no JUnit required.
+ * Compile: javac -d . HBaseStoreFileManagerTest.java
+ * Run:     java -ea unit.HBaseStoreFileManagerTest
+ */
+public class HBaseStoreFileManagerTest {
+
+    static long slowOps;
+    static long fastOps;
+
+    /**
+     * Simulates getUnneededFiles() with ArrayList filesCompacting.
+     * For each of F store files, ArrayList.contains() scans C compacting files.
+     */
+    static int slowGetUnneededFiles(int numStoreFiles, List<Integer> filesCompacting, long maxTs) {
+        slowOps = 0;
+        int unneededCount = 0;
+        // storeFiles.all — F files, first (F-1) are candidates (skip the last)
+        for (int i = 0; i < numStoreFiles - 1; i++) {
+            slowOps++;  // stream entry
+            int fileId = i;
+            long fileTs = (long) fileId;  // fileTs = id, so fileTs < maxTs when id < maxTs
+            if (fileTs < maxTs) {
+                for (Integer compacting : filesCompacting) {  // ArrayList.contains() scan
+                    slowOps++;
+                    if (compacting.equals(fileId)) break;
+                }
+                if (!filesCompacting.contains(fileId)) {
+                    unneededCount++;
+                }
+            }
+        }
+        return unneededCount;
+    }
+
+    /**
+     * Patched: build HashSet once at method entry — O(C) one time, then O(1) per lookup.
+     */
+    static int fastGetUnneededFiles(int numStoreFiles, List<Integer> filesCompacting, long maxTs) {
+        fastOps = 0;
+        Set<Integer> compactingSet = new HashSet<>(filesCompacting);  // O(C) once
+        fastOps += filesCompacting.size();
+        int unneededCount = 0;
+        for (int i = 0; i < numStoreFiles - 1; i++) {
+            fastOps++;  // stream entry
+            int fileId = i;
+            long fileTs = (long) fileId;
+            if (fileTs < maxTs) {
+                fastOps++;  // O(1) HashSet.contains()
+                if (!compactingSet.contains(fileId)) {
+                    unneededCount++;
+                }
+            }
+        }
+        return unneededCount;
+    }
+
+    static void run(int F, int C, long maxTs, int expectedRatio) {
+        // Build filesCompacting: C files evenly distributed across F
+        List<Integer> filesCompacting = new ArrayList<>();
+        for (int i = 0; i < C; i++) {
+            filesCompacting.add(i * (F / Math.max(C, 1)));
+        }
+
+        int slowResult = slowGetUnneededFiles(F, filesCompacting, maxTs);
+        int fastResult = fastGetUnneededFiles(F, filesCompacting, maxTs);
+
+        boolean resultsMatch = (slowResult == fastResult);
+        boolean quadraticWorse = slowOps > fastOps * expectedRatio;
+        boolean pass = resultsMatch && quadraticWorse;
+
+        System.out.printf("F=%-4d C=%-4d maxTs=%-6d  slow=%8d  fast=%5d  ratio=%6.1fx  match=%b  PASS=%b%n",
+            F, C, maxTs, slowOps, fastOps, (double) slowOps / fastOps, resultsMatch, pass);
+
+        if (!pass) {
+            throw new AssertionError(
+                "FAIL F=" + F + " C=" + C +
+                " resultsMatch=" + resultsMatch +
+                " slowOps=" + slowOps + " fastOps=" + fastOps +
+                " needed ratio>" + expectedRatio);
+        }
+    }
+
+    public static void main(String[] args) {
+        System.out.println("=== hbase-0001: DefaultStoreFileManager.getUnneededFiles() O(F*C) vs O(F+C) ===");
+        run(100,  10,  80,  3);
+        run(500,  50,  400, 20);
+        run(1000, 100, 900, 40);
+        System.out.println("3/3 PASS");
+    }
+}