diff --git a/defects/dragonflybsd/Makefile b/defects/dragonflybsd/Makefile new file mode 100644 index 000000000..125b5b8f6 --- /dev/null +++ b/defects/dragonflybsd/Makefile @@ -0,0 +1,6 @@ +.PHONY: all bench clean +all: bench +bench: + python3 bench/run_all.py +clean: + rm -rf bench/__pycache__ __pycache__ diff --git a/defects/dragonflybsd/bench/bench-dragonflybsd-0001.py b/defects/dragonflybsd/bench/bench-dragonflybsd-0001.py new file mode 100644 index 000000000..d8141ec59 --- /dev/null +++ b/defects/dragonflybsd/bench/bench-dragonflybsd-0001.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +# bench-dragonflybsd-0001.py +# CWE-407: list-scan inside loop in dragonflybsd-0001 (generic model) +# Models O(N*k) -> O(N+k) via linear-scan membership inside a loop vs set/dict. + +import sys +import time + + +def bench_defective(n, k): + pool = list(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool: # O(k) + seen.append(x) + return time.perf_counter() - t0 + + +def bench_fixed(n, k): + pool_set = set(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool_set: # O(1) + seen.append(x) + return time.perf_counter() - t0 + + +TRIALS = 3 +CASES = [(100, 100), (500, 500), (1000, 1000), (2000, 2000)] + + +def run(): + lines = [] + header = "=== dragonflybsd-0001: CWE-407: list-scan inside loop in dragonflybsd-0001 (generic model) ===" + print(header); lines.append(header) + for n, k in CASES: + df = min(bench_defective(n, k) for _ in range(TRIALS)) + fx = min(bench_fixed(n, k) for _ in range(TRIALS)) + speedup = (df / fx) if fx > 0 else float("inf") + line = f"N={n:<5} k={k:<5}: defective={df*1000:.3f}ms fixed={fx*1000:.3f}ms speedup={speedup:.1f}x" + print(line); lines.append(line); sys.stdout.flush() + return lines + + +if __name__ == "__main__": + run() diff --git a/defects/dragonflybsd/bench/bench-dragonflybsd-0002.py b/defects/dragonflybsd/bench/bench-dragonflybsd-0002.py new file mode 100644 index 000000000..907461cbb --- /dev/null +++ b/defects/dragonflybsd/bench/bench-dragonflybsd-0002.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +# bench-dragonflybsd-0002.py +# CWE-407: list-scan inside loop in dragonflybsd-0002 (generic model) +# Models O(N*k) -> O(N+k) via linear-scan membership inside a loop vs set/dict. + +import sys +import time + + +def bench_defective(n, k): + pool = list(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool: # O(k) + seen.append(x) + return time.perf_counter() - t0 + + +def bench_fixed(n, k): + pool_set = set(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool_set: # O(1) + seen.append(x) + return time.perf_counter() - t0 + + +TRIALS = 3 +CASES = [(100, 100), (500, 500), (1000, 1000), (2000, 2000)] + + +def run(): + lines = [] + header = "=== dragonflybsd-0002: CWE-407: list-scan inside loop in dragonflybsd-0002 (generic model) ===" + print(header); lines.append(header) + for n, k in CASES: + df = min(bench_defective(n, k) for _ in range(TRIALS)) + fx = min(bench_fixed(n, k) for _ in range(TRIALS)) + speedup = (df / fx) if fx > 0 else float("inf") + line = f"N={n:<5} k={k:<5}: defective={df*1000:.3f}ms fixed={fx*1000:.3f}ms speedup={speedup:.1f}x" + print(line); lines.append(line); sys.stdout.flush() + return lines + + +if __name__ == "__main__": + run() diff --git a/defects/dragonflybsd/bench/bench-dragonflybsd-0003.py b/defects/dragonflybsd/bench/bench-dragonflybsd-0003.py new file mode 100644 index 000000000..4f2341ca4 --- /dev/null +++ b/defects/dragonflybsd/bench/bench-dragonflybsd-0003.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +# bench-dragonflybsd-0003.py +# CWE-407: list-scan inside loop in dragonflybsd-0003 (generic model) +# Models O(N*k) -> O(N+k) via linear-scan membership inside a loop vs set/dict. + +import sys +import time + + +def bench_defective(n, k): + pool = list(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool: # O(k) + seen.append(x) + return time.perf_counter() - t0 + + +def bench_fixed(n, k): + pool_set = set(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool_set: # O(1) + seen.append(x) + return time.perf_counter() - t0 + + +TRIALS = 3 +CASES = [(100, 100), (500, 500), (1000, 1000), (2000, 2000)] + + +def run(): + lines = [] + header = "=== dragonflybsd-0003: CWE-407: list-scan inside loop in dragonflybsd-0003 (generic model) ===" + print(header); lines.append(header) + for n, k in CASES: + df = min(bench_defective(n, k) for _ in range(TRIALS)) + fx = min(bench_fixed(n, k) for _ in range(TRIALS)) + speedup = (df / fx) if fx > 0 else float("inf") + line = f"N={n:<5} k={k:<5}: defective={df*1000:.3f}ms fixed={fx*1000:.3f}ms speedup={speedup:.1f}x" + print(line); lines.append(line); sys.stdout.flush() + return lines + + +if __name__ == "__main__": + run() diff --git a/defects/dragonflybsd/bench/bench-dragonflybsd-0004.py b/defects/dragonflybsd/bench/bench-dragonflybsd-0004.py new file mode 100644 index 000000000..992e9f10f --- /dev/null +++ b/defects/dragonflybsd/bench/bench-dragonflybsd-0004.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +# bench-dragonflybsd-0004.py +# CWE-407: list-scan inside loop in dragonflybsd-0004 (generic model) +# Models O(N*k) -> O(N+k) via linear-scan membership inside a loop vs set/dict. + +import sys +import time + + +def bench_defective(n, k): + pool = list(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool: # O(k) + seen.append(x) + return time.perf_counter() - t0 + + +def bench_fixed(n, k): + pool_set = set(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool_set: # O(1) + seen.append(x) + return time.perf_counter() - t0 + + +TRIALS = 3 +CASES = [(100, 100), (500, 500), (1000, 1000), (2000, 2000)] + + +def run(): + lines = [] + header = "=== dragonflybsd-0004: CWE-407: list-scan inside loop in dragonflybsd-0004 (generic model) ===" + print(header); lines.append(header) + for n, k in CASES: + df = min(bench_defective(n, k) for _ in range(TRIALS)) + fx = min(bench_fixed(n, k) for _ in range(TRIALS)) + speedup = (df / fx) if fx > 0 else float("inf") + line = f"N={n:<5} k={k:<5}: defective={df*1000:.3f}ms fixed={fx*1000:.3f}ms speedup={speedup:.1f}x" + print(line); lines.append(line); sys.stdout.flush() + return lines + + +if __name__ == "__main__": + run() diff --git a/defects/dragonflybsd/bench/bench-dragonflybsd-0005.py b/defects/dragonflybsd/bench/bench-dragonflybsd-0005.py new file mode 100644 index 000000000..096f9cfb2 --- /dev/null +++ b/defects/dragonflybsd/bench/bench-dragonflybsd-0005.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +# bench-dragonflybsd-0005.py +# CWE-407: list-scan inside loop in dragonflybsd-0005 (generic model) +# Models O(N*k) -> O(N+k) via linear-scan membership inside a loop vs set/dict. + +import sys +import time + + +def bench_defective(n, k): + pool = list(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool: # O(k) + seen.append(x) + return time.perf_counter() - t0 + + +def bench_fixed(n, k): + pool_set = set(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool_set: # O(1) + seen.append(x) + return time.perf_counter() - t0 + + +TRIALS = 3 +CASES = [(100, 100), (500, 500), (1000, 1000), (2000, 2000)] + + +def run(): + lines = [] + header = "=== dragonflybsd-0005: CWE-407: list-scan inside loop in dragonflybsd-0005 (generic model) ===" + print(header); lines.append(header) + for n, k in CASES: + df = min(bench_defective(n, k) for _ in range(TRIALS)) + fx = min(bench_fixed(n, k) for _ in range(TRIALS)) + speedup = (df / fx) if fx > 0 else float("inf") + line = f"N={n:<5} k={k:<5}: defective={df*1000:.3f}ms fixed={fx*1000:.3f}ms speedup={speedup:.1f}x" + print(line); lines.append(line); sys.stdout.flush() + return lines + + +if __name__ == "__main__": + run() diff --git a/defects/dragonflybsd/bench/results.txt b/defects/dragonflybsd/bench/results.txt new file mode 100644 index 000000000..f5913f926 --- /dev/null +++ b/defects/dragonflybsd/bench/results.txt @@ -0,0 +1,30 @@ +=== dragonflybsd-0001: CWE-407: list-scan inside loop in dragonflybsd-0001 (generic model) === +N=100 k=100 : defective=0.065ms fixed=0.003ms speedup=24.8x +N=500 k=500 : defective=1.627ms fixed=0.016ms speedup=103.2x +N=1000 k=1000 : defective=6.535ms fixed=0.033ms speedup=198.4x +N=2000 k=2000 : defective=23.729ms fixed=0.062ms speedup=384.0x + +=== dragonflybsd-0002: CWE-407: list-scan inside loop in dragonflybsd-0002 (generic model) === +N=100 k=100 : defective=0.054ms fixed=0.002ms speedup=24.7x +N=500 k=500 : defective=1.337ms fixed=0.013ms speedup=102.2x +N=1000 k=1000 : defective=6.006ms fixed=0.031ms speedup=196.0x +N=2000 k=2000 : defective=29.369ms fixed=0.070ms speedup=416.8x + +=== dragonflybsd-0003: CWE-407: list-scan inside loop in dragonflybsd-0003 (generic model) === +N=100 k=100 : defective=0.063ms fixed=0.003ms speedup=22.6x +N=500 k=500 : defective=1.499ms fixed=0.015ms speedup=100.1x +N=1000 k=1000 : defective=5.752ms fixed=0.029ms speedup=195.8x +N=2000 k=2000 : defective=23.035ms fixed=0.062ms speedup=371.0x + +=== dragonflybsd-0004: CWE-407: list-scan inside loop in dragonflybsd-0004 (generic model) === +N=100 k=100 : defective=0.054ms fixed=0.002ms speedup=24.8x +N=500 k=500 : defective=1.345ms fixed=0.013ms speedup=101.8x +N=1000 k=1000 : defective=5.648ms fixed=0.029ms speedup=196.2x +N=2000 k=2000 : defective=22.910ms fixed=0.061ms speedup=373.8x + +=== dragonflybsd-0005: CWE-407: list-scan inside loop in dragonflybsd-0005 (generic model) === +N=100 k=100 : defective=0.053ms fixed=0.002ms speedup=24.4x +N=500 k=500 : defective=1.374ms fixed=0.013ms speedup=104.4x +N=1000 k=1000 : defective=5.856ms fixed=0.030ms speedup=192.0x +N=2000 k=2000 : defective=24.400ms fixed=0.062ms speedup=390.7x + diff --git a/defects/dragonflybsd/bench/run_all.py b/defects/dragonflybsd/bench/run_all.py new file mode 100644 index 000000000..771192e26 --- /dev/null +++ b/defects/dragonflybsd/bench/run_all.py @@ -0,0 +1,22 @@ +#!/usr/bin/env python3 +import importlib.util, os, sys +BENCH_DIR = os.path.dirname(os.path.abspath(__file__)) + +def load_module(filename): + path = os.path.join(BENCH_DIR, filename) + spec = importlib.util.spec_from_file_location("mod", path) + mod = importlib.util.module_from_spec(spec) + spec.loader.exec_module(mod) + return mod + +all_lines = [] +for fname in ["bench-dragonflybsd-0001.py", "bench-dragonflybsd-0002.py", "bench-dragonflybsd-0003.py", "bench-dragonflybsd-0004.py", "bench-dragonflybsd-0005.py"]: + mod = load_module(fname) + lines = mod.run() + all_lines.extend(lines); all_lines.append("") + print(); sys.stdout.flush() + +out_path = os.path.join(BENCH_DIR, "results.txt") +with open(out_path, "w") as f: + f.write("\n".join(all_lines) + "\n") +print(f"results written to {out_path}"); sys.stdout.flush() diff --git a/defects/hadoop-rpc/Makefile b/defects/hadoop-rpc/Makefile new file mode 100644 index 000000000..125b5b8f6 --- /dev/null +++ b/defects/hadoop-rpc/Makefile @@ -0,0 +1,6 @@ +.PHONY: all bench clean +all: bench +bench: + python3 bench/run_all.py +clean: + rm -rf bench/__pycache__ __pycache__ diff --git a/defects/hadoop-rpc/bench/bench-hadoop-rpc-0001.py b/defects/hadoop-rpc/bench/bench-hadoop-rpc-0001.py new file mode 100644 index 000000000..b7017b859 --- /dev/null +++ b/defects/hadoop-rpc/bench/bench-hadoop-rpc-0001.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +# bench-hadoop-rpc-0001.py +# CWE-407: list-scan inside loop in hadoop-rpc-0001 (generic model) +# Models O(N*k) -> O(N+k) via linear-scan membership inside a loop vs set/dict. + +import sys +import time + + +def bench_defective(n, k): + pool = list(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool: # O(k) + seen.append(x) + return time.perf_counter() - t0 + + +def bench_fixed(n, k): + pool_set = set(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool_set: # O(1) + seen.append(x) + return time.perf_counter() - t0 + + +TRIALS = 3 +CASES = [(100, 100), (500, 500), (1000, 1000), (2000, 2000)] + + +def run(): + lines = [] + header = "=== hadoop-rpc-0001: CWE-407: list-scan inside loop in hadoop-rpc-0001 (generic model) ===" + print(header); lines.append(header) + for n, k in CASES: + df = min(bench_defective(n, k) for _ in range(TRIALS)) + fx = min(bench_fixed(n, k) for _ in range(TRIALS)) + speedup = (df / fx) if fx > 0 else float("inf") + line = f"N={n:<5} k={k:<5}: defective={df*1000:.3f}ms fixed={fx*1000:.3f}ms speedup={speedup:.1f}x" + print(line); lines.append(line); sys.stdout.flush() + return lines + + +if __name__ == "__main__": + run() diff --git a/defects/hadoop-rpc/bench/results.txt b/defects/hadoop-rpc/bench/results.txt new file mode 100644 index 000000000..44abfcabf --- /dev/null +++ b/defects/hadoop-rpc/bench/results.txt @@ -0,0 +1,6 @@ +=== hadoop-rpc-0001: CWE-407: list-scan inside loop in hadoop-rpc-0001 (generic model) === +N=100 k=100 : defective=0.063ms fixed=0.003ms speedup=24.9x +N=500 k=500 : defective=1.709ms fixed=0.029ms speedup=58.7x +N=1000 k=1000 : defective=6.768ms fixed=0.031ms speedup=217.5x +N=2000 k=2000 : defective=23.214ms fixed=0.062ms speedup=373.9x + diff --git a/defects/hadoop-rpc/bench/run_all.py b/defects/hadoop-rpc/bench/run_all.py new file mode 100644 index 000000000..812c27caf --- /dev/null +++ b/defects/hadoop-rpc/bench/run_all.py @@ -0,0 +1,22 @@ +#!/usr/bin/env python3 +import importlib.util, os, sys +BENCH_DIR = os.path.dirname(os.path.abspath(__file__)) + +def load_module(filename): + path = os.path.join(BENCH_DIR, filename) + spec = importlib.util.spec_from_file_location("mod", path) + mod = importlib.util.module_from_spec(spec) + spec.loader.exec_module(mod) + return mod + +all_lines = [] +for fname in ["bench-hadoop-rpc-0001.py"]: + mod = load_module(fname) + lines = mod.run() + all_lines.extend(lines); all_lines.append("") + print(); sys.stdout.flush() + +out_path = os.path.join(BENCH_DIR, "results.txt") +with open(out_path, "w") as f: + f.write("\n".join(all_lines) + "\n") +print(f"results written to {out_path}"); sys.stdout.flush() diff --git a/defects/jami/Makefile b/defects/jami/Makefile new file mode 100644 index 000000000..125b5b8f6 --- /dev/null +++ b/defects/jami/Makefile @@ -0,0 +1,6 @@ +.PHONY: all bench clean +all: bench +bench: + python3 bench/run_all.py +clean: + rm -rf bench/__pycache__ __pycache__ diff --git a/defects/jami/bench/bench-jami-daemon-0001.py b/defects/jami/bench/bench-jami-daemon-0001.py new file mode 100644 index 000000000..59b0e5e18 --- /dev/null +++ b/defects/jami/bench/bench-jami-daemon-0001.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +# bench-jami-daemon-0001.py +# CWE-407: list-scan inside loop in jami-daemon-0001 (generic model) +# Models O(N*k) -> O(N+k) via linear-scan membership inside a loop vs set/dict. + +import sys +import time + + +def bench_defective(n, k): + pool = list(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool: # O(k) + seen.append(x) + return time.perf_counter() - t0 + + +def bench_fixed(n, k): + pool_set = set(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool_set: # O(1) + seen.append(x) + return time.perf_counter() - t0 + + +TRIALS = 3 +CASES = [(100, 100), (500, 500), (1000, 1000), (2000, 2000)] + + +def run(): + lines = [] + header = "=== jami-daemon-0001: CWE-407: list-scan inside loop in jami-daemon-0001 (generic model) ===" + print(header); lines.append(header) + for n, k in CASES: + df = min(bench_defective(n, k) for _ in range(TRIALS)) + fx = min(bench_fixed(n, k) for _ in range(TRIALS)) + speedup = (df / fx) if fx > 0 else float("inf") + line = f"N={n:<5} k={k:<5}: defective={df*1000:.3f}ms fixed={fx*1000:.3f}ms speedup={speedup:.1f}x" + print(line); lines.append(line); sys.stdout.flush() + return lines + + +if __name__ == "__main__": + run() diff --git a/defects/jami/bench/bench-jami-daemon-0002.py b/defects/jami/bench/bench-jami-daemon-0002.py new file mode 100644 index 000000000..d689f62cb --- /dev/null +++ b/defects/jami/bench/bench-jami-daemon-0002.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +# bench-jami-daemon-0002.py +# CWE-407: list-scan inside loop in jami-daemon-0002 (generic model) +# Models O(N*k) -> O(N+k) via linear-scan membership inside a loop vs set/dict. + +import sys +import time + + +def bench_defective(n, k): + pool = list(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool: # O(k) + seen.append(x) + return time.perf_counter() - t0 + + +def bench_fixed(n, k): + pool_set = set(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool_set: # O(1) + seen.append(x) + return time.perf_counter() - t0 + + +TRIALS = 3 +CASES = [(100, 100), (500, 500), (1000, 1000), (2000, 2000)] + + +def run(): + lines = [] + header = "=== jami-daemon-0002: CWE-407: list-scan inside loop in jami-daemon-0002 (generic model) ===" + print(header); lines.append(header) + for n, k in CASES: + df = min(bench_defective(n, k) for _ in range(TRIALS)) + fx = min(bench_fixed(n, k) for _ in range(TRIALS)) + speedup = (df / fx) if fx > 0 else float("inf") + line = f"N={n:<5} k={k:<5}: defective={df*1000:.3f}ms fixed={fx*1000:.3f}ms speedup={speedup:.1f}x" + print(line); lines.append(line); sys.stdout.flush() + return lines + + +if __name__ == "__main__": + run() diff --git a/defects/jami/bench/bench-jami-daemon.py b/defects/jami/bench/bench-jami-daemon.py new file mode 100644 index 000000000..2525a4b79 --- /dev/null +++ b/defects/jami/bench/bench-jami-daemon.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +# bench-jami-daemon.py +# CWE-407: list-scan inside loop in jami-daemon (generic model) +# Models O(N*k) -> O(N+k) via linear-scan membership inside a loop vs set/dict. + +import sys +import time + + +def bench_defective(n, k): + pool = list(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool: # O(k) + seen.append(x) + return time.perf_counter() - t0 + + +def bench_fixed(n, k): + pool_set = set(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool_set: # O(1) + seen.append(x) + return time.perf_counter() - t0 + + +TRIALS = 3 +CASES = [(100, 100), (500, 500), (1000, 1000), (2000, 2000)] + + +def run(): + lines = [] + header = "=== jami-daemon: CWE-407: list-scan inside loop in jami-daemon (generic model) ===" + print(header); lines.append(header) + for n, k in CASES: + df = min(bench_defective(n, k) for _ in range(TRIALS)) + fx = min(bench_fixed(n, k) for _ in range(TRIALS)) + speedup = (df / fx) if fx > 0 else float("inf") + line = f"N={n:<5} k={k:<5}: defective={df*1000:.3f}ms fixed={fx*1000:.3f}ms speedup={speedup:.1f}x" + print(line); lines.append(line); sys.stdout.flush() + return lines + + +if __name__ == "__main__": + run() diff --git a/defects/jami/bench/results.txt b/defects/jami/bench/results.txt new file mode 100644 index 000000000..0cf037e98 --- /dev/null +++ b/defects/jami/bench/results.txt @@ -0,0 +1,18 @@ +=== jami-daemon-0001: CWE-407: list-scan inside loop in jami-daemon-0001 (generic model) === +N=100 k=100 : defective=0.054ms fixed=0.002ms speedup=24.4x +N=500 k=500 : defective=1.357ms fixed=0.013ms speedup=102.0x +N=1000 k=1000 : defective=5.501ms fixed=0.028ms speedup=193.9x +N=2000 k=2000 : defective=23.908ms fixed=0.062ms speedup=386.1x + +=== jami-daemon-0002: CWE-407: list-scan inside loop in jami-daemon-0002 (generic model) === +N=100 k=100 : defective=0.054ms fixed=0.002ms speedup=25.2x +N=500 k=500 : defective=1.355ms fixed=0.013ms speedup=103.6x +N=1000 k=1000 : defective=5.542ms fixed=0.029ms speedup=190.1x +N=2000 k=2000 : defective=22.908ms fixed=0.062ms speedup=372.0x + +=== jami-daemon: CWE-407: list-scan inside loop in jami-daemon (generic model) === +N=100 k=100 : defective=0.054ms fixed=0.002ms speedup=24.7x +N=500 k=500 : defective=1.559ms fixed=0.013ms speedup=117.0x +N=1000 k=1000 : defective=5.574ms fixed=0.030ms speedup=188.4x +N=2000 k=2000 : defective=24.202ms fixed=0.062ms speedup=390.0x + diff --git a/defects/jami/bench/run_all.py b/defects/jami/bench/run_all.py new file mode 100644 index 000000000..f229ed137 --- /dev/null +++ b/defects/jami/bench/run_all.py @@ -0,0 +1,22 @@ +#!/usr/bin/env python3 +import importlib.util, os, sys +BENCH_DIR = os.path.dirname(os.path.abspath(__file__)) + +def load_module(filename): + path = os.path.join(BENCH_DIR, filename) + spec = importlib.util.spec_from_file_location("mod", path) + mod = importlib.util.module_from_spec(spec) + spec.loader.exec_module(mod) + return mod + +all_lines = [] +for fname in ["bench-jami-daemon-0001.py", "bench-jami-daemon-0002.py", "bench-jami-daemon.py"]: + mod = load_module(fname) + lines = mod.run() + all_lines.extend(lines); all_lines.append("") + print(); sys.stdout.flush() + +out_path = os.path.join(BENCH_DIR, "results.txt") +with open(out_path, "w") as f: + f.write("\n".join(all_lines) + "\n") +print(f"results written to {out_path}"); sys.stdout.flush() diff --git a/defects/jitsi/Makefile b/defects/jitsi/Makefile new file mode 100644 index 000000000..125b5b8f6 --- /dev/null +++ b/defects/jitsi/Makefile @@ -0,0 +1,6 @@ +.PHONY: all bench clean +all: bench +bench: + python3 bench/run_all.py +clean: + rm -rf bench/__pycache__ __pycache__ diff --git a/defects/jitsi/bench/bench-jitsi-meet-0001-0001.py b/defects/jitsi/bench/bench-jitsi-meet-0001-0001.py new file mode 100644 index 000000000..782d0166e --- /dev/null +++ b/defects/jitsi/bench/bench-jitsi-meet-0001-0001.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +# bench-jitsi-meet-0001-0001.py +# CWE-407: list-scan inside loop in jitsi-meet-0001-0001 (generic model) +# Models O(N*k) -> O(N+k) via linear-scan membership inside a loop vs set/dict. + +import sys +import time + + +def bench_defective(n, k): + pool = list(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool: # O(k) + seen.append(x) + return time.perf_counter() - t0 + + +def bench_fixed(n, k): + pool_set = set(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool_set: # O(1) + seen.append(x) + return time.perf_counter() - t0 + + +TRIALS = 3 +CASES = [(100, 100), (500, 500), (1000, 1000), (2000, 2000)] + + +def run(): + lines = [] + header = "=== jitsi-meet-0001-0001: CWE-407: list-scan inside loop in jitsi-meet-0001-0001 (generic model) ===" + print(header); lines.append(header) + for n, k in CASES: + df = min(bench_defective(n, k) for _ in range(TRIALS)) + fx = min(bench_fixed(n, k) for _ in range(TRIALS)) + speedup = (df / fx) if fx > 0 else float("inf") + line = f"N={n:<5} k={k:<5}: defective={df*1000:.3f}ms fixed={fx*1000:.3f}ms speedup={speedup:.1f}x" + print(line); lines.append(line); sys.stdout.flush() + return lines + + +if __name__ == "__main__": + run() diff --git a/defects/jitsi/bench/bench-jitsi-meet-0002-0002.py b/defects/jitsi/bench/bench-jitsi-meet-0002-0002.py new file mode 100644 index 000000000..5c4367820 --- /dev/null +++ b/defects/jitsi/bench/bench-jitsi-meet-0002-0002.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +# bench-jitsi-meet-0002-0002.py +# CWE-407: list-scan inside loop in jitsi-meet-0002-0002 (generic model) +# Models O(N*k) -> O(N+k) via linear-scan membership inside a loop vs set/dict. + +import sys +import time + + +def bench_defective(n, k): + pool = list(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool: # O(k) + seen.append(x) + return time.perf_counter() - t0 + + +def bench_fixed(n, k): + pool_set = set(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool_set: # O(1) + seen.append(x) + return time.perf_counter() - t0 + + +TRIALS = 3 +CASES = [(100, 100), (500, 500), (1000, 1000), (2000, 2000)] + + +def run(): + lines = [] + header = "=== jitsi-meet-0002-0002: CWE-407: list-scan inside loop in jitsi-meet-0002-0002 (generic model) ===" + print(header); lines.append(header) + for n, k in CASES: + df = min(bench_defective(n, k) for _ in range(TRIALS)) + fx = min(bench_fixed(n, k) for _ in range(TRIALS)) + speedup = (df / fx) if fx > 0 else float("inf") + line = f"N={n:<5} k={k:<5}: defective={df*1000:.3f}ms fixed={fx*1000:.3f}ms speedup={speedup:.1f}x" + print(line); lines.append(line); sys.stdout.flush() + return lines + + +if __name__ == "__main__": + run() diff --git a/defects/jitsi/bench/bench-jitsi-meet-0003-0003.py b/defects/jitsi/bench/bench-jitsi-meet-0003-0003.py new file mode 100644 index 000000000..eff3598c6 --- /dev/null +++ b/defects/jitsi/bench/bench-jitsi-meet-0003-0003.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +# bench-jitsi-meet-0003-0003.py +# CWE-407: list-scan inside loop in jitsi-meet-0003-0003 (generic model) +# Models O(N*k) -> O(N+k) via linear-scan membership inside a loop vs set/dict. + +import sys +import time + + +def bench_defective(n, k): + pool = list(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool: # O(k) + seen.append(x) + return time.perf_counter() - t0 + + +def bench_fixed(n, k): + pool_set = set(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool_set: # O(1) + seen.append(x) + return time.perf_counter() - t0 + + +TRIALS = 3 +CASES = [(100, 100), (500, 500), (1000, 1000), (2000, 2000)] + + +def run(): + lines = [] + header = "=== jitsi-meet-0003-0003: CWE-407: list-scan inside loop in jitsi-meet-0003-0003 (generic model) ===" + print(header); lines.append(header) + for n, k in CASES: + df = min(bench_defective(n, k) for _ in range(TRIALS)) + fx = min(bench_fixed(n, k) for _ in range(TRIALS)) + speedup = (df / fx) if fx > 0 else float("inf") + line = f"N={n:<5} k={k:<5}: defective={df*1000:.3f}ms fixed={fx*1000:.3f}ms speedup={speedup:.1f}x" + print(line); lines.append(line); sys.stdout.flush() + return lines + + +if __name__ == "__main__": + run() diff --git a/defects/jitsi/bench/bench-jitsi-meet-0004-0004.py b/defects/jitsi/bench/bench-jitsi-meet-0004-0004.py new file mode 100644 index 000000000..5fea69c7c --- /dev/null +++ b/defects/jitsi/bench/bench-jitsi-meet-0004-0004.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +# bench-jitsi-meet-0004-0004.py +# CWE-407: list-scan inside loop in jitsi-meet-0004-0004 (generic model) +# Models O(N*k) -> O(N+k) via linear-scan membership inside a loop vs set/dict. + +import sys +import time + + +def bench_defective(n, k): + pool = list(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool: # O(k) + seen.append(x) + return time.perf_counter() - t0 + + +def bench_fixed(n, k): + pool_set = set(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool_set: # O(1) + seen.append(x) + return time.perf_counter() - t0 + + +TRIALS = 3 +CASES = [(100, 100), (500, 500), (1000, 1000), (2000, 2000)] + + +def run(): + lines = [] + header = "=== jitsi-meet-0004-0004: CWE-407: list-scan inside loop in jitsi-meet-0004-0004 (generic model) ===" + print(header); lines.append(header) + for n, k in CASES: + df = min(bench_defective(n, k) for _ in range(TRIALS)) + fx = min(bench_fixed(n, k) for _ in range(TRIALS)) + speedup = (df / fx) if fx > 0 else float("inf") + line = f"N={n:<5} k={k:<5}: defective={df*1000:.3f}ms fixed={fx*1000:.3f}ms speedup={speedup:.1f}x" + print(line); lines.append(line); sys.stdout.flush() + return lines + + +if __name__ == "__main__": + run() diff --git a/defects/jitsi/bench/bench-jitsi-videobridge-0001.py b/defects/jitsi/bench/bench-jitsi-videobridge-0001.py new file mode 100644 index 000000000..07896ace5 --- /dev/null +++ b/defects/jitsi/bench/bench-jitsi-videobridge-0001.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +# bench-jitsi-videobridge-0001.py +# CWE-407: list-scan inside loop in jitsi-videobridge-0001 (generic model) +# Models O(N*k) -> O(N+k) via linear-scan membership inside a loop vs set/dict. + +import sys +import time + + +def bench_defective(n, k): + pool = list(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool: # O(k) + seen.append(x) + return time.perf_counter() - t0 + + +def bench_fixed(n, k): + pool_set = set(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool_set: # O(1) + seen.append(x) + return time.perf_counter() - t0 + + +TRIALS = 3 +CASES = [(100, 100), (500, 500), (1000, 1000), (2000, 2000)] + + +def run(): + lines = [] + header = "=== jitsi-videobridge-0001: CWE-407: list-scan inside loop in jitsi-videobridge-0001 (generic model) ===" + print(header); lines.append(header) + for n, k in CASES: + df = min(bench_defective(n, k) for _ in range(TRIALS)) + fx = min(bench_fixed(n, k) for _ in range(TRIALS)) + speedup = (df / fx) if fx > 0 else float("inf") + line = f"N={n:<5} k={k:<5}: defective={df*1000:.3f}ms fixed={fx*1000:.3f}ms speedup={speedup:.1f}x" + print(line); lines.append(line); sys.stdout.flush() + return lines + + +if __name__ == "__main__": + run() diff --git a/defects/jitsi/bench/bench-jitsi-videobridge-0002.py b/defects/jitsi/bench/bench-jitsi-videobridge-0002.py new file mode 100644 index 000000000..afa244279 --- /dev/null +++ b/defects/jitsi/bench/bench-jitsi-videobridge-0002.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +# bench-jitsi-videobridge-0002.py +# CWE-407: list-scan inside loop in jitsi-videobridge-0002 (generic model) +# Models O(N*k) -> O(N+k) via linear-scan membership inside a loop vs set/dict. + +import sys +import time + + +def bench_defective(n, k): + pool = list(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool: # O(k) + seen.append(x) + return time.perf_counter() - t0 + + +def bench_fixed(n, k): + pool_set = set(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool_set: # O(1) + seen.append(x) + return time.perf_counter() - t0 + + +TRIALS = 3 +CASES = [(100, 100), (500, 500), (1000, 1000), (2000, 2000)] + + +def run(): + lines = [] + header = "=== jitsi-videobridge-0002: CWE-407: list-scan inside loop in jitsi-videobridge-0002 (generic model) ===" + print(header); lines.append(header) + for n, k in CASES: + df = min(bench_defective(n, k) for _ in range(TRIALS)) + fx = min(bench_fixed(n, k) for _ in range(TRIALS)) + speedup = (df / fx) if fx > 0 else float("inf") + line = f"N={n:<5} k={k:<5}: defective={df*1000:.3f}ms fixed={fx*1000:.3f}ms speedup={speedup:.1f}x" + print(line); lines.append(line); sys.stdout.flush() + return lines + + +if __name__ == "__main__": + run() diff --git a/defects/jitsi/bench/bench-jitsi-videobridge-0003.py b/defects/jitsi/bench/bench-jitsi-videobridge-0003.py new file mode 100644 index 000000000..fe9395fec --- /dev/null +++ b/defects/jitsi/bench/bench-jitsi-videobridge-0003.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +# bench-jitsi-videobridge-0003.py +# CWE-407: list-scan inside loop in jitsi-videobridge-0003 (generic model) +# Models O(N*k) -> O(N+k) via linear-scan membership inside a loop vs set/dict. + +import sys +import time + + +def bench_defective(n, k): + pool = list(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool: # O(k) + seen.append(x) + return time.perf_counter() - t0 + + +def bench_fixed(n, k): + pool_set = set(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool_set: # O(1) + seen.append(x) + return time.perf_counter() - t0 + + +TRIALS = 3 +CASES = [(100, 100), (500, 500), (1000, 1000), (2000, 2000)] + + +def run(): + lines = [] + header = "=== jitsi-videobridge-0003: CWE-407: list-scan inside loop in jitsi-videobridge-0003 (generic model) ===" + print(header); lines.append(header) + for n, k in CASES: + df = min(bench_defective(n, k) for _ in range(TRIALS)) + fx = min(bench_fixed(n, k) for _ in range(TRIALS)) + speedup = (df / fx) if fx > 0 else float("inf") + line = f"N={n:<5} k={k:<5}: defective={df*1000:.3f}ms fixed={fx*1000:.3f}ms speedup={speedup:.1f}x" + print(line); lines.append(line); sys.stdout.flush() + return lines + + +if __name__ == "__main__": + run() diff --git a/defects/jitsi/bench/bench-jitsi-videobridge.py b/defects/jitsi/bench/bench-jitsi-videobridge.py new file mode 100644 index 000000000..e0eff3b2d --- /dev/null +++ b/defects/jitsi/bench/bench-jitsi-videobridge.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +# bench-jitsi-videobridge.py +# CWE-407: list-scan inside loop in jitsi-videobridge (generic model) +# Models O(N*k) -> O(N+k) via linear-scan membership inside a loop vs set/dict. + +import sys +import time + + +def bench_defective(n, k): + pool = list(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool: # O(k) + seen.append(x) + return time.perf_counter() - t0 + + +def bench_fixed(n, k): + pool_set = set(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool_set: # O(1) + seen.append(x) + return time.perf_counter() - t0 + + +TRIALS = 3 +CASES = [(100, 100), (500, 500), (1000, 1000), (2000, 2000)] + + +def run(): + lines = [] + header = "=== jitsi-videobridge: CWE-407: list-scan inside loop in jitsi-videobridge (generic model) ===" + print(header); lines.append(header) + for n, k in CASES: + df = min(bench_defective(n, k) for _ in range(TRIALS)) + fx = min(bench_fixed(n, k) for _ in range(TRIALS)) + speedup = (df / fx) if fx > 0 else float("inf") + line = f"N={n:<5} k={k:<5}: defective={df*1000:.3f}ms fixed={fx*1000:.3f}ms speedup={speedup:.1f}x" + print(line); lines.append(line); sys.stdout.flush() + return lines + + +if __name__ == "__main__": + run() diff --git a/defects/jitsi/bench/results.txt b/defects/jitsi/bench/results.txt new file mode 100644 index 000000000..b5af75c61 --- /dev/null +++ b/defects/jitsi/bench/results.txt @@ -0,0 +1,48 @@ +=== jitsi-meet-0001-0001: CWE-407: list-scan inside loop in jitsi-meet-0001-0001 (generic model) === +N=100 k=100 : defective=0.057ms fixed=0.002ms speedup=24.9x +N=500 k=500 : defective=1.422ms fixed=0.013ms speedup=110.4x +N=1000 k=1000 : defective=5.577ms fixed=0.029ms speedup=191.8x +N=2000 k=2000 : defective=22.697ms fixed=0.062ms speedup=368.9x + +=== jitsi-meet-0002-0002: CWE-407: list-scan inside loop in jitsi-meet-0002-0002 (generic model) === +N=100 k=100 : defective=0.054ms fixed=0.002ms speedup=25.3x +N=500 k=500 : defective=1.342ms fixed=0.013ms speedup=105.0x +N=1000 k=1000 : defective=5.569ms fixed=0.030ms speedup=188.1x +N=2000 k=2000 : defective=22.706ms fixed=0.062ms speedup=366.8x + +=== jitsi-meet-0003-0003: CWE-407: list-scan inside loop in jitsi-meet-0003-0003 (generic model) === +N=100 k=100 : defective=0.054ms fixed=0.002ms speedup=25.0x +N=500 k=500 : defective=1.351ms fixed=0.013ms speedup=104.1x +N=1000 k=1000 : defective=6.173ms fixed=0.048ms speedup=127.9x +N=2000 k=2000 : defective=22.510ms fixed=0.063ms speedup=358.3x + +=== jitsi-meet-0004-0004: CWE-407: list-scan inside loop in jitsi-meet-0004-0004 (generic model) === +N=100 k=100 : defective=0.054ms fixed=0.002ms speedup=24.6x +N=500 k=500 : defective=1.353ms fixed=0.013ms speedup=104.7x +N=1000 k=1000 : defective=5.578ms fixed=0.029ms speedup=189.8x +N=2000 k=2000 : defective=23.193ms fixed=0.062ms speedup=375.6x + +=== jitsi-videobridge-0001: CWE-407: list-scan inside loop in jitsi-videobridge-0001 (generic model) === +N=100 k=100 : defective=0.054ms fixed=0.002ms speedup=24.3x +N=500 k=500 : defective=1.361ms fixed=0.013ms speedup=103.6x +N=1000 k=1000 : defective=5.537ms fixed=0.029ms speedup=190.2x +N=2000 k=2000 : defective=22.613ms fixed=0.062ms speedup=365.5x + +=== jitsi-videobridge-0002: CWE-407: list-scan inside loop in jitsi-videobridge-0002 (generic model) === +N=100 k=100 : defective=0.054ms fixed=0.002ms speedup=24.5x +N=500 k=500 : defective=1.352ms fixed=0.013ms speedup=101.3x +N=1000 k=1000 : defective=5.496ms fixed=0.029ms speedup=186.9x +N=2000 k=2000 : defective=22.793ms fixed=0.223ms speedup=102.0x + +=== jitsi-videobridge-0003: CWE-407: list-scan inside loop in jitsi-videobridge-0003 (generic model) === +N=100 k=100 : defective=0.054ms fixed=0.002ms speedup=24.3x +N=500 k=500 : defective=1.372ms fixed=0.013ms speedup=104.9x +N=1000 k=1000 : defective=5.548ms fixed=0.030ms speedup=184.6x +N=2000 k=2000 : defective=22.699ms fixed=0.061ms speedup=369.3x + +=== jitsi-videobridge: CWE-407: list-scan inside loop in jitsi-videobridge (generic model) === +N=100 k=100 : defective=0.054ms fixed=0.002ms speedup=25.3x +N=500 k=500 : defective=1.362ms fixed=0.013ms speedup=107.5x +N=1000 k=1000 : defective=5.989ms fixed=0.030ms speedup=199.0x +N=2000 k=2000 : defective=22.904ms fixed=0.061ms speedup=374.5x + diff --git a/defects/jitsi/bench/run_all.py b/defects/jitsi/bench/run_all.py new file mode 100644 index 000000000..51c4e7295 --- /dev/null +++ b/defects/jitsi/bench/run_all.py @@ -0,0 +1,22 @@ +#!/usr/bin/env python3 +import importlib.util, os, sys +BENCH_DIR = os.path.dirname(os.path.abspath(__file__)) + +def load_module(filename): + path = os.path.join(BENCH_DIR, filename) + spec = importlib.util.spec_from_file_location("mod", path) + mod = importlib.util.module_from_spec(spec) + spec.loader.exec_module(mod) + return mod + +all_lines = [] +for fname in ["bench-jitsi-meet-0001-0001.py", "bench-jitsi-meet-0002-0002.py", "bench-jitsi-meet-0003-0003.py", "bench-jitsi-meet-0004-0004.py", "bench-jitsi-videobridge-0001.py", "bench-jitsi-videobridge-0002.py", "bench-jitsi-videobridge-0003.py", "bench-jitsi-videobridge.py"]: + mod = load_module(fname) + lines = mod.run() + all_lines.extend(lines); all_lines.append("") + print(); sys.stdout.flush() + +out_path = os.path.join(BENCH_DIR, "results.txt") +with open(out_path, "w") as f: + f.write("\n".join(all_lines) + "\n") +print(f"results written to {out_path}"); sys.stdout.flush() diff --git a/defects/netbsd/Makefile b/defects/netbsd/Makefile new file mode 100644 index 000000000..125b5b8f6 --- /dev/null +++ b/defects/netbsd/Makefile @@ -0,0 +1,6 @@ +.PHONY: all bench clean +all: bench +bench: + python3 bench/run_all.py +clean: + rm -rf bench/__pycache__ __pycache__ diff --git a/defects/netbsd/bench/bench-netbsd-0001.py b/defects/netbsd/bench/bench-netbsd-0001.py new file mode 100644 index 000000000..cc0052a7a --- /dev/null +++ b/defects/netbsd/bench/bench-netbsd-0001.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +# bench-netbsd-0001.py +# CWE-407: list-scan inside loop in netbsd-0001 (generic model) +# Models O(N*k) -> O(N+k) via linear-scan membership inside a loop vs set/dict. + +import sys +import time + + +def bench_defective(n, k): + pool = list(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool: # O(k) + seen.append(x) + return time.perf_counter() - t0 + + +def bench_fixed(n, k): + pool_set = set(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool_set: # O(1) + seen.append(x) + return time.perf_counter() - t0 + + +TRIALS = 3 +CASES = [(100, 100), (500, 500), (1000, 1000), (2000, 2000)] + + +def run(): + lines = [] + header = "=== netbsd-0001: CWE-407: list-scan inside loop in netbsd-0001 (generic model) ===" + print(header); lines.append(header) + for n, k in CASES: + df = min(bench_defective(n, k) for _ in range(TRIALS)) + fx = min(bench_fixed(n, k) for _ in range(TRIALS)) + speedup = (df / fx) if fx > 0 else float("inf") + line = f"N={n:<5} k={k:<5}: defective={df*1000:.3f}ms fixed={fx*1000:.3f}ms speedup={speedup:.1f}x" + print(line); lines.append(line); sys.stdout.flush() + return lines + + +if __name__ == "__main__": + run() diff --git a/defects/netbsd/bench/bench-netbsd-0002.py b/defects/netbsd/bench/bench-netbsd-0002.py new file mode 100644 index 000000000..3b05adebc --- /dev/null +++ b/defects/netbsd/bench/bench-netbsd-0002.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +# bench-netbsd-0002.py +# CWE-407: list-scan inside loop in netbsd-0002 (generic model) +# Models O(N*k) -> O(N+k) via linear-scan membership inside a loop vs set/dict. + +import sys +import time + + +def bench_defective(n, k): + pool = list(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool: # O(k) + seen.append(x) + return time.perf_counter() - t0 + + +def bench_fixed(n, k): + pool_set = set(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool_set: # O(1) + seen.append(x) + return time.perf_counter() - t0 + + +TRIALS = 3 +CASES = [(100, 100), (500, 500), (1000, 1000), (2000, 2000)] + + +def run(): + lines = [] + header = "=== netbsd-0002: CWE-407: list-scan inside loop in netbsd-0002 (generic model) ===" + print(header); lines.append(header) + for n, k in CASES: + df = min(bench_defective(n, k) for _ in range(TRIALS)) + fx = min(bench_fixed(n, k) for _ in range(TRIALS)) + speedup = (df / fx) if fx > 0 else float("inf") + line = f"N={n:<5} k={k:<5}: defective={df*1000:.3f}ms fixed={fx*1000:.3f}ms speedup={speedup:.1f}x" + print(line); lines.append(line); sys.stdout.flush() + return lines + + +if __name__ == "__main__": + run() diff --git a/defects/netbsd/bench/bench-netbsd-0003.py b/defects/netbsd/bench/bench-netbsd-0003.py new file mode 100644 index 000000000..fbd680a86 --- /dev/null +++ b/defects/netbsd/bench/bench-netbsd-0003.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +# bench-netbsd-0003.py +# CWE-407: list-scan inside loop in netbsd-0003 (generic model) +# Models O(N*k) -> O(N+k) via linear-scan membership inside a loop vs set/dict. + +import sys +import time + + +def bench_defective(n, k): + pool = list(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool: # O(k) + seen.append(x) + return time.perf_counter() - t0 + + +def bench_fixed(n, k): + pool_set = set(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool_set: # O(1) + seen.append(x) + return time.perf_counter() - t0 + + +TRIALS = 3 +CASES = [(100, 100), (500, 500), (1000, 1000), (2000, 2000)] + + +def run(): + lines = [] + header = "=== netbsd-0003: CWE-407: list-scan inside loop in netbsd-0003 (generic model) ===" + print(header); lines.append(header) + for n, k in CASES: + df = min(bench_defective(n, k) for _ in range(TRIALS)) + fx = min(bench_fixed(n, k) for _ in range(TRIALS)) + speedup = (df / fx) if fx > 0 else float("inf") + line = f"N={n:<5} k={k:<5}: defective={df*1000:.3f}ms fixed={fx*1000:.3f}ms speedup={speedup:.1f}x" + print(line); lines.append(line); sys.stdout.flush() + return lines + + +if __name__ == "__main__": + run() diff --git a/defects/netbsd/bench/bench-netbsd-0004.py b/defects/netbsd/bench/bench-netbsd-0004.py new file mode 100644 index 000000000..6bcdfc9e1 --- /dev/null +++ b/defects/netbsd/bench/bench-netbsd-0004.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +# bench-netbsd-0004.py +# CWE-407: list-scan inside loop in netbsd-0004 (generic model) +# Models O(N*k) -> O(N+k) via linear-scan membership inside a loop vs set/dict. + +import sys +import time + + +def bench_defective(n, k): + pool = list(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool: # O(k) + seen.append(x) + return time.perf_counter() - t0 + + +def bench_fixed(n, k): + pool_set = set(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool_set: # O(1) + seen.append(x) + return time.perf_counter() - t0 + + +TRIALS = 3 +CASES = [(100, 100), (500, 500), (1000, 1000), (2000, 2000)] + + +def run(): + lines = [] + header = "=== netbsd-0004: CWE-407: list-scan inside loop in netbsd-0004 (generic model) ===" + print(header); lines.append(header) + for n, k in CASES: + df = min(bench_defective(n, k) for _ in range(TRIALS)) + fx = min(bench_fixed(n, k) for _ in range(TRIALS)) + speedup = (df / fx) if fx > 0 else float("inf") + line = f"N={n:<5} k={k:<5}: defective={df*1000:.3f}ms fixed={fx*1000:.3f}ms speedup={speedup:.1f}x" + print(line); lines.append(line); sys.stdout.flush() + return lines + + +if __name__ == "__main__": + run() diff --git a/defects/netbsd/bench/results.txt b/defects/netbsd/bench/results.txt new file mode 100644 index 000000000..3ef7f12a9 --- /dev/null +++ b/defects/netbsd/bench/results.txt @@ -0,0 +1,24 @@ +=== netbsd-0001: CWE-407: list-scan inside loop in netbsd-0001 (generic model) === +N=100 k=100 : defective=0.057ms fixed=0.002ms speedup=24.4x +N=500 k=500 : defective=1.443ms fixed=0.013ms speedup=108.7x +N=1000 k=1000 : defective=5.547ms fixed=0.029ms speedup=188.7x +N=2000 k=2000 : defective=22.993ms fixed=0.061ms speedup=376.7x + +=== netbsd-0002: CWE-407: list-scan inside loop in netbsd-0002 (generic model) === +N=100 k=100 : defective=0.054ms fixed=0.002ms speedup=24.2x +N=500 k=500 : defective=1.351ms fixed=0.013ms speedup=103.8x +N=1000 k=1000 : defective=5.741ms fixed=0.030ms speedup=191.7x +N=2000 k=2000 : defective=23.811ms fixed=0.061ms speedup=387.8x + +=== netbsd-0003: CWE-407: list-scan inside loop in netbsd-0003 (generic model) === +N=100 k=100 : defective=0.054ms fixed=0.002ms speedup=24.8x +N=500 k=500 : defective=1.344ms fixed=0.013ms speedup=102.2x +N=1000 k=1000 : defective=5.585ms fixed=0.029ms speedup=194.7x +N=2000 k=2000 : defective=22.596ms fixed=0.061ms speedup=368.7x + +=== netbsd-0004: CWE-407: list-scan inside loop in netbsd-0004 (generic model) === +N=100 k=100 : defective=0.054ms fixed=0.002ms speedup=24.9x +N=500 k=500 : defective=1.382ms fixed=0.013ms speedup=103.7x +N=1000 k=1000 : defective=5.682ms fixed=0.029ms speedup=193.3x +N=2000 k=2000 : defective=23.174ms fixed=0.062ms speedup=371.0x + diff --git a/defects/netbsd/bench/run_all.py b/defects/netbsd/bench/run_all.py new file mode 100644 index 000000000..d12052c29 --- /dev/null +++ b/defects/netbsd/bench/run_all.py @@ -0,0 +1,22 @@ +#!/usr/bin/env python3 +import importlib.util, os, sys +BENCH_DIR = os.path.dirname(os.path.abspath(__file__)) + +def load_module(filename): + path = os.path.join(BENCH_DIR, filename) + spec = importlib.util.spec_from_file_location("mod", path) + mod = importlib.util.module_from_spec(spec) + spec.loader.exec_module(mod) + return mod + +all_lines = [] +for fname in ["bench-netbsd-0001.py", "bench-netbsd-0002.py", "bench-netbsd-0003.py", "bench-netbsd-0004.py"]: + mod = load_module(fname) + lines = mod.run() + all_lines.extend(lines); all_lines.append("") + print(); sys.stdout.flush() + +out_path = os.path.join(BENCH_DIR, "results.txt") +with open(out_path, "w") as f: + f.write("\n".join(all_lines) + "\n") +print(f"results written to {out_path}"); sys.stdout.flush() diff --git a/defects/regamedll-cs-0001/Makefile b/defects/regamedll-cs-0001/Makefile new file mode 100644 index 000000000..125b5b8f6 --- /dev/null +++ b/defects/regamedll-cs-0001/Makefile @@ -0,0 +1,6 @@ +.PHONY: all bench clean +all: bench +bench: + python3 bench/run_all.py +clean: + rm -rf bench/__pycache__ __pycache__ diff --git a/defects/regamedll-cs-0001/bench/bench-regamedll-cs-0001-0001.py b/defects/regamedll-cs-0001/bench/bench-regamedll-cs-0001-0001.py new file mode 100644 index 000000000..9f49870dd --- /dev/null +++ b/defects/regamedll-cs-0001/bench/bench-regamedll-cs-0001-0001.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +# bench-regamedll-cs-0001-0001.py +# CWE-407: list-scan inside loop in regamedll-cs-0001-0001 (generic model) +# Models O(N*k) -> O(N+k) via linear-scan membership inside a loop vs set/dict. + +import sys +import time + + +def bench_defective(n, k): + pool = list(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool: # O(k) + seen.append(x) + return time.perf_counter() - t0 + + +def bench_fixed(n, k): + pool_set = set(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool_set: # O(1) + seen.append(x) + return time.perf_counter() - t0 + + +TRIALS = 3 +CASES = [(100, 100), (500, 500), (1000, 1000), (2000, 2000)] + + +def run(): + lines = [] + header = "=== regamedll-cs-0001-0001: CWE-407: list-scan inside loop in regamedll-cs-0001-0001 (generic model) ===" + print(header); lines.append(header) + for n, k in CASES: + df = min(bench_defective(n, k) for _ in range(TRIALS)) + fx = min(bench_fixed(n, k) for _ in range(TRIALS)) + speedup = (df / fx) if fx > 0 else float("inf") + line = f"N={n:<5} k={k:<5}: defective={df*1000:.3f}ms fixed={fx*1000:.3f}ms speedup={speedup:.1f}x" + print(line); lines.append(line); sys.stdout.flush() + return lines + + +if __name__ == "__main__": + run() diff --git a/defects/regamedll-cs-0001/bench/results.txt b/defects/regamedll-cs-0001/bench/results.txt new file mode 100644 index 000000000..76968589c --- /dev/null +++ b/defects/regamedll-cs-0001/bench/results.txt @@ -0,0 +1,6 @@ +=== regamedll-cs-0001-0001: CWE-407: list-scan inside loop in regamedll-cs-0001-0001 (generic model) === +N=100 k=100 : defective=0.054ms fixed=0.002ms speedup=24.5x +N=500 k=500 : defective=1.374ms fixed=0.013ms speedup=104.6x +N=1000 k=1000 : defective=5.501ms fixed=0.029ms speedup=187.8x +N=2000 k=2000 : defective=22.860ms fixed=0.062ms speedup=366.6x + diff --git a/defects/regamedll-cs-0001/bench/run_all.py b/defects/regamedll-cs-0001/bench/run_all.py new file mode 100644 index 000000000..09f697d94 --- /dev/null +++ b/defects/regamedll-cs-0001/bench/run_all.py @@ -0,0 +1,22 @@ +#!/usr/bin/env python3 +import importlib.util, os, sys +BENCH_DIR = os.path.dirname(os.path.abspath(__file__)) + +def load_module(filename): + path = os.path.join(BENCH_DIR, filename) + spec = importlib.util.spec_from_file_location("mod", path) + mod = importlib.util.module_from_spec(spec) + spec.loader.exec_module(mod) + return mod + +all_lines = [] +for fname in ["bench-regamedll-cs-0001-0001.py"]: + mod = load_module(fname) + lines = mod.run() + all_lines.extend(lines); all_lines.append("") + print(); sys.stdout.flush() + +out_path = os.path.join(BENCH_DIR, "results.txt") +with open(out_path, "w") as f: + f.write("\n".join(all_lines) + "\n") +print(f"results written to {out_path}"); sys.stdout.flush() diff --git a/defects/supertuxkart-0002/Makefile b/defects/supertuxkart-0002/Makefile new file mode 100644 index 000000000..125b5b8f6 --- /dev/null +++ b/defects/supertuxkart-0002/Makefile @@ -0,0 +1,6 @@ +.PHONY: all bench clean +all: bench +bench: + python3 bench/run_all.py +clean: + rm -rf bench/__pycache__ __pycache__ diff --git a/defects/supertuxkart-0002/bench/bench-supertuxkart-0002-0002.py b/defects/supertuxkart-0002/bench/bench-supertuxkart-0002-0002.py new file mode 100644 index 000000000..46819f7f4 --- /dev/null +++ b/defects/supertuxkart-0002/bench/bench-supertuxkart-0002-0002.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +# bench-supertuxkart-0002-0002.py +# CWE-407: list-scan inside loop in supertuxkart-0002-0002 (generic model) +# Models O(N*k) -> O(N+k) via linear-scan membership inside a loop vs set/dict. + +import sys +import time + + +def bench_defective(n, k): + pool = list(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool: # O(k) + seen.append(x) + return time.perf_counter() - t0 + + +def bench_fixed(n, k): + pool_set = set(range(k)) + items = list(range(n)) + t0 = time.perf_counter() + seen = [] + for x in items: + if x not in pool_set: # O(1) + seen.append(x) + return time.perf_counter() - t0 + + +TRIALS = 3 +CASES = [(100, 100), (500, 500), (1000, 1000), (2000, 2000)] + + +def run(): + lines = [] + header = "=== supertuxkart-0002-0002: CWE-407: list-scan inside loop in supertuxkart-0002-0002 (generic model) ===" + print(header); lines.append(header) + for n, k in CASES: + df = min(bench_defective(n, k) for _ in range(TRIALS)) + fx = min(bench_fixed(n, k) for _ in range(TRIALS)) + speedup = (df / fx) if fx > 0 else float("inf") + line = f"N={n:<5} k={k:<5}: defective={df*1000:.3f}ms fixed={fx*1000:.3f}ms speedup={speedup:.1f}x" + print(line); lines.append(line); sys.stdout.flush() + return lines + + +if __name__ == "__main__": + run() diff --git a/defects/supertuxkart-0002/bench/results.txt b/defects/supertuxkart-0002/bench/results.txt new file mode 100644 index 000000000..c1a3bd2bc --- /dev/null +++ b/defects/supertuxkart-0002/bench/results.txt @@ -0,0 +1,6 @@ +=== supertuxkart-0002-0002: CWE-407: list-scan inside loop in supertuxkart-0002-0002 (generic model) === +N=100 k=100 : defective=0.059ms fixed=0.002ms speedup=24.7x +N=500 k=500 : defective=1.503ms fixed=0.014ms speedup=104.1x +N=1000 k=1000 : defective=5.790ms fixed=0.029ms speedup=201.5x +N=2000 k=2000 : defective=23.911ms fixed=0.063ms speedup=382.3x + diff --git a/defects/supertuxkart-0002/bench/run_all.py b/defects/supertuxkart-0002/bench/run_all.py new file mode 100644 index 000000000..6bc70076c --- /dev/null +++ b/defects/supertuxkart-0002/bench/run_all.py @@ -0,0 +1,22 @@ +#!/usr/bin/env python3 +import importlib.util, os, sys +BENCH_DIR = os.path.dirname(os.path.abspath(__file__)) + +def load_module(filename): + path = os.path.join(BENCH_DIR, filename) + spec = importlib.util.spec_from_file_location("mod", path) + mod = importlib.util.module_from_spec(spec) + spec.loader.exec_module(mod) + return mod + +all_lines = [] +for fname in ["bench-supertuxkart-0002-0002.py"]: + mod = load_module(fname) + lines = mod.run() + all_lines.extend(lines); all_lines.append("") + print(); sys.stdout.flush() + +out_path = os.path.join(BENCH_DIR, "results.txt") +with open(out_path, "w") as f: + f.write("\n".join(all_lines) + "\n") +print(f"results written to {out_path}"); sys.stdout.flush()