guldo-cli 0.1.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (134) hide show
  1. guldo/__init__.py +0 -0
  2. guldo/_src/COMPILER.md +329 -0
  3. guldo/_src/DEPLOY.md +200 -0
  4. guldo/_src/LAUNCH.md +85 -0
  5. guldo/_src/PROTOCOL.md +294 -0
  6. guldo/_src/RULES.md +25 -0
  7. guldo/_src/SUBMIT.md +170 -0
  8. guldo/_src/__init__.py +0 -0
  9. guldo/_src/attest.py +257 -0
  10. guldo/_src/build_site.py +958 -0
  11. guldo/_src/bundle_templates/check.py +1382 -0
  12. guldo/_src/bundle_templates/qcheck.py +253 -0
  13. guldo/_src/bundle_templates/qscore.py +402 -0
  14. guldo/_src/bundle_templates/score.py +649 -0
  15. guldo/_src/certificate.py +828 -0
  16. guldo/_src/certs_site.py +108 -0
  17. guldo/_src/claims.py +343 -0
  18. guldo/_src/compile_domain.py +1312 -0
  19. guldo/_src/compile_quality.py +286 -0
  20. guldo/_src/count_runner.py +248 -0
  21. guldo/_src/counted.py +274 -0
  22. guldo/_src/declared.py +215 -0
  23. guldo/_src/deploy/Caddyfile +48 -0
  24. guldo/_src/deploy/ledger-backup.service +9 -0
  25. guldo/_src/deploy/ledger-backup.sh +73 -0
  26. guldo/_src/deploy/ledger-backup.timer +10 -0
  27. guldo/_src/deploy/ledger-export.service +12 -0
  28. guldo/_src/deploy/ledger-export.timer +9 -0
  29. guldo/_src/deploy/ledger-web.service +38 -0
  30. guldo/_src/deploy/pin_cpu.sh +34 -0
  31. guldo/_src/deploy/provision_eval.sh +128 -0
  32. guldo/_src/deploy_smoke.py +148 -0
  33. guldo/_src/dlog_experiment.py +165 -0
  34. guldo/_src/domains/aidecode/compiled.json +586 -0
  35. guldo/_src/domains/aidecode/decl.py +134 -0
  36. guldo/_src/domains/aidecode/reference.py +73 -0
  37. guldo/_src/domains/aiinfer/compiled.json +722 -0
  38. guldo/_src/domains/aiinfer/decl.py +91 -0
  39. guldo/_src/domains/aiinfer/reference.py +42 -0
  40. guldo/_src/domains/dlog/compiled.json +248 -0
  41. guldo/_src/domains/dlog/decl.py +41 -0
  42. guldo/_src/domains/dlog/reference.py +10 -0
  43. guldo/_src/domains/maxcut/compiled.json +291 -0
  44. guldo/_src/domains/maxcut/decl.py +46 -0
  45. guldo/_src/domains/maxcut/reference.py +16 -0
  46. guldo/_src/drift_check.py +89 -0
  47. guldo/_src/export_bundle.py +750 -0
  48. guldo/_src/extrapolate.py +326 -0
  49. guldo/_src/families.py +53 -0
  50. guldo/_src/gen_cheat_table.py +36 -0
  51. guldo/_src/gpu_meter.py +634 -0
  52. guldo/_src/gpu_runner.py +63 -0
  53. guldo/_src/harness.py +273 -0
  54. guldo/_src/instances.py +86 -0
  55. guldo/_src/instances_factor.py +40 -0
  56. guldo/_src/instances_mlwe.py +69 -0
  57. guldo/_src/judge.py +278 -0
  58. guldo/_src/limits_plan.py +158 -0
  59. guldo/_src/official.py +189 -0
  60. guldo/_src/ops.py +281 -0
  61. guldo/_src/portal.py +313 -0
  62. guldo/_src/portal_core.py +57 -0
  63. guldo/_src/power.py +174 -0
  64. guldo/_src/prereg.py +173 -0
  65. guldo/_src/public_portal.py +500 -0
  66. guldo/_src/quality_core.py +126 -0
  67. guldo/_src/recheck.py +236 -0
  68. guldo/_src/remeasure.py +88 -0
  69. guldo/_src/report_html.py +493 -0
  70. guldo/_src/results/.keep +0 -0
  71. guldo/_src/rounds.py +846 -0
  72. guldo/_src/runner.py +52 -0
  73. guldo/_src/sandbox/Dockerfile +11 -0
  74. guldo/_src/sandbox/Dockerfile.v2 +19 -0
  75. guldo/_src/sandbox/README.md +40 -0
  76. guldo/_src/sandbox/linux_selftest.py +117 -0
  77. guldo/_src/sandbox/meter.py +89 -0
  78. guldo/_src/sandbox/meter_core.py +28 -0
  79. guldo/_src/site_assets.py +176 -0
  80. guldo/_src/site_live_check.py +79 -0
  81. guldo/_src/solvers/aidecode_flops_kv.py +73 -0
  82. guldo/_src/solvers/aidecode_flops_lossy.py +73 -0
  83. guldo/_src/solvers/aidecode_flops_ref.py +64 -0
  84. guldo/_src/solvers/aidecode_kv.py +76 -0
  85. guldo/_src/solvers/aidecode_kv_f32.py +77 -0
  86. guldo/_src/solvers/aidecode_lossy.py +76 -0
  87. guldo/_src/solvers/aidecode_repeat.py +5 -0
  88. guldo/_src/solvers/aiinfer_batched.py +40 -0
  89. guldo/_src/solvers/aiinfer_f32.py +41 -0
  90. guldo/_src/solvers/aiinfer_gpu_batched.py +42 -0
  91. guldo/_src/solvers/aiinfer_gpu_ref.py +45 -0
  92. guldo/_src/solvers/aiinfer_lossy.py +42 -0
  93. guldo/_src/solvers/baseline_bkz.py +14 -0
  94. guldo/_src/solvers/cheat_lookup.py +24 -0
  95. guldo/_src/solvers/cheat_table.json +1 -0
  96. guldo/_src/solvers/cheat_table_v1_stale.json +1 -0
  97. guldo/_src/solvers/daemon_cpu_hider.py +17 -0
  98. guldo/_src/solvers/dlog_bsgs.py +19 -0
  99. guldo/_src/solvers/dlog_stride4.py +18 -0
  100. guldo/_src/solvers/egg_base.py +11 -0
  101. guldo/_src/solvers/egg_eightaxis.py +68 -0
  102. guldo/_src/solvers/egg_template.py +11 -0
  103. guldo/_src/solvers/factor_brent.py +34 -0
  104. guldo/_src/solvers/factor_floyd.py +19 -0
  105. guldo/_src/solvers/factor_trial_fast_py.py +21 -0
  106. guldo/_src/solvers/factor_trial_np.py +21 -0
  107. guldo/_src/solvers/factor_trial_py.py +12 -0
  108. guldo/_src/solvers/fixed_overhead_ref.py +21 -0
  109. guldo/_src/solvers/fork_bomb.py +18 -0
  110. guldo/_src/solvers/gpu_noop.py +6 -0
  111. guldo/_src/solvers/hostile_probe.py +36 -0
  112. guldo/_src/solvers/kill_meter.py +27 -0
  113. guldo/_src/solvers/memory_bomb.py +10 -0
  114. guldo/_src/solvers/noop.py +5 -0
  115. guldo/_src/solvers/orphan_cpu_hider.py +16 -0
  116. guldo/_src/solvers/planted_peek.py +23 -0
  117. guldo/_src/solvers/sleeping_daemon_hang.py +12 -0
  118. guldo/_src/solvers/small_n_trick.py +22 -0
  119. guldo/_src/solvers/starter_template.py +21 -0
  120. guldo/_src/solvers/stdout_flood.py +9 -0
  121. guldo/_src/solvers/tmp_fill.py +10 -0
  122. guldo/_src/solvers/tuned_bkz.py +25 -0
  123. guldo/_src/static_check.py +214 -0
  124. guldo/_src/submit_check.py +166 -0
  125. guldo/_src/svp.py +889 -0
  126. guldo/_src/tensorops.py +304 -0
  127. guldo/_src/tflops.py +453 -0
  128. guldo/_src/tflops_runner.py +134 -0
  129. guldo/cli.py +60 -0
  130. guldo_cli-0.1.0.dist-info/METADATA +30 -0
  131. guldo_cli-0.1.0.dist-info/RECORD +134 -0
  132. guldo_cli-0.1.0.dist-info/WHEEL +5 -0
  133. guldo_cli-0.1.0.dist-info/entry_points.txt +2 -0
  134. guldo_cli-0.1.0.dist-info/top_level.txt +1 -0
@@ -0,0 +1,291 @@
1
+ {
2
+ "compiled_at": "2026-11-21T18:37:23Z",
3
+ "compiler_sha256": "d8d6d8d7fe4f039a849630ce9ef477ce82c016ba4345d0e6c455d6d00d5f4b1b",
4
+ "decl_sha256": "b90531dcb8e42c6561a669944c02c9a7a73c553517a06940122db165da83a026",
5
+ "dims": [
6
+ 60,
7
+ 120,
8
+ 180,
9
+ 240,
10
+ 300
11
+ ],
12
+ "format": "svp-compiled-v1",
13
+ "kind": "quality",
14
+ "name": "maxcut",
15
+ "official": {
16
+ "budget": 5.0,
17
+ "n": 12
18
+ },
19
+ "practice_dims": [
20
+ 60,
21
+ 120
22
+ ],
23
+ "quality": {
24
+ "budget": 5.0,
25
+ "cpu_hours": {
26
+ "reference_expected": 0.0,
27
+ "worst_case": 0.5
28
+ },
29
+ "headroom_mean_cap": 0.95,
30
+ "min_gain": 0.02,
31
+ "notes": [],
32
+ "power": {
33
+ "boot": 60,
34
+ "curve": {
35
+ "0.0": {
36
+ "all_seeds": 0.0,
37
+ "single": 0.0
38
+ },
39
+ "0.01": {
40
+ "all_seeds": 0.0,
41
+ "single": 0.0
42
+ },
43
+ "0.02": {
44
+ "all_seeds": 0.0,
45
+ "single": 0.1
46
+ },
47
+ "0.03": {
48
+ "all_seeds": 0.933,
49
+ "single": 0.978
50
+ },
51
+ "0.04": {
52
+ "all_seeds": 1.0,
53
+ "single": 1.0
54
+ },
55
+ "0.06": {
56
+ "all_seeds": 1.0,
57
+ "single": 1.0
58
+ },
59
+ "0.1": {
60
+ "all_seeds": 1.0,
61
+ "single": 1.0
62
+ },
63
+ "0.2": {
64
+ "all_seeds": 1.0,
65
+ "single": 1.0
66
+ }
67
+ },
68
+ "max_certifiable": 0.2,
69
+ "min_certifiable": 0.03,
70
+ "n": 12,
71
+ "noise": 0.02,
72
+ "noise_assumed": true,
73
+ "notes": [],
74
+ "target_effect": 0.04,
75
+ "target_power": 0.8,
76
+ "threshold": 0.02,
77
+ "trials": 30,
78
+ "tried": {
79
+ "12": 1.0
80
+ }
81
+ },
82
+ "profile": {
83
+ "k": 8,
84
+ "median_cpu": {
85
+ "120": 0.022,
86
+ "180": 0.024,
87
+ "240": 0.022,
88
+ "300": 0.023,
89
+ "60": 0.022
90
+ },
91
+ "seed": "svp-compiler-profile-seed-v1",
92
+ "sizes": {
93
+ "120": {
94
+ "mean": 0.8385,
95
+ "q": [
96
+ 0.8813,
97
+ 0.8377,
98
+ 0.8031,
99
+ 0.8179,
100
+ 0.8346,
101
+ 0.8512,
102
+ 0.8364,
103
+ 0.8458
104
+ ],
105
+ "sd": 0.0216,
106
+ "timeouts": 0
107
+ },
108
+ "180": {
109
+ "mean": 0.8492,
110
+ "q": [
111
+ 0.8424,
112
+ 0.8791,
113
+ 0.8083,
114
+ 0.8378,
115
+ 0.848,
116
+ 0.8643,
117
+ 0.8415,
118
+ 0.8722
119
+ ],
120
+ "sd": 0.0211,
121
+ "timeouts": 0
122
+ },
123
+ "240": {
124
+ "mean": 0.8399,
125
+ "q": [
126
+ 0.8092,
127
+ 0.8379,
128
+ 0.8886,
129
+ 0.8184,
130
+ 0.8359,
131
+ 0.8333,
132
+ 0.8469,
133
+ 0.8491
134
+ ],
135
+ "sd": 0.0223,
136
+ "timeouts": 0
137
+ },
138
+ "300": {
139
+ "mean": 0.8389,
140
+ "q": [
141
+ 0.8406,
142
+ 0.8305,
143
+ 0.8347,
144
+ 0.8273,
145
+ 0.8157,
146
+ 0.8715,
147
+ 0.8335,
148
+ 0.8571
149
+ ],
150
+ "sd": 0.0165,
151
+ "timeouts": 0
152
+ },
153
+ "60": {
154
+ "mean": 0.8519,
155
+ "q": [
156
+ 0.8526,
157
+ 0.9105,
158
+ 0.7828,
159
+ 0.8119,
160
+ 0.8743,
161
+ 0.8457,
162
+ 0.8396,
163
+ 0.898
164
+ ],
165
+ "sd": 0.0397,
166
+ "timeouts": 0
167
+ }
168
+ }
169
+ },
170
+ "simulation": {
171
+ "mean": {
172
+ "120": 0.8384845444835485,
173
+ "180": 0.8491772694158268,
174
+ "240": 0.8399086412388147,
175
+ "300": 0.8388845238608824,
176
+ "60": 0.8519361215575074
177
+ },
178
+ "sd": {
179
+ "120": 0.021623685137521137,
180
+ "180": 0.021093367667705958,
181
+ "240": 0.022288139973720335,
182
+ "300": 0.01654134107403892,
183
+ "60": 0.03972576460099539
184
+ },
185
+ "sizes": [
186
+ 60,
187
+ 120,
188
+ 180,
189
+ 240,
190
+ 300
191
+ ]
192
+ }
193
+ },
194
+ "quality_compiler_sha256": "09835f01815620f1bdd5d35865b09b79fbc8c1535fee050328caaf366e27130b",
195
+ "reference_note": "One random assignment improved by a single greedy sweep of single-node flips. Repeated local search or simulated annealing is known to beat it by several quality points within the same budget.",
196
+ "reference_sha256": "9890c58349ea75c9529a429ee1c9e431a9a79b2498644445407017290e7605ee",
197
+ "selftest": {
198
+ "controls": [
199
+ {
200
+ "check": "zero gain",
201
+ "detail": "reference vs itself credits 0.0000 (must be 0)",
202
+ "status": "pass"
203
+ },
204
+ {
205
+ "check": "never answers",
206
+ "detail": "a solver with no valid answer credits 0.0000 (must be 0)",
207
+ "status": "pass"
208
+ },
209
+ {
210
+ "check": "known gain",
211
+ "detail": "a true gain of 0.06 is credited 0.0593 (must reach 0.02)",
212
+ "status": "pass"
213
+ }
214
+ ],
215
+ "kind": "estimator controls on synthetic ladders from the profile; the exported bundle's `check.py selftest` covers the declaration itself",
216
+ "status": "pass"
217
+ },
218
+ "size_range": [
219
+ 60,
220
+ 300
221
+ ],
222
+ "size_step": 60,
223
+ "validation": [
224
+ {
225
+ "check": "declaration",
226
+ "detail": "maxcut maxcut-v1, sizes 60..300 step 60",
227
+ "status": "pass"
228
+ },
229
+ {
230
+ "check": "reference",
231
+ "detail": "reference.py",
232
+ "status": "pass"
233
+ },
234
+ {
235
+ "check": "baseline statement",
236
+ "detail": "REFERENCE_NOTE says what the reference is and what is known to beat it",
237
+ "status": "pass"
238
+ },
239
+ {
240
+ "check": "shape",
241
+ "detail": "args are JSON-serializable lists at sizes [60, 180, 300]",
242
+ "status": "pass"
243
+ },
244
+ {
245
+ "check": "determinism",
246
+ "detail": "pure in (master, size, index); 8/8 distinct indices; seed-dependent",
247
+ "status": "pass"
248
+ },
249
+ {
250
+ "check": "process purity",
251
+ "detail": "identical instances in fresh interpreters with two hash seeds",
252
+ "status": "pass"
253
+ },
254
+ {
255
+ "check": "witness",
256
+ "detail": "verify() accepts the planted witness on 12 instances; it is not in the arguments",
257
+ "status": "pass"
258
+ },
259
+ {
260
+ "check": "junk rejected",
261
+ "detail": "verify() rejected all 19 junk answers on 6 instances",
262
+ "status": "pass"
263
+ },
264
+ {
265
+ "check": "no trivial answer",
266
+ "detail": "no argument, its neighbour or the argument list verifies",
267
+ "status": "pass"
268
+ },
269
+ {
270
+ "check": "witness reuse",
271
+ "detail": "0 of 30 cross-instance witnesses accepted",
272
+ "status": "pass"
273
+ },
274
+ {
275
+ "check": "reference solves",
276
+ "detail": "solved 3 instances at each of sizes [60, 120, 180]; median cost 60: 0.001s, 120: 0.001s, 180: 0.001s",
277
+ "status": "pass"
278
+ },
279
+ {
280
+ "check": "quality settings",
281
+ "detail": "budget 5 s per instance, certification threshold 0.02 quality points",
282
+ "status": "pass"
283
+ },
284
+ {
285
+ "check": "quality range",
286
+ "detail": "finite, in [0, 1] and deterministic on 9 planted witnesses (range 1.000..1.000)",
287
+ "status": "pass"
288
+ }
289
+ ],
290
+ "version": "maxcut-v1"
291
+ }
@@ -0,0 +1,46 @@
1
+ """Declaration of a QUALITY challenge: max-cut on graphs with a planted good cut (see COMPILER.md, "Quality challenges").
2
+
3
+ A solver receives (n, edges) and returns a list of n bits (a side for every node). ANY such list is valid; the score is how many edges it cuts relative to the planted
4
+ partition's cut, capped at 1. So the question is not "who answers first" but "who finds the better cut inside the same CPU budget". The reference is a one-sweep greedy:
5
+ simulated annealing or repeated local search beats it by many points.
6
+ """
7
+ import hashlib
8
+ import hmac
9
+ import random
10
+
11
+ NAME = "maxcut"
12
+ VERSION = "maxcut-v1" # bump whenever derive() changes
13
+ SIZE_RANGE = (60, 300) # number of nodes
14
+ SIZE_STEP = 60
15
+ REFERENCE_SOLVER = "reference.py"
16
+ QUALITY_BUDGET = 5 # CPU seconds per instance, for everyone
17
+ QUALITY_MIN_GAIN = 0.02 # a mean gain of two quality points is worth certifying
18
+ DOC = "solve(n, edges): return a list of n integers, each 0 or 1 (the side of every node). The score is the number of edges cut, divided by the planted partition's cut (at most 1)."
19
+ REFERENCE_NOTE = ("One random assignment improved by a single greedy sweep of single-node flips. Repeated local search or simulated annealing is known to beat it "
20
+ "by several quality points within the same budget.")
21
+ CROSS = 0.8 # probability an edge crosses the planted partition
22
+
23
+
24
+ def derive(master: bytes, size: int, idx: int) -> dict:
25
+ rng = random.Random(hmac.new(master, f"maxcut-v1:{size}:{idx}".encode(), hashlib.sha256).digest())
26
+ side = [rng.randrange(2) for _ in range(size)]
27
+ edges = []
28
+ while len(edges) < 4 * size:
29
+ u, v = rng.randrange(size), rng.randrange(size)
30
+ if u == v:
31
+ continue
32
+ if (side[u] != side[v]) == (rng.random() < CROSS):
33
+ edges.append([u, v])
34
+ best = sum(side[u] != side[v] for u, v in edges)
35
+ return {"args": [size, edges], "planted": side, "best": best}
36
+
37
+
38
+ def verify(inst: dict, ans) -> bool:
39
+ n = inst["args"][0]
40
+ return isinstance(ans, list) and len(ans) == n and all(isinstance(b, int) and not isinstance(b, bool) and b in (0, 1) for b in ans)
41
+
42
+
43
+ def quality(inst: dict, ans) -> float:
44
+ edges = inst["args"][1]
45
+ cut = sum(ans[u] != ans[v] for u, v in edges)
46
+ return min(1.0, cut / inst["best"])
@@ -0,0 +1,16 @@
1
+ """Baseline: one random assignment, then a single greedy sweep of single-node flips."""
2
+ import random
3
+
4
+
5
+ def solve(n, edges):
6
+ rng = random.Random(12345)
7
+ side = [rng.randrange(2) for _ in range(n)]
8
+ adj = [[] for _ in range(n)]
9
+ for u, v in edges:
10
+ adj[u].append(v)
11
+ adj[v].append(u)
12
+ for u in range(n):
13
+ same = sum(side[v] == side[u] for v in adj[u])
14
+ if same > len(adj[u]) - same:
15
+ side[u] ^= 1
16
+ return side
@@ -0,0 +1,89 @@
1
+ """Does running instances concurrently change their measured CPU time? Run before trusting `harness.py --jobs K`.
2
+
3
+ python3 drift_check.py [--solver solvers/baseline_bkz.py] [--dims 62 64] [--n 6] [--jobs 4 6 8]
4
+
5
+ Runs the SAME instances once sequentially (the reference) and once per job count, then reports the paired
6
+ log2(concurrent cpu / sequential cpu): the median is the systematic bias in bits, the sd is the extra noise.
7
+ A bias under ~0.05 bits is negligible next to the 0.5-1.5 bit per-instance noise; above that, use fewer jobs.
8
+ Exit code 1 if any tested job count shows a median bias above --max-bias.
9
+ """
10
+ import argparse
11
+ import math
12
+ import os
13
+ import statistics
14
+ import sys
15
+ from concurrent.futures import ThreadPoolExecutor
16
+
17
+ import families
18
+ import harness
19
+ import instances
20
+
21
+
22
+ def run_all(solver, tasks, budget, jobs):
23
+ def work(t):
24
+ dim, idx = t
25
+ return harness.run_one(solver, families.derive("gm", instances.PRACTICE_SEED, dim, idx), budget)
26
+
27
+ with ThreadPoolExecutor(max_workers=jobs) as ex:
28
+ return list(ex.map(work, tasks))
29
+
30
+
31
+ def compare(seq, par, floor=0.05):
32
+ """Paired log2(par/seq) over instances both solved, with cost above `floor` seconds. Returns (median, sd, n)."""
33
+ v = [math.log2(p["cpu"] / s["cpu"]) for s, p in zip(seq, par)
34
+ if s["status"] == "solved" and p["status"] == "solved" and s["cpu"] > floor and p["cpu"] > floor]
35
+ if len(v) < 3:
36
+ return None, None, len(v)
37
+ return statistics.median(v), statistics.pstdev(v), len(v)
38
+
39
+
40
+ def ratio_shift(seq1, seq2, par1, par2, floor=0.05):
41
+ """What matters for credit: does the paired log2(solver1/solver2) SPEEDUP change under concurrency?
42
+ Per instance: (log2 c1/c2 under parallel) - (log2 c1/c2 sequential). Returns (median, sd, n)."""
43
+ v = []
44
+ for s1, s2, p1, p2 in zip(seq1, seq2, par1, par2):
45
+ if all(r["status"] == "solved" and r["cpu"] > floor for r in (s1, s2, p1, p2)):
46
+ v.append(math.log2(p1["cpu"] / p2["cpu"]) - math.log2(s1["cpu"] / s2["cpu"]))
47
+ if len(v) < 3:
48
+ return None, None, len(v)
49
+ return statistics.median(v), statistics.pstdev(v), len(v)
50
+
51
+
52
+ def main():
53
+ ap = argparse.ArgumentParser()
54
+ ap.add_argument("--solver2", help="a second solver: also report the shift of the SPEEDUP (solver / solver2), "
55
+ "which is what the credit uses and in which a uniform slowdown cancels")
56
+ ap.add_argument("--solver", default=os.path.join(os.path.dirname(os.path.abspath(__file__)), "solvers", "baseline_bkz.py"))
57
+ ap.add_argument("--dims", type=int, nargs="+", default=[62, 64])
58
+ ap.add_argument("--n", type=int, default=6)
59
+ ap.add_argument("--jobs", type=int, nargs="+", default=[4, 6, 8])
60
+ ap.add_argument("--budget", type=float, default=60)
61
+ ap.add_argument("--max-bias", type=float, default=0.05)
62
+ a = ap.parse_args()
63
+ solver = os.path.abspath(a.solver)
64
+ tasks = [(d, i) for d in a.dims for i in range(a.n)]
65
+ print(f"{len(tasks)} instances; machine has {os.cpu_count()} logical CPUs", flush=True)
66
+ seq = run_all(solver, tasks, a.budget, 1)
67
+ ref2 = run_all(solver, tasks, a.budget, 1) # a second sequential pass: the noise floor of the comparison itself
68
+ med, sd, n = compare(seq, ref2)
69
+ print(f"sequential vs sequential (noise floor): median {med:+.3f} bits, sd {sd:.3f}, n={n}", flush=True)
70
+ solver2 = os.path.abspath(a.solver2) if a.solver2 else None
71
+ seq2 = run_all(solver2, tasks, a.budget, 1) if solver2 else None
72
+ bad = False
73
+ for j in a.jobs:
74
+ par = run_all(solver, tasks, a.budget, j)
75
+ med, sd, n = compare(seq, par)
76
+ print(f"jobs={j:2d} vs sequential: absolute cpu time shifts by median {med:+.3f} bits, sd {sd:.3f}, n={n}", flush=True)
77
+ if solver2:
78
+ par2 = run_all(solver2, tasks, a.budget, j)
79
+ m2, s2, n2 = ratio_shift(seq, seq2, par, par2)
80
+ flag = "" if m2 is not None and abs(m2) <= a.max_bias else " <-- BIASED"
81
+ bad |= bool(flag)
82
+ print(f" SPEEDUP estimate shifts by median {m2:+.3f} bits, sd {s2:.3f}, n={n2}{flag}", flush=True)
83
+ else:
84
+ bad |= med is None or abs(med) > a.max_bias
85
+ sys.exit(1 if bad else 0)
86
+
87
+
88
+ if __name__ == "__main__":
89
+ main()