esiaccel 0.1.5.dev66__cp39-cp39-win_amd64.whl → 0.1.5.dev450__cp39-cp39-win_amd64.whl

esiaccel/esi-cosim.py

@@ -14,333 +14,14 @@
 # ===----------------------------------------------------------------------===//
 
 import argparse
-import os
 from pathlib import Path
-import re
-import signal
-import socket
-import subprocess
 import sys
 import textwrap
-import time
 from typing import Dict, List
 
-_thisdir = Path(__file__).parent
-CosimCollateralDir = _thisdir.parent / "cosim"
-
-
-def is_port_open(port) -> bool:
-  """Check if a TCP port is open locally."""
-  sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-  result = sock.connect_ex(('127.0.0.1', port))
-  sock.close()
-  return True if result == 0 else False
-
-
-class SourceFiles:
-
-  def __init__(self, top: str) -> None:
-    # User source files.
-    self.user: List[Path] = []
-    # DPI shared objects.
-    self.dpi_so: List[str] = ["EsiCosimDpiServer"]
-    # DPI SV files.
-    self.dpi_sv: List[Path] = [
-        CosimCollateralDir / "Cosim_DpiPkg.sv",
-        CosimCollateralDir / "Cosim_Endpoint.sv",
-        CosimCollateralDir / "Cosim_Manifest.sv",
-    ]
-    # Name of the top module.
-    self.top = top
-
-  def add_dir(self, dir: Path):
-    """Add all the RTL files in a directory to the source list."""
-    for file in sorted(dir.iterdir()):
-      if file.is_file() and (file.suffix == ".sv" or file.suffix == ".v"):
-        self.user.append(file)
-      elif file.is_dir():
-        self.add_dir(file)
-
-  def dpi_so_paths(self) -> List[Path]:
-    """Return a list of all the DPI shared object files."""
-
-    def find_so(name: str) -> Path:
-      for path in Simulator.get_env().get("LD_LIBRARY_PATH", "").split(":"):
-        if os.name == "nt":
-          so = Path(path) / f"{name}.dll"
-        else:
-          so = Path(path) / f"lib{name}.so"
-        if so.exists():
-          return so
-      raise FileNotFoundError(f"Could not find {name}.so in LD_LIBRARY_PATH")
-
-    return [find_so(name) for name in self.dpi_so]
-
-  @property
-  def rtl_sources(self) -> List[Path]:
-    """Return a list of all the RTL source files."""
-    return self.dpi_sv + self.user
-
-
-class Simulator:
-
-  # Some RTL simulators don't use stderr for error messages. Everything goes to
-  # stdout. Boo! They should feel bad about this. Also, they can specify that
-  # broken behavior by overriding this.
-  UsesStderr = True
-
-  def __init__(self, sources: SourceFiles, run_dir: Path, debug: bool):
-    self.sources = sources
-    self.run_dir = run_dir
-    self.debug = debug
-
-  @staticmethod
-  def get_env() -> Dict[str, str]:
-    """Get the environment variables to locate shared objects."""
-
-    env = os.environ.copy()
-    env["LIBRARY_PATH"] = env.get("LIBRARY_PATH", "") + ":" + str(
-        _thisdir.parent / "lib")
-    env["LD_LIBRARY_PATH"] = env.get("LD_LIBRARY_PATH", "") + ":" + str(
-        _thisdir.parent / "lib")
-    return env
-
-  def compile_commands(self) -> List[List[str]]:
-    """Compile the sources. Returns the exit code of the simulation compiler."""
-    assert False, "Must be implemented by subclass"
-
-  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
-    return 0
-
-  def run_command(self, gui: bool) -> List[str]:
-    """Return the command to run the simulation."""
-    assert False, "Must be implemented by subclass"
-
-  def run(self,
-          inner_command: str,
-          gui: bool = False,
-          server_only: bool = False) -> int:
-    """Start the simulation then run the command specified. Kill the simulation
-    when the command exits."""
-
-    # 'simProc' is accessed in the finally block. Declare it here to avoid
-    # syntax errors in that block.
-    simProc = None
-    try:
-      # Open log files
-      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.
-      portFileName = self.run_dir / "cosim.cfg"
-      if os.path.exists(portFileName):
-        os.remove(portFileName)
-
-      # Run the simulation.
-      simEnv = Simulator.get_env()
-      if self.debug:
-        simEnv["COSIM_DEBUG_FILE"] = "cosim_debug.log"
-        if "DEBUG_PERIOD" not in simEnv:
-          # Slow the simulation down to one tick per millisecond.
-          simEnv["DEBUG_PERIOD"] = "1"
-      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()
-
-      # Get the port which the simulation RPC selected.
-      checkCount = 0
-      while (not os.path.exists(portFileName)) and \
-              simProc.poll() is None:
-        time.sleep(0.1)
-        checkCount += 1
-        if checkCount > 200 and not gui:
-          raise Exception(f"Cosim never wrote cfg file: {portFileName}")
-      port = -1
-      while port < 0:
-        portFile = open(portFileName, "r")
-        for line in portFile.readlines():
-          m = re.match("port: (\\d+)", line)
-          if m is not None:
-            port = int(m.group(1))
-        portFile.close()
-
-      # Wait for the simulation to start accepting RPC connections.
-      checkCount = 0
-      while not is_port_open(port):
-        checkCount += 1
-        if checkCount > 200:
-          raise Exception(f"Cosim RPC port ({port}) never opened")
-        if simProc.poll() is not None:
-          raise Exception("Simulation exited early")
-        time.sleep(0.05)
-
-      if server_only:
-        # wait for user input to kill the server
-        input(
-            f"Running in server-only mode on port {port} - Press anything to kill the server..."
-        )
-        return 0
-      else:
-        # Run the inner command, passing the connection info via environment vars.
-        testEnv = os.environ.copy()
-        testEnv["ESI_COSIM_PORT"] = str(port)
-        testEnv["ESI_COSIM_HOST"] = "localhost"
-        return subprocess.run(inner_command, cwd=os.getcwd(),
-                              env=testEnv).returncode
-    finally:
-      # Make sure to stop the simulation no matter what.
-      if simProc:
-        os.killpg(os.getpgid(simProc.pid), signal.SIGINT)
-        # Allow the simulation time to flush its outputs.
-        try:
-          simProc.wait(timeout=1.0)
-        except subprocess.TimeoutExpired:
-          # If the simulation doesn't exit of its own free will, kill it.
-          simProc.kill()
-
-
-class Verilator(Simulator):
-  """Run and compile funcs for Verilator."""
-
-  DefaultDriver = CosimCollateralDir / "driver.cpp"
-
-  def __init__(self, sources: SourceFiles, run_dir: Path, debug: bool):
-    super().__init__(sources, run_dir, debug)
-
-    self.verilator = "verilator"
-    if "VERILATOR_PATH" in os.environ:
-      self.verilator = os.environ["VERILATOR_PATH"]
-
-  def compile_commands(self) -> List[List[str]]:
-    cmd: List[str] = [
-        self.verilator,
-        "--cc",
-        "--top-module",
-        self.sources.top,
-        "-DSIMULATION",
-        "-Wno-TIMESCALEMOD",
-        "-Wno-fatal",
-        "-sv",
-        "--build",
-        "--exe",
-        "--assert",
-        str(Verilator.DefaultDriver),
-    ]
-    cflags = [
-        "-DTOP_MODULE=" + self.sources.top,
-    ]
-    if self.debug:
-      cmd += [
-          "--trace", "--trace-params", "--trace-structs", "--trace-underscore"
-      ]
-      cflags.append("-DTRACE")
-    if len(cflags) > 0:
-      cmd += ["-CFLAGS", " ".join(cflags)]
-    if len(self.sources.dpi_so) > 0:
-      cmd += ["-LDFLAGS", " ".join(["-l" + so for so in self.sources.dpi_so])]
-    cmd += [str(p) for p in self.sources.rtl_sources]
-    return [cmd]
-
-  def run_command(self, gui: bool):
-    if gui:
-      raise RuntimeError("Verilator does not support GUI mode.")
-    exe = Path.cwd() / "obj_dir" / ("V" + self.sources.top)
-    return [str(exe)]
-
-
-class Questa(Simulator):
-  """Run and compile funcs for Questasim."""
-
-  DefaultDriver = CosimCollateralDir / "driver.sv"
-
-  # Questa doesn't use stderr for error messages. Everything goes to stdout.
-  UsesStderr = False
-
-  def internal_compile_commands(self) -> List[str]:
-    cmds = [
-        "onerror { quit -f -code 1 }",
-    ]
-    sources = self.sources.rtl_sources
-    sources.append(Questa.DefaultDriver)
-    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"vopt -incr driver -o driver_opt +acc")
-    return cmds
-
-  def compile_commands(self) -> List[List[str]]:
-    with open("compile.do", "w") as f:
-      for cmd in self.internal_compile_commands():
-        f.write(cmd)
-        f.write("\n")
-      f.write("quit\n")
-    return [
-        ["vsim", "-batch", "-do", "compile.do"],
-    ]
-
-  def run_command(self, gui: bool) -> List[str]:
-    vsim = "vsim"
-    # Note: vsim exit codes say nothing about the test run's pass/fail even
-    # if $fatal is encountered in the simulation.
-    if gui:
-      cmd = [
-          vsim,
-          "driver_opt",
-      ]
-    else:
-      cmd = [
-          vsim,
-          "driver_opt",
-          "-batch",
-          "-do",
-          "run -all",
-      ]
-    for lib in self.sources.dpi_so_paths():
-      svLib = os.path.splitext(lib)[0]
-      cmd.append("-sv_lib")
-      cmd.append(svLib)
-    return cmd
-
-  def run(self,
-          inner_command: str,
-          gui: bool = False,
-          server_only: bool = False) -> int:
-    """Override the Simulator.run() to add a soft link in the run directory (to
-    the work directory) before running vsim the usual way."""
-
-    # Create a soft link to the work directory.
-    workDir = self.run_dir / "work"
-    if not workDir.exists():
-      os.symlink(Path(os.getcwd()) / "work", workDir)
-
-    # Run the simulation.
-    return super().run(inner_command, gui, server_only=server_only)
+from esiaccel.cosim.questa import Questa
+from esiaccel.cosim.verilator import Verilator
+from esiaccel.cosim.simulator import SourceFiles
 
 
 def __main__(args):

esiaccel/include/esi/Accelerator.h

@@ -86,13 +86,6 @@ public:
   /// Disconnect from the accelerator cleanly.
   virtual void disconnect();
 
-  // While building the design, keep around a std::map of active services
-  // indexed by the service name. When a new service is encountered during
-  // descent, add it to the table (perhaps overwriting one). Modifications to
-  // the table only apply to the current branch, so copy this and update it at
-  // each level of the tree.
-  using ServiceTable = std::map<std::string, services::Service *>;
-
   /// Return a pointer to the accelerator 'service' thread (or threads). If the
   /// thread(s) are not running, they will be started when this method is
   /// called. `std::thread` is used. If users don't want the runtime to spin up
@@ -165,7 +158,7 @@ private:
 
   /// Cache services via a unique_ptr so they get free'd automatically when
   /// Accelerator objects get deconstructed.
-  using ServiceCacheKey = std::tuple<const std::type_info *, AppIDPath>;
+  using ServiceCacheKey = std::tuple<std::string, AppIDPath>;
   std::map<ServiceCacheKey, std::unique_ptr<Service>> serviceCache;
 
   std::unique_ptr<AcceleratorServiceThread> serviceThread;
@@ -176,12 +169,6 @@ private:
 
 namespace registry {
 
-// Connect to an ESI accelerator given a backend name and connection specifier.
-// Alternatively, instantiate the backend directly (if you're using C++).
-std::unique_ptr<AcceleratorConnection> connect(Context &ctxt,
-                                               const std::string &backend,
-                                               const std::string &connection);
-
 namespace internal {
 
 /// Backends can register themselves to be connected via a connection string.

esiaccel/include/esi/CLI.h

@@ -51,19 +51,19 @@ public:
       ctxt = Context::withLogger<ConsoleLogger>(Logger::Level::Debug);
     else if (verbose)
       ctxt = Context::withLogger<ConsoleLogger>(Logger::Level::Info);
+    else
+      ctxt = Context::withLogger<ConsoleLogger>(Logger::Level::Warning);
     return 0;
   }
 
   /// Connect to the accelerator using the specified backend and connection.
-  std::unique_ptr<AcceleratorConnection> connect() {
-    return ctxt.connect(backend, connStr);
-  }
+  AcceleratorConnection *connect() { return ctxt->connect(backend, connStr); }
 
   /// Get the context.
-  Context &getContext() { return ctxt; }
+  Context &getContext() { return *ctxt; }
 
 protected:
-  Context ctxt;
+  std::unique_ptr<Context> ctxt;
 
   std::string backend;
   std::string connStr;

esiaccel/include/esi/Common.h

@@ -20,6 +20,7 @@
 #include <cstdint>
 #include <map>
 #include <optional>
+#include <span>
 #include <stdexcept>
 #include <string>
 #include <vector>
@@ -42,6 +43,13 @@ struct AppID {
     return name == other.name && idx == other.idx;
   }
   bool operator!=(const AppID &other) const { return !(*this == other); }
+  friend std::ostream &operator<<(std::ostream &os, const AppID &id);
+
+  std::string toString() const {
+    if (idx.has_value())
+      return name + "[" + std::to_string(idx.value()) + "]";
+    return name;
+  }
 };
 bool operator<(const AppID &a, const AppID &b);
 
@@ -52,6 +60,7 @@ public:
   AppIDPath operator+(const AppIDPath &b) const;
   AppIDPath parent() const;
   std::string toStr() const;
+  friend std::ostream &operator<<(std::ostream &os, const AppIDPath &path);
 };
 bool operator<(const AppIDPath &a, const AppIDPath &b);
 
@@ -105,6 +114,8 @@ class MessageData {
 public:
   /// Adopts the data vector buffer.
   MessageData() = default;
+  MessageData(std::span<const uint8_t> data)
+      : data(data.data(), data.data() + data.size()) {}
   MessageData(std::vector<uint8_t> &data) : data(std::move(data)) {}
   MessageData(std::vector<uint8_t> &&data) : data(std::move(data)) {}
   MessageData(const uint8_t *data, size_t size) : data(data, data + size) {}
@@ -115,11 +126,17 @@ public:
   /// Get the data as a vector of bytes.
   const std::vector<uint8_t> &getData() const { return data; }
 
+  /// Implicit conversion to a vector/span of bytes, to play nice with other
+  /// APIs that accept bytearray-like things.
+  operator const std::vector<uint8_t> &() const { return data; }
+  operator std::span<const uint8_t>() const { return data; }
+
   /// Move the data out of this object.
   std::vector<uint8_t> takeData() { return std::move(data); }
 
   /// Get the size of the data in bytes.
   size_t getSize() const { return data.size(); }
+  size_t size() const { return getSize(); }
 
   /// Returns true if this message contains no data.
   bool empty() const { return data.empty(); }
@@ -152,7 +169,6 @@ private:
 } // namespace esi
 
 std::ostream &operator<<(std::ostream &, const esi::ModuleInfo &);
-std::ostream &operator<<(std::ostream &, const esi::AppID &);
 
 //===----------------------------------------------------------------------===//
 // Functions which should be in the standard library.

esiaccel/include/esi/Context.h

@@ -20,23 +20,30 @@
 #include "esi/Types.h"
 
 #include <exception>
+#include <map>
 #include <memory>
-#include <optional>
+#include <vector>
 
 namespace esi {
 class AcceleratorConnection;
 
 /// AcceleratorConnections, Accelerators, and Manifests must all share a
-/// context. It owns all the types, uniquifying them.
+/// context. It owns all the types, uniquifying them. It also owns the
+/// connections (which own the Accelerators). When it is destroyed, all
+/// connections are disconnected and the objects are destroyed.
 class Context {
 public:
-  Context() : logger(std::make_unique<ConsoleLogger>(Logger::Level::Warning)) {}
-  Context(std::unique_ptr<Logger> logger) : logger(std::move(logger)) {}
+  Context();
+  Context(std::unique_ptr<Logger> logger);
+  ~Context();
+
+  /// Disconnect from all accelerators associated with this context.
+  void disconnectAll();
 
   /// Create a context with a specific logger type.
   template <typename T, typename... Args>
-  static Context withLogger(Args &&...args) {
-    return Context(std::make_unique<T>(args...));
+  static std::unique_ptr<Context> withLogger(Args &&...args) {
+    return std::make_unique<Context>(std::make_unique<T>(args...));
   }
 
   /// Resolve a type id to the type.
@@ -49,9 +56,9 @@ public:
   /// Register a type with the context. Takes ownership of the pointer type.
   void registerType(Type *type);
 
-  /// Connect to an accelerator backend.
-  std::unique_ptr<AcceleratorConnection> connect(std::string backend,
-                                                 std::string connection);
+  /// Connect to an accelerator backend. Retains ownership internally and
+  /// returns a non-owning pointer.
+  AcceleratorConnection *connect(std::string backend, std::string connection);
 
   /// Register a logger with the accelerator. Assumes ownership of the logger.
   void setLogger(std::unique_ptr<Logger> logger) {
@@ -63,6 +70,7 @@ public:
 
 private:
   std::unique_ptr<Logger> logger;
+  std::vector<std::unique_ptr<AcceleratorConnection>> connections;
 
 private:
   using TypeCache = std::map<Type::ID, std::unique_ptr<Type>>;

esiaccel/include/esi/Manifest.h

@@ -65,8 +65,6 @@ private:
 
 } // namespace esi
 
-std::ostream &operator<<(std::ostream &os, const esi::AppID &id);
-std::ostream &operator<<(std::ostream &, const esi::AppIDPath &);
 std::ostream &operator<<(std::ostream &, const esi::ModuleInfo &);
 
 #endif // ESI_MANIFEST_H

esiaccel/include/esi/Services.h

@@ -25,10 +25,21 @@
 #include "esi/Ports.h"
 
 #include <cstdint>
+#include <list>
 
 namespace esi {
 class AcceleratorConnection;
 class Engine;
+namespace services {
+class Service;
+}
+
+// While building the design, keep around a std::map of active services indexed
+// by the service name. When a new service is encountered during descent, add it
+// to the table (perhaps overwriting one). Modifications to the table only apply
+// to the current branch, so copy this and update it at each level of the tree.
+using ServiceTable = std::map<std::string, services::Service *>;
+
 namespace services {
 
 /// Add a custom interface to a service client at a particular point in the
@@ -271,13 +282,20 @@ public:
     void connect();
     std::future<MessageData> call(const MessageData &arg);
 
+    const esi::Type *getArgType() const {
+      return dynamic_cast<const ChannelType *>(type->findChannel("arg").first)
+          ->getInner();
+    }
+
+    const esi::Type *getResultType() const {
+      return dynamic_cast<const ChannelType *>(
+                 type->findChannel("result").first)
+          ->getInner();
+    }
+
     virtual std::optional<std::string> toString() const override {
-      const esi::Type *argType =
-          dynamic_cast<const ChannelType *>(type->findChannel("arg").first)
-              ->getInner();
-      const esi::Type *resultType =
-          dynamic_cast<const ChannelType *>(type->findChannel("result").first)
-              ->getInner();
+      const esi::Type *argType = getArgType();
+      const esi::Type *resultType = getResultType();
       return "function " + resultType->getID() + "(" + argType->getID() + ")";
     }
 
@@ -320,13 +338,20 @@ public:
     void connect(std::function<MessageData(const MessageData &)> callback,
                  bool quick = false);
 
+    const esi::Type *getArgType() const {
+      return dynamic_cast<const ChannelType *>(type->findChannel("arg").first)
+          ->getInner();
+    }
+
+    const esi::Type *getResultType() const {
+      return dynamic_cast<const ChannelType *>(
+                 type->findChannel("result").first)
+          ->getInner();
+    }
+
     virtual std::optional<std::string> toString() const override {
-      const esi::Type *argType =
-          dynamic_cast<const ChannelType *>(type->findChannel("arg").first)
-              ->getInner();
-      const esi::Type *resultType =
-          dynamic_cast<const ChannelType *>(type->findChannel("result").first)
-              ->getInner();
+      const esi::Type *argType = getArgType();
+      const esi::Type *resultType = getResultType();
       return "callback " + resultType->getID() + "(" + argType->getID() + ")";
     }
 
@@ -351,18 +376,23 @@ public:
   virtual std::string getServiceSymbol() const override;
   virtual BundlePort *getPort(AppIDPath id,
                               const BundleType *type) const override;
+  virtual Service *getChildService(Service::Type service, AppIDPath id = {},
+                                   std::string implName = {},
+                                   ServiceImplDetails details = {},
+                                   HWClientDetails clients = {}) override;
+  MMIO::MMIORegion *getMMIORegion() const;
 
   /// A telemetry port which gets attached to a service port.
-  class Telemetry : public ServicePort {
+  class Metric : public ServicePort {
     friend class TelemetryService;
-    Telemetry(AppID id, const BundleType *type, PortMap channels);
+    Metric(AppID id, const BundleType *type, PortMap channels,
+           const TelemetryService *telemetryService,
+           std::optional<uint64_t> offset);
 
   public:
-    static Telemetry *get(AppID id, BundleType *type, WriteChannelPort &get,
-                          ReadChannelPort &data);
-
     void connect();
     std::future<MessageData> read();
+    uint64_t readInt();
 
     virtual std::optional<std::string> toString() const override {
       const esi::Type *dataType =
@@ -372,16 +402,24 @@ public:
     }
 
   private:
-    WriteChannelPort *get_req;
-    ReadChannelPort *data;
+    const TelemetryService *telemetryService;
+    MMIO::MMIORegion *mmio;
+    std::optional<uint64_t> offset;
   };
 
-  const std::map<AppIDPath, Telemetry *> &getTelemetryPorts() {
-    return telemetryPorts;
+  std::map<AppIDPath, Metric *> getTelemetryPorts() {
+    std::map<AppIDPath, Metric *> ports;
+    getTelemetryPorts(ports);
+    return ports;
   }
+  void getTelemetryPorts(std::map<AppIDPath, Metric *> &ports);
 
 private:
-  mutable std::map<AppIDPath, Telemetry *> telemetryPorts;
+  AppIDPath id;
+  mutable MMIO::MMIORegion *mmio;
+  std::map<AppIDPath, uint64_t> portAddressAssignments;
+  mutable std::map<AppIDPath, Metric *> telemetryPorts;
+  std::list<TelemetryService *> children;
 };
 
 /// Registry of services which can be instantiated directly by the Accelerator