russell@unturf.com
9934133dcf
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
115 lines
3.6 KiB
Java
115 lines
3.6 KiB
Java
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);
|
|
}
|
|
}
|
|
}
|