esiaccel 0.1.5.dev254__cp311-cp311-win_amd64.whl → 0.2.3.dev47__cp311-cp311-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/cmake/esiaccelConfig.cmake

@@ -13,3 +13,37 @@ else()
     IMPORTED_LOCATION "${CMAKE_CURRENT_LIST_DIR}/.././libESICppRuntime.so"
   )
 endif()
+
+add_library(esiaccel::CosimRpc SHARED IMPORTED)
+set_target_properties(esiaccel::CosimRpc PROPERTIES
+  INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_LIST_DIR}/../include"
+  INTERFACE_LINK_LIBRARIES esiaccel::ESICppRuntime
+)
+
+if(WIN32)
+  set_target_properties(esiaccel::CosimRpc PROPERTIES
+    IMPORTED_LOCATION "${CMAKE_CURRENT_LIST_DIR}/../CosimRpc.dll"
+    IMPORTED_IMPLIB "${CMAKE_CURRENT_LIST_DIR}/../CosimRpc.lib"
+  )
+else()
+  set_target_properties(esiaccel::CosimRpc PROPERTIES
+    IMPORTED_LOCATION "${CMAKE_CURRENT_LIST_DIR}/.././libCosimRpc.so"
+  )
+endif()
+
+add_library(esiaccel::CosimBackend SHARED IMPORTED)
+set_target_properties(esiaccel::CosimBackend PROPERTIES
+  INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_LIST_DIR}/../include"
+  INTERFACE_LINK_LIBRARIES "esiaccel::ESICppRuntime;esiaccel::CosimRpc"
+)
+
+if(WIN32)
+  set_target_properties(esiaccel::CosimBackend PROPERTIES
+    IMPORTED_LOCATION "${CMAKE_CURRENT_LIST_DIR}/../CosimBackend.dll"
+    IMPORTED_IMPLIB "${CMAKE_CURRENT_LIST_DIR}/../CosimBackend.lib"
+  )
+else()
+  set_target_properties(esiaccel::CosimBackend PROPERTIES
+    IMPORTED_LOCATION "${CMAKE_CURRENT_LIST_DIR}/.././libCosimBackend.so"
+  )
+endif()

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/include/esi/Accelerator.h

@@ -65,8 +65,8 @@ public:
   Accelerator(std::optional<ModuleInfo> info,
               std::vector<std::unique_ptr<Instance>> children,
               std::vector<services::Service *> services,
-              std::vector<std::unique_ptr<BundlePort>> &ports)
-      : HWModule(info, std::move(children), services, ports) {}
+              std::vector<std::unique_ptr<BundlePort>> &&ports)
+      : HWModule(info, std::move(children), services, std::move(ports)) {}
 };
 
 //===----------------------------------------------------------------------===//
@@ -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

@@ -43,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);
 
@@ -53,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);
 
@@ -106,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) {}
@@ -126,6 +136,7 @@ public:
 
   /// 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(); }
@@ -158,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/Design.h

@@ -45,11 +45,15 @@ class Service;
 
 /// Represents either the top level or an instance of a hardware module.
 class HWModule {
+public:
+  HWModule(const HWModule &) = delete;
+  HWModule &operator=(const HWModule &) = delete;
+
 protected:
   HWModule(std::optional<ModuleInfo> info,
            std::vector<std::unique_ptr<Instance>> children,
            std::vector<services::Service *> services,
-           std::vector<std::unique_ptr<BundlePort>> &ports);
+           std::vector<std::unique_ptr<BundlePort>> &&ports);
 
 public:
   virtual ~HWModule() = default;
@@ -112,11 +116,12 @@ public:
   Instance(AppID id, std::optional<ModuleInfo> info,
            std::vector<std::unique_ptr<Instance>> children,
            std::vector<services::Service *> services,
-           std::vector<std::unique_ptr<BundlePort>> &ports)
-      : HWModule(info, std::move(children), services, ports), id(id) {}
+           std::vector<std::unique_ptr<BundlePort>> &&ports)
+      : HWModule(info, std::move(children), services, std::move(ports)),
+        id(id) {}
 
   /// Get the instance's ID, which it will always have.
-  const AppID getID() const { return id; }
+  AppID getID() const { return id; }
 
 protected:
   const AppID id;

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