wave12: 501/237 — ClickHouse/Druid/Pinot + Ansible/OpenTofu/Pulumi + Celery/Camel + VictoriaMetrics/Ceph

defects/celery/unit/ResultSetAlgorithm.java

@@ -0,0 +1,150 @@
+package unit;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * celery-0001: ResultSet.update() / ResultSet.add()
+ *
+ * Defect: self.results is a plain list. The expression
+ *   'r not in self.results'  (Python)
+ * becomes an O(N) scan on each of M elements in update() → O(M*N) total.
+ *
+ * Fix: maintain a parallel dict keyed by result ID for O(1) membership.
+ *
+ * Op counting: each comparison during the list scan counts as one op.
+ * For hash lookup we count 1 op per lookup.
+ */
+public class ResultSetAlgorithm {
+
+    // --- Slow path: simulate list.contains() with explicit scan counting ---
+
+    static long slowUpdate(int existingCount, int newCount) {
+        long ops = 0;
+        List<String> results = new ArrayList<>();
+
+        for (int i = 0; i < existingCount; i++) {
+            results.add("result-" + i);
+        }
+
+        // simulate: self.results.extend(r for r in results if r not in self.results)
+        for (int i = existingCount; i < existingCount + newCount; i++) {
+            String r = "result-" + i;
+            // Scan the list: worst case is a full pass (item not found)
+            for (String existing : results) {
+                ops++; // each comparison costs 1 op
+                if (existing.equals(r)) break;
+            }
+            // Item not in list, add it
+            results.add(r);
+        }
+        return ops;
+    }
+
+    // --- Fast path: LinkedHashMap (id→result) simulation ---
+
+    static long fastUpdate(int existingCount, int newCount) {
+        long ops = 0;
+        Map<String, String> resultMap = new LinkedHashMap<>();
+
+        for (int i = 0; i < existingCount; i++) {
+            String r = "result-" + i;
+            resultMap.put(r, r);
+        }
+
+        for (int i = existingCount; i < existingCount + newCount; i++) {
+            String r = "result-" + i;
+            ops++; // O(1) hash lookup counted as 1 op
+            if (!resultMap.containsKey(r)) {
+                resultMap.put(r, r);
+            }
+        }
+        return ops;
+    }
+
+    // --- Slow path: add() pattern ---
+    // Simulates: if result not in self.results: self.results.append(result)
+    // Called N times for sequential task completions in a chord group.
+
+    static long slowAdd(int N) {
+        long ops = 0;
+        List<String> results = new ArrayList<>();
+
+        for (int i = 0; i < N; i++) {
+            String r = "result-" + i;
+            // Scan entire list for membership check
+            for (String existing : results) {
+                ops++;
+                if (existing.equals(r)) break;
+            }
+            // Not found → append (all N items are unique, so full scan each time)
+            results.add(r);
+        }
+        return ops;
+    }
+
+    // --- Fast path: add() pattern ---
+
+    static long fastAdd(int N) {
+        long ops = 0;
+        Map<String, String> resultMap = new LinkedHashMap<>();
+
+        for (int i = 0; i < N; i++) {
+            String r = "result-" + i;
+            ops++; // O(1) lookup
+            resultMap.putIfAbsent(r, r);
+        }
+        return ops;
+    }
+
+    static void runTest(String label, int N, long slowOps, long fastOps) {
+        double ratio = (double) slowOps / fastOps;
+        boolean pass = ratio >= 10.0;
+        System.out.printf("  %-14s N=%-5d slow=%,8d fast=%,5d ratio=%6.1fx  %s%n",
+                label, N, slowOps, fastOps, ratio, pass ? "PASS" : "FAIL");
+        if (!pass) {
+            throw new AssertionError("Ratio " + ratio + " < 10x threshold at N=" + N);
+        }
+    }
+
+    public static void main(String[] args) {
+        System.out.println("celery-0001: ResultSetAlgorithm");
+        System.out.println("  Defect: list.contains() per element in update()/add() → O(N²)");
+        System.out.println("  Fix:    dict/map key lookup → O(N)");
+        System.out.println();
+
+        int[] sizes = {200, 500, 1000};
+        int passed = 0;
+        int total = sizes.length * 2;
+
+        for (int N : sizes) {
+            // Test update(): merge N new results into N existing
+            long slowU = slowUpdate(N, N);
+            long fastU = fastUpdate(N, N);
+            try {
+                runTest("update", N, slowU, fastU);
+                passed++;
+            } catch (AssertionError e) {
+                System.out.println("  FAIL update: " + e.getMessage());
+            }
+
+            // Test add(): add N items one at a time (each unique)
+            long slowA = slowAdd(N);
+            long fastA = fastAdd(N);
+            try {
+                runTest("add", N, slowA, fastA);
+                passed++;
+            } catch (AssertionError e) {
+                System.out.println("  FAIL add: " + e.getMessage());
+            }
+        }
+
+        System.out.println();
+        System.out.println(passed + "/" + total + " PASS");
+        if (passed < total) {
+            System.exit(1);
+        }
+    }
+}