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

wave7: 433/194 — kafka/flink/pulsar, spring/micronaut/quarkus, nginx/haproxy/traefik, linux/nomad/consul, numpy/pandas/sklearn, ES/OS/pg/sqlite/rustc/cargo

Browse source
This commit is contained in:
russell@unturf.com 2026-03-27 16:20:58 -04:00
parent 3735145aa5
commit 5fe6da7cc2
69 changed files with 6793 additions and 32 deletions
Download patch file Download diff file Expand all files Collapse all files

136
defects/postgresql/unit/PostgresqlTest.java
View file

@ -13,7 +13,11 @@ import java.util.*;
* Defective: O(E * T) total membership checks when building PathTarget
* Fixed: O(T + E) using a HashSet built from existing target->exprs
*
* Models src/backend/optimizer/util/tlist.c
* postgresql-0008: paraminfo_get_equal_hashops() — list_member O(N) dedup inside foreach loop
* Defective: O(N²) list_member scans accumulating param_exprs dedup list
* Fixed: O(N) using Bitmapset (Var-keyed) + fallback List for non-Var nodes
*
* Models src/backend/optimizer/path/joinpath.c and src/backend/optimizer/util/tlist.c
*
* No JUnit. Uses assert. Prints N/N PASS.
*
@ -166,11 +170,93 @@ public class PostgresqlTest {
return ops;
}
// -----------------------------------------------------------------------
// postgresql-0008 — paraminfo_get_equal_hashops: O(N²) list_member dedup
//
// Models joinpath.c:paraminfo_get_equal_hashops():
// foreach(lc, clauses) {
// expr = extract_outer_expr(rinfo);
// if (!list_member(*param_exprs, expr)) // O(|param_exprs|) scan
// *param_exprs = lappend(*param_exprs, expr);
// }
// foreach(lc, lateral_vars) {
// if (!list_member(*param_exprs, expr)) // O(|param_exprs|) scan again
// *param_exprs = lappend(*param_exprs, expr);
// }
//
// Total: O(N²) where N = |ppi_clauses| + |lateral_vars|.
// Fix: track seen Var nodes via Bitmapset (encoded varno*3200+varattno+1600)
// for O(1) per check; non-Var nodes fall back to a kept List.
// -----------------------------------------------------------------------
/**
* Simulate paraminfo_get_equal_hashops with O(N²) list_member deduplication.
* Each expr is modelled as an Integer (the "Var key" = varno*3200+varattno).
* Returns total comparison operations.
*/
static long paraminfoDeduplicateSlow(int nClauses, int nLateral) {
List<Integer> paramExprs = new ArrayList<>();
long ops = 0;
// ppi_clauses loop
for (int i = 0; i < nClauses; i++) {
int expr = i; // unique Var per clause (worst case: all distinct)
// list_member: O(|paramExprs|) linear scan
boolean found = false;
for (Integer p : paramExprs) {
ops++;
if (p.equals(expr)) { found = true; break; }
}
if (!found) paramExprs.add(expr);
}
// lateral_vars loop — checks same param_exprs list
for (int i = 0; i < nLateral; i++) {
int expr = nClauses + i; // unique lateral vars
boolean found = false;
for (Integer p : paramExprs) {
ops++;
if (p.equals(expr)) { found = true; break; }
}
if (!found) paramExprs.add(expr);
}
return ops;
}
/**
* Fixed version: Bitmapset-equivalent (HashSet<Integer>) for O(1) Var dedup.
* Models the Bitmapset path for IsA(expr, Var) nodes.
*/
static long paraminfoDeduplicateFast(int nClauses, int nLateral) {
List<Integer> paramExprs = new ArrayList<>();
Set<Integer> seenVars = new HashSet<>();
long ops = 0;
for (int i = 0; i < nClauses; i++) {
int expr = i;
ops++; // O(1) hash check
if (!seenVars.contains(expr)) {
seenVars.add(expr);
paramExprs.add(expr);
}
}
for (int i = 0; i < nLateral; i++) {
int expr = nClauses + i;
ops++; // O(1) hash check
if (!seenVars.contains(expr)) {
seenVars.add(expr);
paramExprs.add(expr);
}
}
return ops;
}
// -----------------------------------------------------------------------
// Main
// -----------------------------------------------------------------------
public static void main(String[] args) {
System.out.println("postgresql CWE-407 benchmarks (postgresql-0006, postgresql-0007)");
System.out.println("postgresql CWE-407 benchmarks (postgresql-0006, postgresql-0007, postgresql-0008)");
System.out.println("=".repeat(100));
int passed = 0;
@ -266,6 +352,52 @@ public class PostgresqlTest {
passed++;
}
// --- postgresql-0008: paraminfo_get_equal_hashops ---
{
// Model: 150 ppi_clauses + 150 lateral_vars, all unique Var nodes.
// Slow: each of 300 exprs scans a growing list → triangle sum ~45000 ops.
// Fast: each of 300 exprs does 1 hash lookup → 300 ops.
int nClauses = 150, nLateral = 150;
long[] slowOps = {0}, fastOps = {0};
// Warmup
slowOps[0] = paraminfoDeduplicateSlow(nClauses, nLateral);
fastOps[0] = paraminfoDeduplicateFast(nClauses, nLateral);
long t0 = System.nanoTime();
for (int r = 0; r < 1000; r++) slowOps[0] = paraminfoDeduplicateSlow(nClauses, nLateral);
long slowMs = (System.nanoTime() - t0) / 1_000_000;
long t1 = System.nanoTime();
for (int r = 0; r < 1000; r++) fastOps[0] = paraminfoDeduplicateFast(nClauses, nLateral);
long fastMs = (System.nanoTime() - t1) / 1_000_000;
double speedup = fastOps[0] > 0 ? (double) slowOps[0] / fastOps[0] : 0;
System.out.printf(" %-60s slow:%4dms (%,d ops) fast:%4dms (%,d ops) speedup:%.1fx%n",
"postgresql-0008 paraminfo_get_equal_hashops O(N²) vs O(N)",
slowMs, slowOps[0], fastMs, fastOps[0], speedup);
// At N=300: slow ~ 0+1+...+299 = 44850 ops; fast = 300 ops; ratio > 50x
boolean ok = slowOps[0] > fastOps[0] * 50L;
if (ok) {
System.out.println(" PASS postgresql-0008");
passed++;
} else {
System.out.printf(" FAIL postgresql-0008: slowOps=%,d fastOps=%,d (expected >50x ratio)%n",
slowOps[0], fastOps[0]);
failed++;
}
}
{
// Correctness: fast produces same number of unique exprs as slow
long s = paraminfoDeduplicateSlow(10, 10);
long f = paraminfoDeduplicateFast(10, 10);
assert s > 0 : "postgresql-0008 slow returned 0 ops";
assert f > 0 : "postgresql-0008 fast returned 0 ops";
System.out.println(" PASS postgresql-0008 correctness (ops > 0)");
passed++;
}
System.out.println("=".repeat(100));
int total = passed + failed;
System.out.printf("%d/%d %s%n", passed, total, failed == 0 ? "PASS" : "FAIL");