Make the heap measurement independent of where the repo is cloned

With the memory job finally running, it reported 50K against a 48K budget --
where the same command on my machine reports 47K, on the same commit and the
same interpreter.

The game was not the variable. probe() inserted the work directory into
sys.path as an absolute path, and a GitHub runner checks out to a deeper one.
A couple of hundred extra bytes at the baseline pushes a parse allocation over
a GC chunk boundary, and the reported minimum jumps three kilobytes. Measured
directly: padding the path from 38 to 87 characters moved the answer from 47K
to 50K with no other change. A bench whose answer depends on the depth of the
checkout is not measuring the program.

The probe now runs with the work directory as its cwd and touches sys.path not
at all -- MicroPython's default already starts with '' -- so the stubs are
staged next to the modules. 47K at 38, 87, 111 and 143 characters of path.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AKLqS4PgnCXrzKHDH8Cnzy

Author: softpython2884

.gitignore

@@ -10,7 +10,6 @@ build/
 tools/mp/micropython
 tools/mp/micropython-src/
 tools/mp/work/
-tools/mp/stubs/_probe.py
 pc/**/__pycache__/
 pc/.venv/
 pc/build/

docs/OPTIMIZATION.md

@@ -41,6 +41,17 @@ que personne le remarque. Epsilon n'embarque ni l'un ni l'autre, alors le build
 les désactive : la compilation passe de « à réparer à la main » à quinze
 secondes, et la mesure tourne à chaque commit.
 
+Et une fois qu'elle a tourné, elle a annoncé **50 Ko** là où la même commande
+en annonçait 47 sur cette machine. Le jeu n'y était pour rien : la sonde
+insérait le dossier de travail dans `sys.path`, en absolu. Sur un runner GitHub
+ce chemin est plus long ; quelques centaines d'octets de plus au départ, une
+allocation de l'analyseur qui franchit une frontière de bloc, et le minimum
+mesuré saute de 3 Ko. Un banc de mesure dont la réponse dépend de l'endroit où
+le dépôt est cloné ne mesure pas le programme. La sonde tourne désormais avec
+le dossier de travail pour répertoire courant — `sys.path` de MicroPython
+commence déjà par `''` — et ne manipule plus aucun chemin : 47 Ko, quelle que
+soit la profondeur du clone.
+
 Le build local est en 64 bits, donc ses pointeurs sont deux fois plus larges que
 ceux du ARM 32 bits de la calculatrice ; l'arbre syntaxique, qui est presque
 entièrement fait de pointeurs, coûte environ 1,6 fois plus ici. Le budget de

pc/README.md

@@ -117,8 +117,8 @@ le même échantillon.
 | Effet | RMS |
 |---|---|
 | Alerte boss | 0,164 |
-| Explosion | 0,041 |
 | Tir ennemi | 0,042 |
+| Explosion | 0,041 |
 | **Tir joueur** | **0,016** |
 
 ### `M` : trois crans, pas deux

tools/memcheck.py

@@ -20,6 +20,7 @@
 """
 
 import os
+import shutil
 import subprocess
 import sys
 
@@ -34,19 +35,30 @@
 
 
 def probe(heap_k, entry, workdir):
-    src = ("import kandinsky, ion, time, gc, sys\n"
-           "sys.path.insert(0, %r)\n"
+    """Import `entry` on a heap of exactly `heap_k` KB. Returns None if it did
+    not fit.
+
+    Nothing here mentions an absolute path. An earlier version inserted the
+    work directory into sys.path, which made the answer depend on how deep the
+    checkout sat: the longer string shifted the baseline by a couple of hundred
+    bytes, that pushed a parse allocation over a chunk boundary, and the
+    reported minimum jumped 3 KB. Same game, different number, depending on the
+    machine. The interpreter runs with the work directory as its own cwd
+    instead, and MicroPython's default sys.path already starts with '', so the
+    modules and the stubs are found with no path string at all.
+    """
+    src = ("import kandinsky, ion, time, gc\n"
            "gc.collect()\n"
            "b = gc.mem_free()\n"
            "import %s\n"
            "gc.collect()\n"
-           "print('OK', b - gc.mem_free(), gc.mem_free())\n" % (workdir, entry))
-    path = os.path.join(STUBS, "_probe.py")
+           "print('OK', b - gc.mem_free(), gc.mem_free())\n" % entry)
+    path = os.path.join(workdir, "_probe.py")
     with open(path, "w") as fh:
         fh.write(src)
     try:
         r = subprocess.run([MP, "-X", "heapsize=%dk" % heap_k, "_probe.py"],
-                           capture_output=True, text=True, cwd=STUBS, timeout=90)
+                           capture_output=True, text=True, cwd=workdir, timeout=90)
     except subprocess.TimeoutExpired:
         return None
     if r.stdout.startswith("OK"):
@@ -96,11 +108,15 @@ def main(argv):
     workdir = os.path.join(ROOT, "tools", "mp", "work")
     os.makedirs(workdir, exist_ok=True)
 
-    # Every dist/*.py module must be importable, so stage them all.
+    # Every dist/*.py module must be importable, so stage them all -- and the
+    # kandinsky/ion stubs beside them, since the probe imports by cwd alone.
     dist = os.path.join(ROOT, "dist")
     for f in sorted(os.listdir(dist)):
         if f.endswith(".py"):
             prepare(os.path.join(dist, f), workdir)
+    for f in sorted(os.listdir(STUBS)):
+        if f.endswith(".py") and not f.startswith("_"):
+            shutil.copyfile(os.path.join(STUBS, f), os.path.join(workdir, f))
 
     print("%-22s %8s %10s %10s %8s" %
           ("module", "bytes", "min heap", "resident", "verdict"))