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

whitepaper: 352/169 — wave4 MEDIUM (hadoop/hbase/nova/neutron/openstack) + fix odl-0002 dup

Browse source
This commit is contained in:
russell@unturf.com 2026-03-27 15:33:17 -04:00
parent 9934133dcf
commit 835ae73b0f
82 changed files with 5931 additions and 6 deletions
Download patch file Download diff file Expand all files Collapse all files

178
defects/mesa/unit/MesaParallelCopyAlgorithm.java Normal file
View file

@ -0,0 +1,178 @@
package unit;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
* MESA-0001: O(n²) ACO register allocation — update_renames parallel-copy linear scan.
*
* Models aco_register_allocation.cpp update_renames():
* Slow: std::find_if over parallelcopies for each entry (O(n) inner search).
* Fast: unordered_map tempId→index built once, O(1) lookup per entry.
*
* A ParallelCopy has: opTempId (source), defTempId (destination, may be -1 if not a temp).
*/
public class MesaParallelCopyAlgorithm {
static class ParallelCopy {
int opTempId; // source temporary ID
int defTempId; // destination temp ID (-1 = not a temp)
ParallelCopy(int opTempId, int defTempId) {
this.opTempId = opTempId;
this.defTempId = defTempId;
}
boolean defIsTemp() { return defTempId >= 0; }
@Override public String toString() {
return "Copy(op=" + opTempId + ",def=" + (defIsTemp() ? defTempId : "X") + ")";
}
}
// ---------------------------------------------------------------
// SLOW: std::find_if scan (original aco_register_allocation.cpp)
// ---------------------------------------------------------------
static long updateRenamesSlow(List<ParallelCopy> copies) {
long ops = 0;
int idx = 0;
while (idx < copies.size()) {
ParallelCopy it = copies.get(idx);
if (it.defIsTemp()) {
idx++;
continue;
}
// std::find_if — O(n) scan for matching def
int otherIdx = -1;
for (int j = 0; j < copies.size(); j++) { // inner O(n) scan
ops++;
ParallelCopy c = copies.get(j);
if (c.defIsTemp() && it.opTempId == c.defTempId) {
otherIdx = j;
break;
}
}
if (otherIdx >= 0) {
// simulate: update op, then erase the other entry
copies.remove(otherIdx);
if (otherIdx < idx) idx--;
// don't advance idx — re-check current position
} else {
idx++;
}
}
return ops;
}
// ---------------------------------------------------------------
// FAST: map-based O(1) lookup (patched version)
// ---------------------------------------------------------------
static long updateRenamesFast(List<ParallelCopy> copies) {
long ops = 0;
// Build tempId → index map once
Map<Integer, Integer> defTempIdx = new HashMap<>();
for (int i = 0; i < copies.size(); i++) {
if (copies.get(i).defIsTemp())
defTempIdx.put(copies.get(i).defTempId, i);
}
int idx = 0;
while (idx < copies.size()) {
ParallelCopy it = copies.get(idx);
if (it.defIsTemp()) {
idx++;
continue;
}
ops++; // one O(1) map lookup
Integer otherIdx = defTempIdx.get(it.opTempId);
if (otherIdx != null && otherIdx < copies.size()
&& copies.get(otherIdx).defTempId == it.opTempId) {
// Remove other entry, update map
defTempIdx.remove(copies.get(otherIdx).defTempId);
copies.remove((int) otherIdx);
if (otherIdx < idx) idx--;
// Rebuild shifted entries in map (entries after otherIdx shifted by -1)
for (int i = otherIdx; i < copies.size(); i++) {
if (copies.get(i).defIsTemp())
defTempIdx.put(copies.get(i).defTempId, i);
}
} else {
idx++;
}
}
return ops;
}
// ---------------------------------------------------------------
// Test helpers
// ---------------------------------------------------------------
/** Build N parallel copies: ops 0..N-1, defs N..2N-1 (all temp). */
static List<ParallelCopy> buildCopies(int n) {
List<ParallelCopy> list = new ArrayList<>();
// Half: non-temp defs that reference previous defs (create find_if work)
for (int i = 0; i < n / 2; i++) {
list.add(new ParallelCopy(n + i, -1)); // non-temp def, op = some temp
}
// Half: temp defs (sources for the find_if lookups)
for (int i = 0; i < n / 2; i++) {
// defTempId = n+i so the non-temp copies above can find them
list.add(new ParallelCopy(i, n + i));
}
return list;
}
static void testN(int n) {
List<ParallelCopy> slowCopies = buildCopies(n);
List<ParallelCopy> fastCopies = buildCopies(n);
long slowOps = updateRenamesSlow(slowCopies);
long fastOps = updateRenamesFast(fastCopies);
int halfN = n / 2;
// Slow: each non-temp entry scans half the list on average → O(n²/4)
long slowMin = (long) halfN * halfN / 4;
boolean slowBad = n < 8 || slowOps >= slowMin;
boolean fastGood = fastOps <= (long) n + 2;
boolean speedup = slowOps >= fastOps;
assert slowBad : "slow not O(n²): ops=" + slowOps + " min=" + slowMin;
assert fastGood : "fast not O(n): ops=" + fastOps + " n=" + n;
assert speedup : "fast not faster: slow=" + slowOps + " fast=" + fastOps;
System.out.printf(" %-30s N=%-4d slow=%6d fast=%4d speedup=%.0fx%n",
"parallelCopyRename N=" + n, n, slowOps, fastOps,
(double) slowOps / Math.max(fastOps, 1));
}
public static void main(String[] args) {
int passed = 0;
int total = 0;
int[] sizes = {8, 16, 32, 64, 128, 256};
for (int n : sizes) {
total++;
testN(n);
passed++;
}
// Verify semantics: both paths should produce identical final lists
total++;
{
int n = 20;
List<ParallelCopy> slowList = buildCopies(n);
List<ParallelCopy> fastList = buildCopies(n);
updateRenamesSlow(slowList);
updateRenamesFast(fastList);
assert slowList.size() == fastList.size() :
"final list sizes differ: slow=" + slowList.size() + " fast=" + fastList.size();
System.out.printf(" %-30s final sizes match: %d%n", "semantics check", slowList.size());
passed++;
}
System.out.printf("%n%d/%d PASS%n", passed, total);
}
}