engineering/java-topology
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

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

Browse source 
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
This commit is contained in:
russell@unturf.com 2026-03-27 15:23:43 -04:00
parent b3842ab6b8
commit 9934133dcf
260 changed files with 18278 additions and 15 deletions
Download patch file Download diff file Expand all files Collapse all files

115
defects/caddy/unit/CaddyHostByHashingAlgorithmTest.java Normal file
View file

@ -0,0 +1,115 @@
package unit;
import java.util.HashMap;
import java.util.Map;
/**
* caddy-0001: hostByHashing O(N) xxhash-per-upstream vs O(1) cached-hash fix.
*
* slow() models the defect: hash(up.String() + s) called once per upstream per request.
* fast() models the fix: upstream hash pre-cached; combine with hash(s) in O(1).
*
* Assert: slowOps > fastOps * 5 for N=50 upstreams.
*/
public class CaddyHostByHashingAlgorithmTest {
static long slowOps;
static long fastOps;
// ---- simulated upstream ------------------------------------------------
static class Upstream {
final String addr;
long cachedHash; // populated at provision time in the fix
boolean available;
Upstream(String addr, long cachedHash) {
this.addr = addr;
this.cachedHash = cachedHash;
this.available = true;
}
}
// ---- cheap hash substitute (counts as 1 op) ----------------------------
static long cheapHash(String s) {
long h = 0xcbf29ce484222325L;
for (char c : s.toCharArray()) {
h ^= c;
h *= 0x100000001b3L;
}
return h;
}
// ---- slow: O(N) hash-per-upstream (defect) -----------------------------
static Upstream slowHostByHashing(Upstream[] pool, String s) {
long highest = 0;
Upstream best = null;
for (Upstream up : pool) {
if (!up.available) continue;
slowOps++; // one hash call per upstream
long h = cheapHash(up.addr + s);
if (h > highest) { highest = h; best = up; }
}
return best;
}
// ---- fast: O(1) hash-of-s + XOR with cached hash (fix) ----------------
static Upstream fastHostByHashing(Upstream[] pool, String s) {
fastOps++; // one hash call total
long sHash = cheapHash(s);
long highest = 0;
Upstream best = null;
for (Upstream up : pool) {
if (!up.available) continue;
long h = up.cachedHash ^ sHash; // XOR: O(1) per upstream, no hash call
if (h > highest) { highest = h; best = up; }
}
return best;
}
// ---- benchmark driver --------------------------------------------------
public static void main(String[] args) {
final int N = 50;
final int REQUESTS = 10_000;
Upstream[] pool = new Upstream[N];
for (int i = 0; i < N; i++) {
String addr = "10.0." + (i / 256) + "." + (i % 256) + ":8080";
pool[i] = new Upstream(addr, cheapHash(addr));
}
String[] requestKeys = new String[REQUESTS];
for (int r = 0; r < REQUESTS; r++) {
requestKeys[r] = "/path/resource/" + r;
}
slowOps = 0;
fastOps = 0;
for (int r = 0; r < REQUESTS; r++) {
Upstream s = slowHostByHashing(pool, requestKeys[r]);
if (s == null) throw new AssertionError("slow: no upstream selected");
}
for (int r = 0; r < REQUESTS; r++) {
Upstream f = fastHostByHashing(pool, requestKeys[r]);
if (f == null) throw new AssertionError("fast: no upstream selected");
}
long ratio = slowOps / Math.max(fastOps, 1);
boolean pass = slowOps > fastOps * (N / 2);
System.out.printf("caddy-0001 slow=%d fast=%d ratio=%dx %s%n",
slowOps, fastOps, ratio, pass ? "PASS" : "FAIL");
if (!pass) {
System.err.printf("FAIL: expected slowOps(%d) > fastOps(%d) * %d%n",
slowOps, fastOps, N / 2);
System.exit(1);
}
}
}