esiaccel 0.1.5.dev205__cp312-cp312-win_amd64.whl → 0.1.5.dev219__cp312-cp312-win_amd64.whl

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/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,13 @@ 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):
     self.proc = proc
     self.port = port
+    self.threads: List[threading.Thread] = threads or []
 
   def force_stop(self):
     """Make sure to stop the simulation no matter what."""
@@ -92,6 +97,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,11 +109,72 @@ 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):
+    """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.
+    """
     self.sources = sources
     self.run_dir = run_dir
     self.debug = debug
 
+    # 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]:
     """Get the environment variables to locate shared objects."""
@@ -123,23 +193,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 +224,12 @@ 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")
 
     # Erase the config file if it exists. We don't want to read
     # an old config.
@@ -168,19 +245,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 +277,57 @@ 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)
+
+  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).
+    """
+    proc = subprocess.Popen(cmd,
+                            stdout=subprocess.PIPE,
+                            stderr=subprocess.PIPE,
+                            env=env,
+                            cwd=cwd,
+                            text=True,
+                            preexec_fn=os.setsid)
+
+    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,

esiaccel/cosim/verilator.py

@@ -4,7 +4,7 @@
 
 import os
 from pathlib import Path
-from typing import List
+from typing import List, Optional, Callable
 
 from .simulator import CosimCollateralDir, Simulator, SourceFiles
 
@@ -14,9 +14,23 @@ class Verilator(Simulator):
 
   DefaultDriver = CosimCollateralDir / "driver.cpp"
 
-  def __init__(self, sources: SourceFiles, run_dir: Path, debug: bool):
-    super().__init__(sources, run_dir, debug)
-
+  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):
+    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)
     self.verilator = "verilator"
     if "VERILATOR_PATH" in os.environ:
       self.verilator = os.environ["VERILATOR_PATH"]
@@ -36,6 +50,7 @@ class Verilator(Simulator):
         "-j",
         "0",
         "--output-split",
+        "--autoflush",
         "--assert",
         str(Verilator.DefaultDriver),
     ]
@@ -44,7 +59,8 @@ class Verilator(Simulator):
     ]
     if self.debug:
       cmd += [
-          "--trace", "--trace-params", "--trace-structs", "--trace-underscore"
+          "--trace-fst", "--trace-params", "--trace-structs",
+          "--trace-underscore"
       ]
       cflags.append("-DTRACE")
     if len(cflags) > 0:

{esiaccel-0.1.5.dev205.dist-info → esiaccel-0.1.5.dev219.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: esiaccel
-Version: 0.1.5.dev205
+Version: 0.1.5.dev219
 Summary: ESI accelerators runtime
 Author-email: John Demme <John.Demme@microsoft.com>
 License: ==============================================================================

{esiaccel-0.1.5.dev205.dist-info → esiaccel-0.1.5.dev219.dist-info}/RECORD

@@ -1,28 +1,28 @@
-esiaccel/CosimBackend.dll,sha256=UiMiWukPyecx9fgJMz7scGA862JPD_ApmTLaJAWElJE,7152128
+esiaccel/CosimBackend.dll,sha256=cANubAxsaG3GoSz3tJdaXXY3CwiLwGnD49l7ApTnIh4,7152128
 esiaccel/CosimBackend.lib,sha256=5tnhX-BFxzlslXNsblCWXjY583sDW4lFLGNch7hzWZw,4992924
-esiaccel/ESICppRuntime.dll,sha256=IN1gagR1JvgXj376t5Plg3Su3Lou9FpsEqQq6_T7KcA,4078592
+esiaccel/ESICppRuntime.dll,sha256=s4vPL6_NQrvWUs9XMOfxhiBs1G4iPETULL1guvDlfoM,4078592
 esiaccel/ESICppRuntime.lib,sha256=tltAogZ3c0ryYHirOXz_qltr5aNdoquZ-Q4yVqim3FY,15154004
-esiaccel/EsiCosimDpiServer.dll,sha256=412hqK72k7wg6rhS6d9AqoKE10n-KkrkLkHkNJ-9h_I,159744
+esiaccel/EsiCosimDpiServer.dll,sha256=Z7IXzih80HZN_9IzM9uq8RydnB3M92mCMn6NIahl2tU,159744
 esiaccel/EsiCosimDpiServer.lib,sha256=zn3bIX10e2HQtwZOi1xpqeNfy4AdZm8Jx634HVTVQ8w,604164
-esiaccel/MtiPli.dll,sha256=44O2jtZ7zDXt-Mo0L2cXFhe_sEU-KDICrmw-TV3IRLA,14848
+esiaccel/MtiPli.dll,sha256=u0qCm45umvX6o42Y7rDonOYMJfMW0VV4K99pMuxzIKQ,14848
 esiaccel/MtiPli.lib,sha256=juJ2Asmv6cnozNPpXvGeKkieYFcXK8MOYmDQZz-dAy4,14570
 esiaccel/__init__.py,sha256=65xXWHwJwRePsyhWk837NpzuN0qsNhoAX29TOiSYKGc,905
 esiaccel/accelerator.py,sha256=BcXPsUqcQV3YsVVyYbz9P6JnZLlcnuageFbJwID9_3s,3318
 esiaccel/codegen.py,sha256=uoYELtnIabVvgLeCABj-mWras0BvmSKABPH-cd9nDFk,6560
 esiaccel/esi-cosim.py,sha256=P7n3SBgKPnXynwghY5zK1FmpqZkbC_YxfVIvNNQNl6Q,3817
-esiaccel/esiCppAccel.cp312-win_amd64.pyd,sha256=JKn0jtlFgfSGsvgkEkn9WK8D9q7_1hbkPpp0WzzN9cs,510976
-esiaccel/esiquery.exe,sha256=zvoo-VYY5Uw5GbX6PlrfT82dR0NevTOQEhhR52TUXwI,441856
+esiaccel/esiCppAccel.cp312-win_amd64.pyd,sha256=KEdQXKdir6NZ_xmvhn-5PLi7K205FXl_LI-WgrvEBRQ,510976
+esiaccel/esiquery.exe,sha256=uIflsoLud7pPhpnom5IKb5Nf3DMF1yFZ5gFj8h2L-hY,441856
 esiaccel/types.py,sha256=LFLzUCvtYF6FLsmKet6eJTMq2ija2Z5kxd5Ks6tkS4U,19044
 esiaccel/utils.py,sha256=q-8fmgJ9tUvmBsIvqZiZ7u845IJhOjvjYTQLhhrNYl0,1515
 esiaccel/cmake/esiaccelConfig.cmake,sha256=u2aW99k1lEcmYTG1P3BTJqtmDrj53wUUaBz_jzw8kYY,565
 esiaccel/cosim/Cosim_DpiPkg.sv,sha256=9qGn1VyAVrzBP5At1thV6xrovg0WghICD01Zz9J221E,3458
 esiaccel/cosim/Cosim_Endpoint.sv,sha256=2F7UQYWavUlWx7Iqi_6iawn5geZRPG96H8rDBBDRAQ0,8391
 esiaccel/cosim/Cosim_Manifest.sv,sha256=vl9b6XieEkP880IBw1ferekBnDJwFanZZggJJGertXM,1123
-esiaccel/cosim/driver.cpp,sha256=DrEKkSN7Y_Hu7wcaUulH5mbC2L4yB9xLClRMeRUpzHM,3842
+esiaccel/cosim/driver.cpp,sha256=Lvmo03pzzhoswdxAtdXAm-oU6UkfTyl1LgoCpyDzLhY,3842
 esiaccel/cosim/driver.sv,sha256=ro-j9GM164A1W0MDPkqYfEn3TUKHSqVvgjO31fnloQI,1428
 esiaccel/cosim/questa.py,sha256=d6PnjzRxQpu47Zpez6hmzTc_aMQdrmQRSmnpOXSPFVU,2386
-esiaccel/cosim/simulator.py,sha256=VZnCxRW6QzCMVhkkq0VC7tJ-kIxXatz30P5dJ5zzCKw,8081
-esiaccel/cosim/verilator.py,sha256=BwCJWLlMOPD_JZyjOoLGUW48-IIndtbj55D2kRvL1l4,1834
+esiaccel/cosim/simulator.py,sha256=aWhEjuAwdzgAIRUsW9yC2ACBIbdxbmMhJSGnH-OP_n0,12975
+esiaccel/cosim/verilator.py,sha256=WPZT14EkjtF1214P2noZyQC58GR7021xWaQ5oQwVcIg,2696
 esiaccel/include/esi/Accelerator.h,sha256=RhkZ2HeMZ0iHc5BkHdDWXoeg9J9lyPQciH5bWq5Qc_w,9772
 esiaccel/include/esi/CLI.h,sha256=Nn8tHn_xtEfkrD7USE2tao6ktYOJ6xcbnhZkS9-ox0A,2540
 esiaccel/include/esi/Common.h,sha256=IGJvAU72dlearXFbSmlXFFriy8aomirp7opEBjgewek,5775
@@ -38,9 +38,9 @@ esiaccel/include/esi/Utils.h,sha256=KPd75GajIFeTBVJocXBjwsJqhbZg-ShWZCIe3oQdBss,
 esiaccel/include/esi/backends/Cosim.h,sha256=s7vYd0ra6m1nvk-n37MjvBoGVI-CCUKBt0DU4PKlaHM,2838
 esiaccel/include/esi/backends/RpcServer.h,sha256=WMwnhwU2qnrcglGNeiKg9QQHpkDx1QE1JydKYDK4jqE,1856
 esiaccel/include/esi/backends/Trace.h,sha256=kx4wwLH3a0ndmRUdaDyYGZ1SP83zlpFrk30Nw8ZrJJA,3286
-esiaccel-0.1.5.dev205.dist-info/licenses/LICENSE,sha256=vtnVnB8_lN1yPYcA5MeT56R8UsQtBhyzZLBvu_KMf7I,13468
-esiaccel-0.1.5.dev205.dist-info/METADATA,sha256=tXBuqKC4EqMHtaA7m4pFDR7kDgXdyoon8kcLLW4xG6I,16148
-esiaccel-0.1.5.dev205.dist-info/WHEEL,sha256=8UP9x9puWI0P1V_d7K2oMTBqfeLNm21CTzZ_Ptr0NXU,101
-esiaccel-0.1.5.dev205.dist-info/entry_points.txt,sha256=_CuNLV0fyTURxRREFwpzGycifZW_-7-MyuJNEwKK9J8,137
-esiaccel-0.1.5.dev205.dist-info/top_level.txt,sha256=fYWTWMDK4PDu4ePQ9NtcFHas2k8-d1kWhTs2avPpgB4,9
-esiaccel-0.1.5.dev205.dist-info/RECORD,,
+esiaccel-0.1.5.dev219.dist-info/licenses/LICENSE,sha256=vtnVnB8_lN1yPYcA5MeT56R8UsQtBhyzZLBvu_KMf7I,13468
+esiaccel-0.1.5.dev219.dist-info/METADATA,sha256=f-XqGqrEMBo0ogpjlkVr9oUcYU2Yafo8diGbgjK4ePM,16148
+esiaccel-0.1.5.dev219.dist-info/WHEEL,sha256=8UP9x9puWI0P1V_d7K2oMTBqfeLNm21CTzZ_Ptr0NXU,101
+esiaccel-0.1.5.dev219.dist-info/entry_points.txt,sha256=_CuNLV0fyTURxRREFwpzGycifZW_-7-MyuJNEwKK9J8,137
+esiaccel-0.1.5.dev219.dist-info/top_level.txt,sha256=fYWTWMDK4PDu4ePQ9NtcFHas2k8-d1kWhTs2avPpgB4,9
+esiaccel-0.1.5.dev219.dist-info/RECORD,,