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

defects/camel/unit/RouteStartupAlgorithm.java

@@ -0,0 +1,121 @@
+package unit;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * camel-0001: InternalRouteStartupManager.doStartOrResumeRouteConsumers
+ *
+ * Defect: routeInputs is ArrayList<Endpoint>. Each iteration calls
+ * routeInputs.contains(endpoint) → O(R) inside an O(R) outer loop = O(R²).
+ *
+ * Fix: use LinkedHashSet<Endpoint> for O(1) contains().
+ */
+public class RouteStartupAlgorithm {
+
+    // --- Slow path: ArrayList.contains() in loop ---
+
+    static long slowStartupCheck(int routeCount) {
+        long ops = 0;
+        List<String> routeInputs = new ArrayList<>();
+
+        for (int i = 0; i < routeCount; i++) {
+            String endpoint = "endpoint-" + i;
+
+            // Simulate: if (!doCheckMultipleConsumerSupportClash(endpoint, routeInputs))
+            // doCheckMultipleConsumerSupportClash calls routeInputs.contains(endpoint)
+            ops++;
+            boolean clash = routeInputs.contains(endpoint); // O(i) scan
+            if (clash) {
+                throw new RuntimeException("unexpected clash at " + i);
+            }
+
+            // Simulate existingEndpoints rebuild each iteration
+            List<String> existingEndpoints = new ArrayList<>();
+            for (int j = 0; j < i; j++) {
+                existingEndpoints.add("endpoint-" + j);
+                ops++;
+            }
+            // contains check on existingEndpoints
+            ops++;
+            boolean existingClash = existingEndpoints.contains(endpoint); // O(i) scan
+            if (existingClash) {
+                throw new RuntimeException("unexpected existing clash at " + i);
+            }
+
+            routeInputs.add(endpoint);
+        }
+        return ops;
+    }
+
+    // --- Fast path: LinkedHashSet.contains() in loop ---
+
+    static long fastStartupCheck(int routeCount) {
+        long ops = 0;
+        Set<String> routeInputs = new LinkedHashSet<>();
+        Set<String> existingEndpointsSet = new LinkedHashSet<>();
+
+        for (int i = 0; i < routeCount; i++) {
+            String endpoint = "endpoint-" + i;
+
+            // O(1) contains
+            ops++;
+            boolean clash = routeInputs.contains(endpoint);
+            if (clash) {
+                throw new RuntimeException("unexpected clash at " + i);
+            }
+
+            // No need to rebuild existingEndpoints; maintain incrementally
+            ops++;
+            boolean existingClash = existingEndpointsSet.contains(endpoint);
+            if (existingClash) {
+                throw new RuntimeException("unexpected existing clash at " + i);
+            }
+
+            routeInputs.add(endpoint);
+            existingEndpointsSet.add(endpoint);
+        }
+        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("  %-12s N=%-5d slow=%,7d fast=%,5d ratio=%5.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("camel-0001: RouteStartupAlgorithm");
+        System.out.println("  Defect: ArrayList.contains() in O(R) loop → O(R²)");
+        System.out.println("  Fix:    LinkedHashSet.contains() → O(R)");
+        System.out.println();
+
+        int[] sizes = {100, 300, 500};
+        int passed = 0;
+        int total = sizes.length;
+
+        for (int N : sizes) {
+            long slowOps = slowStartupCheck(N);
+            long fastOps = fastStartupCheck(N);
+            try {
+                runTest("route-startup", N, slowOps, fastOps);
+                passed++;
+            } catch (AssertionError e) {
+                System.out.println("  FAIL: " + e.getMessage());
+            }
+        }
+
+        System.out.println();
+        System.out.println(passed + "/" + total + " PASS");
+        if (passed < total) {
+            System.exit(1);
+        }
+    }
+}