Prep for tester parallel: private nimcache for each test (#6937)

* Compile tester with --opt:speed

This makes "tester html" substantially faster

* Use a private nimcache for each test

This allows reusing the cache between test runs. It is also prep for parallel
testing within a single category (#6913)

koch.nim

@@ -441,7 +441,7 @@ template `|`(a, b): string = (if a.len > 0: a else: b)
 proc tests(args: string) =
   # we compile the tester with taintMode:on to have a basic
   # taint mode test :-)
-  nimexec "cc --taintMode:on tests/testament/tester"
+  nimexec "cc --taintMode:on --opt:speed tests/testament/tester"
   # Since tests take a long time (on my machine), and we want to defy Murhpys
   # law - lets make sure the compiler really is freshly compiled!
   nimexec "c --lib:lib -d:release --opt:speed compiler/nim.nim"

tests/testament/categories.nim

@@ -15,58 +15,52 @@
 
 const
   rodfilesDir = "tests/rodfiles"
-  nimcacheDir = rodfilesDir / "nimcache"
 
-proc delNimCache() =
+proc delNimCache(filename, options: string) =
+  let dir = nimcacheDir(filename, options)
   try:
-    removeDir(nimcacheDir)
+    removeDir(dir)
   except OSError:
-    echo "[Warning] could not delete: ", nimcacheDir
+    echo "[Warning] could not delete: ", dir
 
 proc runRodFiles(r: var TResults, cat: Category, options: string) =
-  template test(filename: untyped) =
+  template test(filename: string, clearCacheFirst=false) =
+    if clearCacheFirst: delNimCache(filename, options)
     testSpec r, makeTest(rodfilesDir / filename, options, cat, actionRun)
 
-  delNimCache()
 
   # test basic recompilation scheme:
-  test "hallo"
+  test "hallo", true
   test "hallo"
   when false:
     # test incremental type information:
     test "hallo2"
-    delNimCache()
 
   # test type converters:
-  test "aconv"
+  test "aconv", true
   test "bconv"
-  delNimCache()
 
   # test G, A, B example from the documentation; test init sections:
-  test "deada"
+  test "deada", true
   test "deada2"
-  delNimCache()
 
   when false:
     # test method generation:
-    test "bmethods"
+    test "bmethods", true
     test "bmethods2"
-    delNimCache()
 
     # test generics:
-    test "tgeneric1"
+    test "tgeneric1", true
     test "tgeneric2"
-    delNimCache()
 
 proc compileRodFiles(r: var TResults, cat: Category, options: string) =
-  template test(filename: untyped) =
+  template test(filename: untyped, clearCacheFirst=true) =
+    if clearCacheFirst: delNimCache(filename, options)
     testSpec r, makeTest(rodfilesDir / filename, options, cat)
 
-  delNimCache()
   # test DLL interfacing:
-  test "gtkex1"
+  test "gtkex1", true
   test "gtkex2"
-  delNimCache()
 
 # --------------------- DLL generation tests ----------------------------------
 

tests/testament/tester.nim

@@ -12,7 +12,7 @@
 import
   parseutils, strutils, pegs, os, osproc, streams, parsecfg, json,
   marshal, backend, parseopt, specs, htmlgen, browsers, terminal,
-  algorithm, compiler/nodejs, times, sets
+  algorithm, compiler/nodejs, times, sets, md5
 
 const
   resultsFile = "testresults.html"
@@ -71,8 +71,14 @@ proc getFileDir(filename: string): string =
   if not result.isAbsolute():
     result = getCurrentDir() / result
 
+proc nimcacheDir(filename, options: string): string =
+  ## Give each test a private nimcache dir so they don't clobber each other's.
+  return "nimcache" / (filename & '_' & options.getMD5)
+
 proc callCompiler(cmdTemplate, filename, options: string,
-                  target: TTarget): TSpec =
+                  target: TTarget, extraOptions=""): TSpec =
+  let nimcache = nimcacheDir(filename, options)
+  let options = options & " --nimCache:" & nimcache.quoteShell & extraOptions
   let c = parseCmdLine(cmdTemplate % ["target", targetToCmd[target],
                        "options", options, "file", filename.quoteShell,
                        "filedir", filename.getFileDir()])
@@ -222,9 +228,10 @@ proc cmpMsgs(r: var TResults, expected, given: TSpec, test: TTest, target: TTarg
     r.addResult(test, target, expected.msg, given.msg, reSuccess)
     inc(r.passed)
 
-proc generatedFile(path, name: string, target: TTarget): string =
+proc generatedFile(test: TTest, target: TTarget): string =
+  let (_, name, _) = test.name.splitFile
   let ext = targetToExt[target]
-  result = path / "nimcache" /
+  result = nimcacheDir(test.name, test.options) /
     (if target == targetJS: "" else: "compiler_") &
     name.changeFileExt(ext)
 
@@ -234,8 +241,7 @@ proc needsCodegenCheck(spec: TSpec): bool =
 proc codegenCheck(test: TTest, target: TTarget, spec: TSpec, expectedMsg: var string,
                   given: var TSpec) =
   try:
-    let (path, name, _) = test.name.splitFile
+    let genFile = generatedFile(test, target)
-    let genFile = generatedFile(path, name, target)
     let contents = readFile(genFile).string
     let check = spec.ccodeCheck
     if check.len > 0:
@@ -325,9 +331,8 @@ proc testSpec(r: var TResults, test: TTest, target = targetC) =
 
     case expected.action
     of actionCompile:
-      var given = callCompiler(expected.cmd, test.name,
+      var given = callCompiler(expected.cmd, test.name, test.options, target,
-        test.options & " --stdout --hint[Path]:off --hint[Processing]:off",
+        extraOptions=" --stdout --hint[Path]:off --hint[Processing]:off")
-        target)
       compilerOutputTests(test, target, given, expected, r)
     of actionRun, actionRunNoSpec:
       # In this branch of code "early return" pattern is clearer than deep
@@ -342,8 +347,8 @@ proc testSpec(r: var TResults, test: TTest, target = targetC) =
       let isJsTarget = target == targetJS
       var exeFile: string
       if isJsTarget:
-        let (dir, file, _) = splitFile(tname)
+        let (_, file, _) = splitFile(tname)
-        exeFile = dir / "nimcache" / file & ".js" # *TODO* hardcoded "nimcache"
+        exeFile = nimcacheDir(test.name, test.options) / file & ".js"
       else:
         exeFile = changeFileExt(tname, ExeExt)