esiaccel 0.1.5.dev205__cp39-cp39-win_amd64.whl → 0.1.5.dev533__cp39-cp39-win_amd64.whl

esiaccel/__init__.py

@@ -3,14 +3,15 @@
 #  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 import sys
 import os
-from .accelerator import AcceleratorConnection
+from .accelerator import AcceleratorConnection, Context, LogLevel
 
 from .esiCppAccel import (AppID, Type, BundleType, ChannelType, ArrayType,
                           StructType, BitsType, UIntType, SIntType)
 
 __all__ = [
-    "AcceleratorConnection", "AppID", "Type", "BundleType", "ChannelType",
-    "ArrayType", "StructType", "BitsType", "UIntType", "SIntType"
+    "AcceleratorConnection", "AppID", "Context", "LogLevel", "Type",
+    "BundleType", "ChannelType", "ArrayType", "StructType", "BitsType",
+    "UIntType", "SIntType"
 ]
 
 if sys.platform == "win32":
@@ -20,3 +21,11 @@ if sys.platform == "win32":
   """
   from .utils import get_dll_dir
   os.add_dll_directory(str(get_dll_dir()))
+
+
+def connect(platform: str, connection_str: str) -> "AcceleratorConnection":
+  """Connect to an accelerator using the specified platform and connection
+  string."""
+  ctxt = Context.default()
+  return AcceleratorConnection(ctxt,
+                               ctxt.cpp_ctxt.connect(platform, connection_str))

esiaccel/accelerator.py

@@ -15,19 +15,51 @@ from typing import Dict, List, Optional
 from .types import BundlePort
 from . import esiCppAccel as cpp
 
-# Global context for the C++ side.
-ctxt = cpp.Context()
+LogLevel = cpp.LogLevel
+
+
+class Context:
+  """A context for ESI accelerator connections. The underlying C++ context owns
+  everything assocated with it including types, accelerator connections, and
+  the accelerator facade/interface (aka Accelerator) itself. It must not be
+  garbage collected while any accelerators or connections that it owns are still
+  in use as they will be disconnected and destroyed when the context is
+  destroyed."""
+
+  _default: Optional["Context"] = None
+
+  def __init__(self, log_level: cpp.LogLevel = cpp.LogLevel.Warning):
+    self.cpp_ctxt = cpp.Context()
+    self.set_stdio_logger(log_level)
+
+  @staticmethod
+  def default() -> "Context":
+    if Context._default is None:
+      Context._default = Context()
+    return Context._default
+
+  def set_stdio_logger(self, level: cpp.LogLevel):
+    self.cpp_ctxt.set_stdio_logger(level)
+
+  def connect(self, platform: str,
+              connection_str: str) -> "AcceleratorConnection":
+    return AcceleratorConnection(
+        self, self.cpp_ctxt.connect(platform, connection_str))
 
 
 class AcceleratorConnection:
   """A connection to an ESI accelerator."""
 
-  def __init__(self, platform: str, connection_str: str):
-    self.cpp_accel = cpp.AcceleratorConnection(ctxt, platform, connection_str)
+  def __init__(self, ctxt: Context, cpp_accel: cpp.AcceleratorConnection):
+    if not isinstance(ctxt, Context):
+      raise TypeError("ctxt must be a Context")
+    self.ctxt = ctxt
+    self.cpp_accel = cpp_accel
 
   def manifest(self) -> cpp.Manifest:
     """Get and parse the accelerator manifest."""
-    return cpp.Manifest(ctxt, self.cpp_accel.sysinfo().json_manifest())
+    return cpp.Manifest(self.ctxt.cpp_ctxt,
+                        self.cpp_accel.sysinfo().json_manifest())
 
   def sysinfo(self) -> cpp.SysInfo:
     return self.cpp_accel.sysinfo()

esiaccel/codegen.py

@@ -6,7 +6,7 @@
 # with the runtime, though it is intended to be extensible for other languages.
 
 from typing import List, TextIO, Type, Optional
-from .accelerator import AcceleratorConnection
+from .accelerator import AcceleratorConnection, Context
 from .esiCppAccel import ModuleInfo
 from . import types
 
@@ -171,12 +171,12 @@ def run(generator: Type[Generator] = CppGenerator,
 
   conn: AcceleratorConnection
   if args.file is not None:
-    conn = AcceleratorConnection("trace", f"-:{args.file}")
+    conn = Context.default().connect("trace", f"-:{args.file}")
   elif args.platform is not None:
     if args.connection is None:
       print("Must specify --connection with --platform")
       return 1
-    conn = AcceleratorConnection(args.platform, args.connection)
+    conn = Context.default().connect(args.platform, args.connection)
   else:
     print("Must specify either --file or --platform")
     return 1

esiaccel/cosim/Cosim_Endpoint.sv

@@ -82,15 +82,6 @@ module Cosim_Endpoint_ToHost
                        TO_HOST_SIZE_BYTES_FLOOR_IN_BITS];
   endgenerate
 
-  initial begin
-    $display("TO_HOST_SIZE_BITS: %d", TO_HOST_SIZE_BITS);
-    $display("TO_HOST_SIZE_BYTES: %d", TO_HOST_SIZE_BYTES);
-    $display("TO_HOST_SIZE_BITS_DIFF: %d", TO_HOST_SIZE_BITS_DIFF);
-    $display("TO_HOST_SIZE_BYTES_FLOOR: %d", TO_HOST_SIZE_BYTES_FLOOR);
-    $display("TO_HOST_SIZE_BYTES_FLOOR_IN_BITS: %d",
-             TO_HOST_SIZE_BYTES_FLOOR_IN_BITS);
-  end
-
 endmodule
 
 module Cosim_Endpoint_FromHost
@@ -224,13 +215,4 @@ module Cosim_Endpoint_FromHost
   assign DataOutValid = DataOut_x_valid;
   assign DataOut = DataOut_x;
 
-  initial begin
-    $display("FROM_HOST_SIZE_BITS: %d", FROM_HOST_SIZE_BITS);
-    $display("FROM_HOST_SIZE_BYTES: %d", FROM_HOST_SIZE_BYTES);
-    $display("FROM_HOST_SIZE_BITS_DIFF: %d", FROM_HOST_SIZE_BITS_DIFF);
-    $display("FROM_HOST_SIZE_BYTES_FLOOR: %d", FROM_HOST_SIZE_BYTES_FLOOR);
-    $display("FROM_HOST_SIZE_BYTES_FLOOR_IN_BITS: %d",
-             FROM_HOST_SIZE_BYTES_FLOOR_IN_BITS);
-  end
-
 endmodule

esiaccel/cosim/driver.cpp

@@ -30,7 +30,7 @@
 #include CONCAT3(V,TOP_MODULE,.h)
 // clang-format on
 
-#include "verilated_vcd_c.h"
+#include "verilated_fst_c.h"
 
 #include "signal.h"
 #include <iostream>
@@ -64,12 +64,12 @@ int main(int argc, char **argv) {
   }
 
 #ifdef TRACE
-  VerilatedVcdC *tfp = nullptr;
+  VerilatedFstC *tfp = nullptr;
 #endif
 
   if (waveformFile) {
 #ifdef TRACE
-    tfp = new VerilatedVcdC();
+    tfp = new VerilatedFstC();
     Verilated::traceEverOn(true);
     dut.trace(tfp, 99); // Trace 99 levels of hierarchy
     tfp->open(waveformFile);
@@ -95,11 +95,11 @@ int main(int argc, char **argv) {
   // Run for a few cycles with reset held.
   for (timeStamp = 0; timeStamp < 8 && !Verilated::gotFinish(); timeStamp++) {
     dut.eval();
-    dut.clk = !dut.clk;
 #ifdef TRACE
     if (tfp)
       tfp->dump(timeStamp);
 #endif
+    dut.clk = !dut.clk;
   }
 
   // Take simulation out of reset.
@@ -108,12 +108,12 @@ int main(int argc, char **argv) {
   // Run for the specified number of cycles out of reset.
   for (; !Verilated::gotFinish() && !stopSimulation; timeStamp++) {
     dut.eval();
-    dut.clk = !dut.clk;
-
 #ifdef TRACE
     if (tfp)
       tfp->dump(timeStamp);
 #endif
+    dut.clk = !dut.clk;
+
     if (debugPeriod)
       std::this_thread::sleep_for(std::chrono::milliseconds(debugPeriod));
   }

esiaccel/cosim/driver.sv

@@ -18,8 +18,22 @@
 `define TOP_MODULE ESI_Cosim_Top
 `endif
 
+// Allow reading environment variables to control waveform dumping.
+import "DPI-C" function string getenv(input string env_name);
+
 module driver();
 
+  // If the SAVE_WAVE environment variable is set, dump a VCD waveform to that
+  // filename.
+  initial begin
+    string save_wave = getenv("SAVE_WAVE");
+    if (save_wave != "") begin
+      $display("[driver] Saving waveform to %s", save_wave);
+      $dumpfile(save_wave);
+      $dumpvars(0, driver);
+    end
+  end
+
   logic clk = 0;
   logic rst = 0;
 

esiaccel/cosim/questa.py

@@ -4,9 +4,9 @@
 
 import os
 from pathlib import Path
-from typing import List
+from typing import List, Optional, Callable, Dict
 
-from .simulator import CosimCollateralDir, Simulator
+from .simulator import CosimCollateralDir, Simulator, SourceFiles
 
 
 class Questa(Simulator):
@@ -14,6 +14,32 @@ class Questa(Simulator):
 
   DefaultDriver = CosimCollateralDir / "driver.sv"
 
+  def __init__(
+      self,
+      sources: SourceFiles,
+      run_dir: Path,
+      debug: bool,
+      run_stdout_callback: Optional[Callable[[str], None]] = None,
+      run_stderr_callback: Optional[Callable[[str], None]] = None,
+      compile_stdout_callback: Optional[Callable[[str], None]] = None,
+      compile_stderr_callback: Optional[Callable[[str], None]] = None,
+      make_default_logs: bool = True,
+      macro_definitions: Optional[Dict[str, str]] = None,
+      # An optional list of questa error codes to suppress
+      suppressed_questa_errors: Optional[List[int]] = None):
+    super().__init__(
+        sources=sources,
+        run_dir=run_dir,
+        debug=debug,
+        run_stdout_callback=run_stdout_callback,
+        run_stderr_callback=run_stderr_callback,
+        compile_stdout_callback=compile_stdout_callback,
+        compile_stderr_callback=compile_stderr_callback,
+        make_default_logs=make_default_logs,
+        macro_definitions=macro_definitions,
+    )
+    self.suppressed_questa_errors = suppressed_questa_errors
+
   # Questa doesn't use stderr for error messages. Everything goes to stdout.
   UsesStderr = False
 
@@ -23,9 +49,27 @@ class Questa(Simulator):
     ]
     sources = self.sources.rtl_sources
     sources.append(Questa.DefaultDriver)
+
+    # Format macro definition command
+    if self.macro_definitions:
+      macro_definitions_cmd = " ".join([
+          f"+define+{k}={v}" if v is not None else f"+define+{k}"
+          for k, v in self.macro_definitions.items()
+      ])
+    else:
+      macro_definitions_cmd = ""
+
+    # Format error suppression command
+    if self.suppressed_questa_errors:
+      suppressed_questa_errors_cmd = " ".join(
+          [f"-suppress {ec}" for ec in self.suppressed_questa_errors])
+    else:
+      suppressed_questa_errors_cmd = ""
+
     for src in sources:
-      cmds.append(f"vlog -incr +acc -sv +define+TOP_MODULE={self.sources.top}"
-                  f" +define+SIMULATION {str(src)}")
+      cmds.append(
+          f"vlog -incr +acc -sv {macro_definitions_cmd} {suppressed_questa_errors_cmd} +define+TOP_MODULE={self.sources.top}"
+          f" +define+SIMULATION {src.as_posix()}")
     cmds.append(f"vopt -incr driver -o driver_opt +acc")
     return cmds
 
@@ -53,9 +97,28 @@ class Questa(Simulator):
           vsim,
           "driver_opt",
           "-batch",
+      ]
+
+      if self.debug:
+        # Create waveform dump .do file
+        wave_file = Path("wave.do")
+        with wave_file.open("w") as f:
+          f.write("log -r /*\n")
+        cmd += [
+            "-do",
+            str(wave_file.resolve()),
+        ]
+        # Questa will by default log to a vsim.wlf file in the current
+        # directory.
+        print(
+            f"Debug mode enabled - waveform will be in {wave_file.resolve().parent / 'vsim.wlf'}"
+        )
+
+      cmd += [
           "-do",
           "run -all",
       ]
+
     for lib in self.sources.dpi_so_paths():
       svLib = os.path.splitext(lib)[0]
       cmd.append("-sv_lib")

esiaccel/cosim/simulator.py

@@ -9,7 +9,8 @@ import socket
 import subprocess
 import time
 from pathlib import Path
-from typing import Dict, List
+from typing import Dict, List, Optional, Callable, IO
+import threading
 
 _thisdir = Path(__file__).parent
 CosimCollateralDir = _thisdir
@@ -77,9 +78,15 @@ class SourceFiles:
 
 class SimProcess:
 
-  def __init__(self, proc: subprocess.Popen, port: int):
+  def __init__(self,
+               proc: subprocess.Popen,
+               port: int,
+               threads: Optional[List[threading.Thread]] = None,
+               gui: bool = False):
     self.proc = proc
     self.port = port
+    self.threads: List[threading.Thread] = threads or []
+    self.gui = gui
 
   def force_stop(self):
     """Make sure to stop the simulation no matter what."""
@@ -92,6 +99,10 @@ class SimProcess:
         # If the simulation doesn't exit of its own free will, kill it.
         self.proc.kill()
 
+    # Join reader threads (they should exit once pipes are closed).
+    for t in self.threads:
+      t.join()
+
 
 class Simulator:
 
@@ -100,10 +111,75 @@ class Simulator:
   # broken behavior by overriding this.
   UsesStderr = True
 
-  def __init__(self, sources: SourceFiles, run_dir: Path, debug: bool):
+  def __init__(self,
+               sources: SourceFiles,
+               run_dir: Path,
+               debug: bool,
+               run_stdout_callback: Optional[Callable[[str], None]] = None,
+               run_stderr_callback: Optional[Callable[[str], None]] = None,
+               compile_stdout_callback: Optional[Callable[[str], None]] = None,
+               compile_stderr_callback: Optional[Callable[[str], None]] = None,
+               make_default_logs: bool = True,
+               macro_definitions: Optional[Dict[str, str]] = None):
+    """Simulator base class.
+
+    Optional sinks can be provided for capturing output. If not provided,
+    the simulator will write to log files in `run_dir`.
+
+    Args:
+      sources: SourceFiles describing RTL/DPI inputs.
+      run_dir: Directory where build/run artifacts are placed.
+      debug: Enable cosim debug mode.
+      run_stdout_callback: Line-based callback for runtime stdout.
+      run_stderr_callback: Line-based callback for runtime stderr.
+      compile_stdout_callback: Line-based callback for compile stdout.
+      compile_stderr_callback: Line-based callback for compile stderr.
+      make_default_logs: If True and corresponding callback is not supplied,
+        create log file and emit via internally-created callback.
+      macro_definitions: Optional dictionary of macro definitions to be defined
+        during compilation.
+    """
     self.sources = sources
     self.run_dir = run_dir
     self.debug = debug
+    self.macro_definitions = macro_definitions
+
+    # Unified list of any log file handles we opened.
+    self._default_files: List[IO[str]] = []
+
+    def _ensure_default(cb: Optional[Callable[[str], None]], filename: str):
+      """Return (callback, file_handle_or_None) with optional file creation.
+
+      Behavior:
+        * If a callback is provided, return it unchanged with no file.
+        * If no callback and make_default_logs is False, return (None, None).
+        * If no callback and make_default_logs is True, create a log file and
+          return a writer callback plus the opened file handle.
+      """
+      if cb is not None:
+        return cb, None
+      if not make_default_logs:
+        return None, None
+      p = self.run_dir / filename
+      p.parent.mkdir(parents=True, exist_ok=True)
+      logf = p.open("w+")
+      self._default_files.append(logf)
+
+      def _writer(line: str, _lf=logf):
+        _lf.write(line + "\n")
+        _lf.flush()
+
+      return _writer, logf
+
+    # Initialize all four (compile/run stdout/stderr) uniformly.
+    self._compile_stdout_cb, self._compile_stdout_log = _ensure_default(
+        compile_stdout_callback, 'compile_stdout.log')
+    self._compile_stderr_cb, self._compile_stderr_log = _ensure_default(
+        compile_stderr_callback, 'compile_stderr.log')
+    self._run_stdout_cb, self._run_stdout_log = _ensure_default(
+        run_stdout_callback, 'sim_stdout.log')
+    self._run_stderr_cb, self._run_stderr_log = _ensure_default(
+        run_stderr_callback, 'sim_stderr.log')
 
   @staticmethod
   def get_env() -> Dict[str, str]:
@@ -123,23 +199,29 @@ class Simulator:
   def compile(self) -> int:
     cmds = self.compile_commands()
     self.run_dir.mkdir(parents=True, exist_ok=True)
-    with (self.run_dir / "compile_stdout.log").open("w") as stdout, (
-        self.run_dir / "compile_stderr.log").open("w") as stderr:
-      for cmd in cmds:
-        stderr.write(" ".join(cmd) + "\n")
-        cp = subprocess.run(cmd,
-                            env=Simulator.get_env(),
-                            capture_output=True,
-                            text=True)
-        stdout.write(cp.stdout)
-        stderr.write(cp.stderr)
-        if cp.returncode != 0:
-          print("====== Compilation failure:")
-          if self.UsesStderr:
-            print(cp.stderr)
-          else:
-            print(cp.stdout)
-          return cp.returncode
+    for cmd in cmds:
+      ret = self._start_process_with_callbacks(
+          cmd,
+          env=Simulator.get_env(),
+          cwd=None,
+          stdout_cb=self._compile_stdout_cb,
+          stderr_cb=self._compile_stderr_cb,
+          wait=True)
+      if isinstance(ret, int) and ret != 0:
+        print("====== Compilation failure")
+
+        # If we have the default file loggers, print the compilation logs to
+        # console. Else, assume that the user has already captured them.
+        if self.UsesStderr:
+          if self._compile_stderr_log is not None:
+            self._compile_stderr_log.seek(0)
+            print(self._compile_stderr_log.read())
+        else:
+          if self._compile_stdout_log is not None:
+            self._compile_stdout_log.seek(0)
+            print(self._compile_stdout_log.read())
+
+        return ret
     return 0
 
   def run_command(self, gui: bool) -> List[str]:
@@ -148,11 +230,16 @@ class Simulator:
 
   def run_proc(self, gui: bool = False) -> SimProcess:
     """Run the simulation process. Returns the Popen object and the port which
-      the simulation is listening on."""
-    # Open log files
+      the simulation is listening on.
+
+    If user-provided stdout/stderr sinks were supplied in the constructor,
+    they are used. Otherwise, log files are created in `run_dir`.
+    """
     self.run_dir.mkdir(parents=True, exist_ok=True)
-    simStdout = open(self.run_dir / "sim_stdout.log", "w")
-    simStderr = open(self.run_dir / "sim_stderr.log", "w")
+
+    env_gui = os.environ.get("COSIM_GUI", "0")
+    if env_gui != "0":
+      gui = True
 
     # Erase the config file if it exists. We don't want to read
     # an old config.
@@ -168,19 +255,19 @@ class Simulator:
         # Slow the simulation down to one tick per millisecond.
         simEnv["DEBUG_PERIOD"] = "1"
     rcmd = self.run_command(gui)
-    simProc = subprocess.Popen(self.run_command(gui),
-                               stdout=simStdout,
-                               stderr=simStderr,
-                               env=simEnv,
-                               cwd=self.run_dir,
-                               preexec_fn=os.setsid)
-    simStderr.close()
-    simStdout.close()
+    # Start process with asynchronous output capture.
+    proc, threads = self._start_process_with_callbacks(
+        rcmd,
+        env=simEnv,
+        cwd=self.run_dir,
+        stdout_cb=self._run_stdout_cb,
+        stderr_cb=self._run_stderr_cb,
+        wait=False)
 
     # Get the port which the simulation RPC selected.
     checkCount = 0
     while (not os.path.exists(portFileName)) and \
-            simProc.poll() is None:
+            proc.poll() is None:
       time.sleep(0.1)
       checkCount += 1
       if checkCount > 500 and not gui:
@@ -200,10 +287,66 @@ class Simulator:
       checkCount += 1
       if checkCount > 200:
         raise Exception(f"Cosim RPC port ({port}) never opened")
-      if simProc.poll() is not None:
+      if proc.poll() is not None:
         raise Exception("Simulation exited early")
       time.sleep(0.05)
-    return SimProcess(proc=simProc, port=port)
+    return SimProcess(proc=proc, port=port, threads=threads, gui=gui)
+
+  def _start_process_with_callbacks(
+      self, cmd: List[str], env: Optional[Dict[str, str]], cwd: Optional[Path],
+      stdout_cb: Optional[Callable[[str],
+                                   None]], stderr_cb: Optional[Callable[[str],
+                                                                        None]],
+      wait: bool) -> int | tuple[subprocess.Popen, List[threading.Thread]]:
+    """Start a subprocess and stream its stdout/stderr to callbacks.
+
+    If wait is True, blocks until process completes and returns its exit code.
+    If wait is False, returns the Popen object (threads keep streaming).
+    """
+    if os.name == "posix":
+      proc = subprocess.Popen(cmd,
+                              stdout=subprocess.PIPE,
+                              stderr=subprocess.PIPE,
+                              env=env,
+                              cwd=cwd,
+                              text=True,
+                              preexec_fn=os.setsid)
+    else:  # windows
+      proc = subprocess.Popen(cmd,
+                              stdout=subprocess.PIPE,
+                              stderr=subprocess.PIPE,
+                              env=env,
+                              cwd=cwd,
+                              text=True,
+                              creationflags=subprocess.CREATE_NEW_PROCESS_GROUP)
+
+    def _reader(pipe, cb):
+      if pipe is None:
+        return
+      for raw in pipe:
+        if raw.endswith('\n'):
+          raw = raw[:-1]
+        if cb:
+          try:
+            cb(raw)
+          except Exception as e:
+            print(f"Exception in simulator output callback: {e}")
+
+    threads: List[threading.Thread] = [
+        threading.Thread(target=_reader,
+                         args=(proc.stdout, stdout_cb),
+                         daemon=True),
+        threading.Thread(target=_reader,
+                         args=(proc.stderr, stderr_cb),
+                         daemon=True),
+    ]
+    for t in threads:
+      t.start()
+    if wait:
+      for t in threads:
+        t.join()
+      return proc.wait()
+    return proc, threads
 
   def run(self,
           inner_command: str,
@@ -228,8 +371,12 @@ class Simulator:
         testEnv = os.environ.copy()
         testEnv["ESI_COSIM_PORT"] = str(simProc.port)
         testEnv["ESI_COSIM_HOST"] = "localhost"
-        return subprocess.run(inner_command, cwd=os.getcwd(),
-                              env=testEnv).returncode
+        ret = subprocess.run(inner_command, cwd=os.getcwd(),
+                             env=testEnv).returncode
+        if simProc.gui:
+          print("GUI mode - waiting for simulator to exit...")
+          simProc.proc.wait()
+        return ret
     finally:
-      if simProc:
+      if simProc and simProc.proc.poll() is None:
         simProc.force_stop()