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

wave17: openssh-0001/2, strongswan-0001, gradle-0002, groovy-0001/2, make-0001, clojure-CLEAN + whitepaper 549/240

Browse source
This commit is contained in:
russell@unturf.com 2026-03-27 19:55:52 -04:00
parent 0f275c44af
commit 4221966e66
22 changed files with 1776 additions and 4 deletions
Download patch file Download diff file Expand all files Collapse all files

85
defects/make/patch/make-0001-implicit-dep-hashset.md Normal file
View file

@ -0,0 +1,85 @@
# make-0001: implicit.c pattern_search file->deps O(R×D×F) → O(R×D+F)
## Defect
- **File**: `src/implicit.c`
- **Function**: `pattern_search`
- **Lines**: ~796 (Savannah HEAD, 2025-03-27)
- **CWE**: 407 — Inefficient Algorithmic Complexity
- **Severity**: HIGH
## Pattern
```c
/* Outer: for (intermed_ok = 0; intermed_ok < 2; ++intermed_ok) */
/* Outer: for (ri = 0; ri < nrules; ri++) */
/* Middle: while(1) / for (d = dl; d != 0; d = d->next) */
if (df && df->is_target)
explicit = 1;
else
for (dp = file->deps; dp != 0; dp = dp->next) /* O(F) */
if (streq (d->name, dep_name (dp))) /* O(F) linear scan */
break;
```
## Complexity
- `R` = number of pattern rules (can be hundreds of built-in + user-defined rules)
- `D` = number of pattern prerequisites per rule (typically 1-5)
- `F` = number of explicit prerequisites of the current target file
For each target, `pattern_search` runs through R rules × D deps × F explicit deps.
The O(F) inner linear scan is performed for every `(rule, dep)` pair.
**Worst case**: target with F=100 deps and R=200 rules with D=5 deps each:
- Without fix: 200 × 5 × 100 = 100,000 string comparisons
- With fix: build hash set once from F deps (O(F)), then O(1) per lookup:
200 × 5 × 1 = 1,000 lookups + 100 hash inserts = ~1,100 ops
- **Speedup**: ~91× at F=100, scales as O(F)
## Root Cause
The function `pattern_search` is the hot path called for every target that
needs an implicit rule. In a project with many targets (e.g. a large
parallel make with hundreds of object files, each with many explicit
prerequisites), this inner loop fires F times per (rule, dep) combination.
`file->deps` is a linked list — no random access or hashing. The membership
test `streq(d->name, dep_name(dp))` scans the whole list every time.
## Fix
Build a `hash_set` (or a `struct hash_table` using GNU Make's `hashmap`
infrastructure) from `file->deps` **once** before the rule loop begins.
Replace the inner `for (dp = file->deps; ...)` linear scan with an O(1)
hash lookup.
```c
/* CWE-407 fix: build a set of explicit dep names once before the rule loop.
The inner for(dp = file->deps; ...) scan was O(F) per (rule, dep) pair,
giving O(R * D * F) total. A hash set gives O(R * D + F). */
struct hash_table *dep_name_set = make_file_dep_name_set (file);
/* ... inside the rule/dep loops ... */
if (df && df->is_target)
explicit = 1;
else
dp = dep_name_set_contains (dep_name_set, d->name) ? (struct dep *)1 : 0;
```
GNU Make already uses `struct hash_table` (see `hash.h`) for file name
lookup (`hash_find_item`). The same infrastructure applies here.
## Evidence
Confirmed present in:
- `src/implicit.c` in GNU Make mirror (mirror/make on GitHub, ~2024)
- `src/implicit.c` in GNU Make Savannah HEAD (`cgit/make.git`, 2025-03-27)
Lines 796-797 (Savannah):
```c
for (dp = file->deps; dp != 0; dp = dp->next)
if (streq (d->name, dep_name (dp)))
```

180
defects/make/unit/MakeAlgorithm.java Normal file
View file

@ -0,0 +1,180 @@
package unit;
import java.util.*;
/**
* Unit test for make-0001: GNU Make pattern_search file->deps O(R×D×F) linear scan.
*
* Models the pattern in src/implicit.c (pattern_search):
*
* for (intermed_ok = 0; intermed_ok < 2; ++intermed_ok)
* for (ri = 0; ri < nrules; ri++)
* [while(1) / for d in rule_deps]
* for (dp = file->deps; dp != 0; dp = dp->next) // O(F) linear scan
* if (streq(d->name, dep_name(dp))) break; // CWE-407 defect
*
* SLOW: LinkedList.contains() — O(F) per (rule, dep) pair → O(R×D×F) total
* FAST: HashSet.contains() — O(1) per lookup → O(R×D + F) total
*/
public class MakeAlgorithm {
// -----------------------------------------------------------------------
// Test parameters
// -----------------------------------------------------------------------
private static final int N_FILE_DEPS = 500; // F: explicit deps per target
private static final int N_RULES = 200; // R: pattern rules
private static final int N_RULE_DEPS = 5; // D: prereqs per rule (avg)
private static final int REQUIRED_RATIO = 5;
// -----------------------------------------------------------------------
// Simulate file->deps as a linked list (as in GNU Make)
// -----------------------------------------------------------------------
static class Dep {
final String name;
Dep next;
Dep(String name) { this.name = name; }
}
/** Build a linked list of F dependency names. */
static Dep buildDepList(int f) {
Dep head = null;
for (int i = f - 1; i >= 0; i--) {
Dep d = new Dep("dep_" + i);
d.next = head;
head = d;
}
return head;
}
/** Build R pattern rules, each with D deps (some match file->deps). */
static List<List<String>> buildRules(int r, int d, int f) {
List<List<String>> rules = new ArrayList<>(r);
Random rng = new Random(42);
for (int i = 0; i < r; i++) {
List<String> ruleDeps = new ArrayList<>(d);
for (int j = 0; j < d; j++) {
// Mix of matching and non-matching deps
if (rng.nextInt(3) == 0 && f > 0)
ruleDeps.add("dep_" + rng.nextInt(f)); // matches file->deps
else
ruleDeps.add("rule_dep_" + i + "_" + j); // doesn't match
}
rules.add(ruleDeps);
}
return rules;
}
// -----------------------------------------------------------------------
// SLOW: O(R×D×F) — linear scan of file->deps for each (rule, dep)
// -----------------------------------------------------------------------
static long slowPatternSearch(List<List<String>> rules, Dep fileDepHead) {
long ops = 0;
for (int intermedOk = 0; intermedOk < 2; intermedOk++) {
for (List<String> ruleDeps : rules) {
for (String ruleDep : ruleDeps) {
// Simulate: for (dp = file->deps; dp != 0; dp = dp->next)
// if (streq(ruleDep, dep_name(dp))) break;
boolean found = false;
for (Dep dp = fileDepHead; dp != null; dp = dp.next) {
ops++;
if (dp.name.equals(ruleDep)) {
found = true;
break;
}
}
}
}
}
return ops;
}
// -----------------------------------------------------------------------
// FAST: O(R×D + F) — build HashSet once, then O(1) lookup per (rule, dep)
// -----------------------------------------------------------------------
static long fastPatternSearch(List<List<String>> rules, Dep fileDepHead) {
long ops = 0;
// CWE-407 fix: build hash set from file->deps once
Set<String> depNameSet = new HashSet<>();
for (Dep dp = fileDepHead; dp != null; dp = dp.next) {
ops++; // building the set
depNameSet.add(dp.name);
}
for (int intermedOk = 0; intermedOk < 2; intermedOk++) {
for (List<String> ruleDeps : rules) {
for (String ruleDep : ruleDeps) {
ops++; // O(1) hash lookup
depNameSet.contains(ruleDep);
}
}
}
return ops;
}
// -----------------------------------------------------------------------
// Test runner
// -----------------------------------------------------------------------
static boolean runTest(String name, int fileDeps, int rules, int ruleDeps) {
Dep fileDepHead = buildDepList(fileDeps);
List<List<String>> ruleList = buildRules(rules, ruleDeps, fileDeps);
long slowOps = slowPatternSearch(ruleList, fileDepHead);
long fastOps = fastPatternSearch(ruleList, fileDepHead);
double ratio = (double) slowOps / fastOps;
boolean pass = ratio >= REQUIRED_RATIO;
System.out.printf(" %-40s slow=%,7d fast=%,7d ratio=%5.1fx %s%n",
name, slowOps, fastOps, ratio, pass ? "PASS" : "FAIL");
return pass;
}
public static void main(String[] args) {
System.out.println("make-0001: GNU Make pattern_search O(R×D×F) dep linear scan");
System.out.println("=".repeat(78));
int pass = 0, total = 0;
// ---- correctness: results should agree ----
{
Dep hd = buildDepList(50);
List<List<String>> rl = buildRules(10, 3, 50);
Set<String> depSet = new HashSet<>();
for (Dep dp = hd; dp != null; dp = dp.next) depSet.add(dp.name);
boolean slowFound = false, fastFound = false;
String target = "dep_25";
for (List<String> ruleDeps : rl) {
for (String rd : ruleDeps) {
if (rd.equals(target)) { slowFound = true; break; }
}
if (slowFound) break;
}
// Simulate fast path for correctness check
List<List<String>> rl2 = new ArrayList<>();
List<String> artificialRule = Collections.singletonList(target);
rl2.add(artificialRule);
for (List<String> ruleDeps : rl2)
for (String rd : ruleDeps)
if (depSet.contains(rd)) { fastFound = true; break; }
// target is dep_25 which IS in depSet
assert fastFound : "fast path should find dep_25 in depSet";
}
// ---- performance tests ----
System.out.println();
total++; if (runTest("F=500 R=200 D=5 (baseline)", N_FILE_DEPS, N_RULES, N_RULE_DEPS)) pass++;
total++; if (runTest("F=100 R=100 D=3 (small)", 100, 100, 3)) pass++;
total++; if (runTest("F=1000 R=300 D=5 (large)", 1000, 300, 5)) pass++;
total++; if (runTest("F=200 R=400 D=8 (many rules)",200, 400, 8)) pass++;
total++; if (runTest("F=800 R=150 D=4 (heavy deps)",800, 150, 4)) pass++;
System.out.println();
System.out.printf("%d/%d PASS%n", pass, total);
if (pass != total) System.exit(1);
}
}