Merge branch 'main' into alembic-fix

Author: bnmnetp

bookserver/internal/common_builder.py

@@ -175,7 +175,9 @@ def check_sim_out(out_list, verification_code):
     # Get lines, with fallback if they don't exist.
     second_to_last_line = sl[-2] if len(sl) >= 2 else ""
     last_line = sl[-1] if len(sl) >= 1 else ""
-    return (second_to_last_line == "Correct.") and (last_line == str(verification_code))
+    return (second_to_last_line == "Correct.") and (
+        last_line.strip() == str(verification_code)
+    )
 
 
 # Run MDB
@@ -194,7 +196,6 @@ def sim_run_mdb(
     # A path to the binary (typically in .elf format) to simulate.
     sim_binary_path,
 ):
-
     # Get or create an instance of the simulator.
     po = _tls.__dict__.get("po")
     if (
@@ -211,7 +212,7 @@ def sim_run_mdb(
             _tls.simout_path, "w+", encoding="utf-8", errors="backslashreplace"
         )
 
-        # Java, by default, doesn't free memory until it gets low, making it a memory hog. The `Java command-line flags <https://docs.oracle.com/en/java/javase/13/docs/specs/man/java.html>`_ ``-Xms750M -Xmx750M`` specify a heap size of 750 MB. However, these options must go before the ``--jar`` option when invoking ``java``, meaning they require hand edits to ``mdb.bat/sh``; they can't be passed as paramters (which are placed after ``--jar`` by ``mdb.bat/sh``). Therefore, use the `JAVA_TOOL_OPTIONS <https://docs.oracle.com/javase/8/docs/technotes/guides/troubleshoot/envvars002.html>`_ env var to pass these parameters.
+        # Java, by default, doesn't free memory until it gets low, making it a memory hog. The `Java command-line flags <https://docs.oracle.com/en/java/javase/13/docs/specs/man/java.html>`_ ``-Xms750M -Xmx750M`` specify a heap size of 750 MB. However, these options must go before the ``--jar`` option when invoking ``java``, meaning they require hand edits to ``mdb.bat/sh``; they can't be passed as parameters (which are placed after ``--jar`` by ``mdb.bat/sh``). Therefore, use the `JAVA_TOOL_OPTIONS <https://docs.oracle.com/javase/8/docs/technotes/guides/troubleshoot/envvars002.html>`_ env var to pass these parameters.
         sim_env = os.environ.copy()
         sim_env["JAVA_TOOL_OPTIONS"] = "-Xms750M -Xmx750M"
         # Start the simulator.
@@ -256,7 +257,8 @@ def on_exit():
     end_time = time.time() + 15
     output = []
     while time.time() < end_time:
-        if po.poll() is None:
+        # If the process terminates (a not-``None`` return value), read the last output then exit the loop.
+        if po.poll() is not None:
             output.append(po.communicate()[0])
             break
         line = po.stdout.readline()

bookserver/internal/feedback.py

@@ -276,6 +276,9 @@ def _platform_edit(
     elif ext == ".rs":
         # Rust doesn't support `setting line numbers <https://github.com/rust-lang/rfcs/issues/1862>`__ either.
         fmt = ""
+    elif ext == ".v":
+        # Quoting from section 19.7 of the IEEE Standard for Verilog Hardware Description Language (IEEE Std 1364-2005), the syntax for this compiler directive is ```line number "filename" level``, where ``level == 0`` indicates that this line doesn't precede or follow an include directive.
+        fmt = '`line 1 "box {}" 0\n'
     else:
         # This is an unsupported language. It would be nice to report this as an error instead of raising an exception.
         raise RuntimeError("Unsupported extension {}".format(ext))

bookserver/internal/scheduled_builder.py

@@ -86,6 +86,7 @@ def _scheduled_builder(
         "rust": rust_builder,
         "pic24-xc16-bullylib": xc16_builder,
         "armv7-newlib-sim": armv7_builder,
+        "verilog": verilog_builder,
     }.get(builder, None)
     if builder_func is None:
         raise RuntimeError(f"Unknown builder {builder}")
@@ -197,21 +198,21 @@ def copy_test_file_to_tmp(
     return test_file_name
 
 
-# Given an list of arguments to pass as the first parameter of ``subprocess.run``, wrap this in runguard. Return an updates list of parameters for ``subprocess.run``.
+# Given an list of arguments to pass as the first parameter of ``subprocess.run``, wrap this in runguard. Return an updated list of parameters for ``subprocess.run``.
 def runguard(
     # A list of arguments comprising the first parameter of ``subprocess.run``.
     args,
     # The directory containing the executable to run in runguard.
     cwd,
-    # Kill COMMAND after TIME seconds (float).
+    # Kill COMMAND after TIME seconds (float). Omitted if this argument is falsey.
     time_s=15,
-    # Set maximum CPU time to TIME seconds (float).
+    # Set maximum CPU time to TIME seconds (float). Omitted if this argument is falsey.
     cputime_s=10,
-    # Set all (total, stack, etc) memory limits to SIZE kB.
-    memsize_kb=100,
-    # Set maximum created filesize to SIZE kB.
+    # Set all (total, stack, etc) memory limits to SIZE kB. Omitted if this argument is falsey.
+    memsize_kb=100000,
+    # Set maximum created filesize to SIZE kB. Omitted if this argument is falsey.
     filesize_kb=50,
-    # Set maximum no. processes to N.
+    # Set maximum no. processes to N. Omitted if this argument is falsey.
     num_processes=1,
     # Disable core dumps when True
     no_core_dumps=True,
@@ -226,12 +227,12 @@ def runguard(
             "/var/www/jobe/runguard/runguard",
             f"--user={user}",
             "--group=jobe",
-            f"--time={time_s}",
-            f"--cputime={cputime_s}",
-            f"--memsize={memsize_kb}",
-            f"--filesize={filesize_kb}",
-            f"--nproc={num_processes}",
         ]
+        + ([f"--time={time_s}"] if time_s else [])
+        + ([f"--cputime={cputime_s}"] if cputime_s else [])
+        + ([f"--memsize={memsize_kb}"] if memsize_kb else [])
+        + ([f"--filesize={filesize_kb}"] if filesize_kb else [])
+        + ([f"--nproc={num_processes}"] if num_processes else [])
         + (["--no-core"] if no_core_dumps else [])
         + args
     )
@@ -264,9 +265,12 @@ def rust_builder(
     out_list = []
     report_subprocess(["rustc", "--test", run_file_name], "Compile", cwd, out_list)
 
-    # Run.
+    # Run. Experimentation shows that Rust uses two processes (perhaps one for the test harness?).
     return report_subprocess(
-        runguard(["./" + os.path.splitext(run_file_name)[0]], cwd), "Run", cwd, out_list
+        runguard(["./" + os.path.splitext(run_file_name)[0]], cwd, num_processes=2),
+        "Run",
+        cwd,
+        out_list,
     )
 
 
@@ -578,3 +582,57 @@ def armv7_builder(
     return out_list, (
         100 if correct == 100 and check_sim_out(out_list, verification_code) else 0
     )
+
+
+def verilog_builder(
+    file_path, cwd, sphinx_base_path, sphinx_source_path, sphinx_out_path, source_path
+):
+    # Build the test code with a random verification code.
+    out_list = []
+    verification_code = get_verification_code()
+    test_file_path = os.path.join(
+        sphinx_base_path,
+        sphinx_source_path,
+        os.path.splitext(source_path)[0] + "-test.v",
+    )
+    preproc_path = file_path + ".test.vp"
+    report_subprocess(
+        [
+            "iverilog",
+            # Only do preprocessing; don't compile the result.
+            "-E",
+            # Pass the verification code.
+            "-DVERIFICATION_CODE=({})".format(verification_code),
+            "-o",
+            preproc_path,
+            test_file_path,
+        ],
+        "Compile test code",
+        cwd,
+        out_list,
+    )
+
+    # Compile the source and test code.
+    exe_path = file_path + ".exe"
+    report_subprocess(
+        [
+            "iverilog",
+            "-o",
+            exe_path,
+            file_path,
+            preproc_path,
+        ],
+        "Compile",
+        cwd,
+        out_list,
+    )
+
+    # Run the simulation.
+    report_subprocess(
+        runguard([exe_path], cwd, memsize_kb=100000),
+        "Simulation",
+        cwd,
+        out_list,
+        include_stderr=True,
+    )
+    return out_list, (100 if check_sim_out(out_list, verification_code) else 0)