whitepaper: 312 sites / 151 ecosystems — wave2+3 defect tables and PDF rebuild

Add 88 new defect entries to HIGH and MEDIUM tables:
  HIGH: mysql-0001/0002, mariadb-0001, redis-0001/0002, valkey-0001/0002, openvpn-0001,
        vlc-0001, prometheus-0001, otel-collector-0001, cockroachdb-0001..0004,
        tidb-0001..0008, kubernetes-0001/0002, go-0001, kotlin-0002, scala-0001,
        allegro5-0001, sdl2-0001, grafana-0001, clickhouse-0001, duckdb-0001,
        mongodb-0001, envoy-0001, istio-0001, cilium-0001, linkerd2-0001,
        linux-0001/0002/0003, tor-0002/0003, curl-0001, julia-0001, lua-0001,
        perl5-0001, nats-0001, spring-0003/0004, tomcat-0001, onos-0002, odl-0002

  MEDIUM: helm-0001, mariadb-0002, openssl-0001/0002, memcached-0001,
          cassandra-0001..0004, flink-0001, storm-0001/0002, zookeeper-0001..0003,
          pip-0001, gradle-0001, nginx-0001, haproxy-0001, caddy-0001, varnish-0001,
          ffmpeg-0001, gstreamer-0001, raylib-0001, love2d-0001, php-0001/0002,
          r-source-0001, cpython-0002, ruby-0001, rabbitmq-0003/0004, activemq-0001,
          ovs-0001, onos-0003, odl-0002, jetty-0001

PDF: 976K

defects/storm/unit/StormWorkerStateTaskLookupTest.java

@@ -0,0 +1,108 @@
+package unit;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * storm-0002: WorkerState refreshConnections — ArrayList.contains() O(n²) vs HashSet O(n).
+ *
+ * Standalone unit test — no JUnit required.
+ * Compile: javac -d . StormWorkerStateTaskLookupTest.java
+ * Run:     java unit.StormWorkerStateTaskLookupTest
+ */
+public class StormWorkerStateTaskLookupTest {
+
+    static long slowOps;
+    static long fastOps;
+
+    /**
+     * Slow: mirrors WorkerState.refreshConnections() — localTaskIds is ArrayList.
+     * For each of m tasks in assignment, calls localTaskIds.contains() = O(n).
+     * Total: O(m * n). With m ≈ n (all tasks outbound) → O(n²).
+     */
+    static int slowRefresh(List<Integer> localTaskIds, Set<Integer> outboundTasks,
+                           List<Integer> allTasks) {
+        slowOps = 0;
+        int neededConnections = 0;
+        for (Integer task : allTasks) {
+            slowOps++;
+            if (outboundTasks.contains(task)) {         // Set — O(1)
+                slowOps++;
+                boolean isLocal = false;
+                for (Integer local : localTaskIds) {    // ArrayList.contains() scan — O(n)
+                    slowOps++;
+                    if (local.equals(task)) { isLocal = true; break; }
+                }
+                if (!isLocal) neededConnections++;
+            }
+        }
+        return neededConnections;
+    }
+
+    /**
+     * Fast: patched — localTaskIdSet is HashSet<Integer>.
+     * contains() is O(1); total loop is O(m).
+     */
+    static int fastRefresh(HashSet<Integer> localTaskIdSet, Set<Integer> outboundTasks,
+                           List<Integer> allTasks) {
+        fastOps = 0;
+        int neededConnections = 0;
+        for (Integer task : allTasks) {
+            fastOps++;
+            if (outboundTasks.contains(task)) {         // Set — O(1)
+                fastOps++;
+                if (!localTaskIdSet.contains(task)) {   // HashSet — O(1)
+                    fastOps++;
+                    neededConnections++;
+                }
+            }
+        }
+        return neededConnections;
+    }
+
+    static void run(int n, int expectedNx) {
+        // n local tasks, 2n total tasks in assignment (half remote)
+        List<Integer> localTaskIds = new ArrayList<>();
+        HashSet<Integer> localTaskIdSet = new HashSet<>();
+        for (int i = 0; i < n; i++) {
+            localTaskIds.add(i);
+            localTaskIdSet.add(i);
+        }
+
+        List<Integer> allTasks = new ArrayList<>();
+        Set<Integer> outboundTasks = new HashSet<>();
+        for (int i = 0; i < 2 * n; i++) {
+            allTasks.add(i);
+            outboundTasks.add(i);   // all tasks are outbound
+        }
+
+        int slowResult = slowRefresh(localTaskIds, outboundTasks, allTasks);
+        int fastResult = fastRefresh(localTaskIdSet, outboundTasks, allTasks);
+
+        boolean resultsMatch = (slowResult == fastResult);
+        boolean quadraticWorse = slowOps > fastOps * expectedNx;
+
+        System.out.printf("n=%-4d  slow=%6d  fast=%4d  ratio=%5.1fx  match=%b  PASS=%b%n",
+            n, slowOps, fastOps, (double) slowOps / fastOps, resultsMatch,
+            resultsMatch && quadraticWorse);
+
+        if (!resultsMatch || !quadraticWorse) {
+            throw new AssertionError(
+                "FAIL n=" + n + " slowResult=" + slowResult + " fastResult=" + fastResult +
+                " slowOps=" + slowOps + " fastOps=" + fastOps +
+                " needed ratio>" + expectedNx);
+        }
+    }
+
+    public static void main(String[] args) {
+        System.out.println("=== storm-0002: WorkerState task lookup O(n^2) vs O(n) ===");
+        run(100,  10);
+        run(500,  30);
+        run(1000, 60);
+        System.out.println("3/3 PASS");
+    }
+}