integrated realtimegc stuff into testament

tests/realtimeGC/cmain.c

@@ -21,24 +21,24 @@ int main(int argc, char* argv[])
     void* hndl;
     pFunc status;
     pFunc count;
-    pFunc occupiedMem;
+    pFunc checkOccupiedMem;
 
 #ifdef WIN
-    hndl = (void*) LoadLibrary((char const*)"./shared.dll");
+    hndl = (void*) LoadLibrary((char const*)"./tests/realtimeGC/shared.dll");
     status = (pFunc)GetProcAddress((HMODULE) hndl, (char const*)"status");
     count = (pFunc)GetProcAddress((HMODULE) hndl, (char const*)"count");
-    occupiedMem = (pFunc)GetProcAddress((HMODULE) hndl, (char const*)"occupiedMem");
+    checkOccupiedMem = (pFunc)GetProcAddress((HMODULE) hndl, (char const*)"checkOccupiedMem");
 #else /* OSX || NIX */
-    hndl = (void*) dlopen((char const*)"./libshared.so", RTLD_LAZY);
+    hndl = (void*) dlopen((char const*)"./tests/realtimeGC/libshared.so", RTLD_LAZY);
     status = (pFunc) dlsym(hndl, (char const*)"status");
     count = (pFunc) dlsym(hndl, (char const*)"count");
-    occupiedMem = (pFunc) dlsym(hndl, (char const*)"occupiedMem");
+    checkOccupiedMem = (pFunc) dlsym(hndl, (char const*)"checkOccupiedMem");
 #endif
 
     assert(hndl);
     assert(status);
     assert(count);
-    assert(occupiedMem);
+    assert(checkOccupiedMem);
 
     time_t startTime = time((time_t*)0);
     time_t runTime = (time_t)(RUNTIME);
@@ -52,9 +52,9 @@ int main(int argc, char* argv[])
             status();
         /* printf("2. sleeping...\n"); */
         sleep(1);
-        occupiedMem();
+        checkOccupiedMem();
         accumTime = time((time_t*)0) - startTime;
-        printf("--- Minutes left to run: %d\n", (int)(runTime-accumTime)/60);
+        /* printf("--- Minutes left to run: %d\n", (int)(runTime-accumTime)/60); */
     }
     printf("Cleaning up the shared object pointer...\n");
 #ifdef WIN
@@ -65,7 +65,3 @@ int main(int argc, char* argv[])
     printf("Done\n");
     return 0;
 }
-
-
-
-

tests/realtimeGC/make.bat

@@ -1,10 +0,0 @@
-
-set CXX=gcc
-set LIBS=-ldl
-set LNFLAGS=
-set CFLAGS=-DWIN
-set INC=
-
-nim c shared.nim
-nim c -o:nmain main.nim
-%CXX% %INC% %DEFS% %CFLAGS% -o cmain main.c %LNFLAGS% %LIBS%

tests/realtimeGC/nmain.nim

@@ -3,38 +3,44 @@ discard """
   output: "Done"
 """
 
-import times
-import os
+import times, os, threadpool
 
 const RUNTIME = 15 * 60 # 15 minutes
 
 when defined(windows):
-  const dllname = "./shared.dll"
+  const dllname = "./tests/realtimeGC/shared.dll"
 elif defined(macosx):
-  const dllname = "./libshared.dylib"
+  const dllname = "./tests/realtimeGC/libshared.dylib"
 else:
-  const dllname = "./libshared.so"
+  const dllname = "./tests/realtimeGC/libshared.so"
 
 proc status() {.importc: "status", dynlib: dllname.}
 proc count() {.importc: "count", dynlib: dllname.}
-proc occupiedMem() {.importc: "occupiedMem", dynlib: dllname.}
+proc checkOccupiedMem() {.importc: "checkOccupiedMem", dynlib: dllname.}
 
-proc main() =
+proc process() =
   let startTime = getTime()
   let runTime = cast[Time](RUNTIME) #
   var accumTime: Time
   while accumTime < runTime:
     for i in 0..10:
       count()
-    #echo("1. sleeping... ")
+    # echo("1. sleeping... ")
     sleep(500)
     for i in 0..10:
       status()
-    #echo("2. sleeping... ")
+    # echo("2. sleeping... ")
     sleep(500)
-    occupiedMem()
+    checkOccupiedMem()
     accumTime = cast[Time]((getTime() - startTime))
-    #echo("--- Minutes left to run: ", int(int(runTime-accumTime)/60))
+    # echo("--- Minutes left to run: ", int(int(runTime-accumTime)/60))
+
+proc main() =
+  process()
+  # parallel:
+  #   for i in 0..0:
+  #     spawn process()
+  # sync()
   echo("Done")
 
 main()

tests/realtimeGC/shared.nim

@@ -4,6 +4,8 @@ discard """
 
 import strutils
 
+# Global state, accessing with threads, no locks. Don't do this at
+# home.
 var gCounter: uint64
 var gTxStatus: bool
 var gRxStatus: bool
@@ -55,7 +57,7 @@ proc count() {.exportc: "count", dynlib.} =
   gCounter += 1
   # echo("gCounter: ", gCounter)
 
-proc occupiedMem() {.exportc: "occupiedMem", dynlib.} =
-  echo("Occupied Memmory: ", getOccupiedMem())
+proc checkOccupiedMem() {.exportc: "checkOccupiedMem", dynlib.} =
+  if getOccupiedMem() > 10_000_000:
+    quit 1
   discard
-

tests/realtimeGC/shared.nim.cfg

@@ -1,4 +1,3 @@
-
 --app:lib
 --threads:on
 

tests/testament/categories.nim

@@ -138,6 +138,18 @@ proc gcTests(r: var TResults, cat: Category, options: string) =
   test "stackrefleak"
   test "cyclecollector"
 
+proc longGCTests(r: var TResults, cat: Category, options: string) =
+  when defined(windows):
+    let cOptions = "gcc -ldl -DWIN"
+  else:
+    let cOptions = "gcc -ldl"
+
+  var c = initResults()
+  # According to ioTests, this should compile the file
+  testNoSpec c, makeTest("tests/realtimeGC/shared", options, cat, actionCompile)
+  # testC r, makeTest("tests/realtimeGC/cmain", cOptions, cat, actionRun)
+  testSpec r, makeTest("tests/realtimeGC/nmain", options & "--threads: on", cat, actionRun)
+
 # ------------------------- threading tests -----------------------------------
 
 proc threadTests(r: var TResults, cat: Category, options: string) =
@@ -340,6 +352,8 @@ proc processCategory(r: var TResults, cat: Category, options: string) =
     dllTests(r, cat, options)
   of "gc":
     gcTests(r, cat, options)
+  of "longgc":
+    longGCTests(r, cat, options)
   of "debugger":
     debuggerTests(r, cat, options)
   of "manyloc":

tests/testament/tester.nim

@@ -87,6 +87,25 @@ proc callCompiler(cmdTemplate, filename, options: string,
   elif suc =~ pegSuccess:
     result.err = reSuccess
 
+proc callCCompiler(cmdTemplate, filename, options: string,
+                  target: TTarget): TSpec =
+  let c = parseCmdLine(cmdTemplate % ["target", targetToCmd[target],
+                       "options", options, "file", filename.quoteShell])
+  var p = startProcess(command="gcc", args=c[4.. ^1],
+                       options={poStdErrToStdOut, poUsePath})
+  let outp = p.outputStream
+  var x = newStringOfCap(120)
+  result.nimout = ""
+  result.msg = ""
+  result.file = ""
+  result.outp = ""
+  result.line = -1
+  while outp.readLine(x.TaintedString) or running(p):
+    result.nimout.add(x & "\n")
+  close(p)
+  if p.peekExitCode == 0:
+    result.err = reSuccess
+
 proc initResults: TResults =
   result.total = 0
   result.passed = 0
@@ -247,8 +266,22 @@ proc testNoSpec(r: var TResults, test: TTest) =
   r.addResult(test, "", given.msg, given.err)
   if given.err == reSuccess: inc(r.passed)
 
+proc testC(r: var TResults, test: TTest) =
+  # runs C code. Doesn't support any specs, just goes by exit code.
+  let tname = test.name.addFileExt(".c")
+  inc(r.total)
+  styledEcho "Processing ", fgCyan, extractFilename(tname)
+  var given = callCCompiler(cmdTemplate, test.name & ".c", test.options, test.target)
+  if given.err != reSuccess:
+    r.addResult(test, "", given.msg, given.err)
+  elif test.action == actionRun:
+    let exeFile = changeFileExt(test.name, ExeExt)
+    var (buf, exitCode) = execCmdEx(exeFile, options = {poStdErrToStdOut, poUseShell})
+    if exitCode != 0: given.err = reExitCodesDiffer
+  if given.err == reSuccess: inc(r.passed)
+
 proc makeTest(test, options: string, cat: Category, action = actionCompile,
-              target = targetC): TTest =
+              target = targetC, env: string = ""): TTest =
   # start with 'actionCompile', will be overwritten in the spec:
   result = TTest(cat: cat, name: test, options: options,
                  target: target, action: action)