esiaccel 0.2.3.dev49__cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl

esiaccel/__init__.py

@@ -0,0 +1,31 @@
+#  Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+#  See https://llvm.org/LICENSE.txt for license information.
+#  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+import sys
+import os
+from .accelerator import AcceleratorConnection, Context, LogLevel
+
+from .esiCppAccel import (AppID, Type, BundleType, ChannelType, ArrayType,
+                          StructType, BitsType, UIntType, SIntType)
+
+__all__ = [
+    "AcceleratorConnection", "AppID", "Context", "LogLevel", "Type",
+    "BundleType", "ChannelType", "ArrayType", "StructType", "BitsType",
+    "UIntType", "SIntType"
+]
+
+if sys.platform == "win32":
+  """Ensure that ESI libraries are in the dll path on Windows. Necessary to
+  call when users build against the esiaccel-provided prebuilt CMake/prebuilt
+  libraries, before they are loaded via. python.
+  """
+  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

@@ -0,0 +1,134 @@
+# ===-----------------------------------------------------------------------===#
+#  Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+#  See https://llvm.org/LICENSE.txt for license information.
+#  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+# ===-----------------------------------------------------------------------===#
+#
+# The structure of the Python classes and hierarchy roughly mirrors the C++
+# side, but wraps the C++ objects. The wrapper classes sometimes add convenience
+# functionality and serve to return wrapped versions of the returned objects.
+#
+# ===-----------------------------------------------------------------------===#
+
+from typing import Dict, List, Optional
+
+from .types import BundlePort
+from . import esiCppAccel as cpp
+
+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, 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(self.ctxt.cpp_ctxt,
+                        self.cpp_accel.sysinfo().json_manifest())
+
+  def sysinfo(self) -> cpp.SysInfo:
+    return self.cpp_accel.sysinfo()
+
+  def build_accelerator(self) -> "Accelerator":
+    return Accelerator(self.manifest().build_accelerator(self.cpp_accel))
+
+  def get_service_mmio(self) -> cpp.MMIO:
+    return self.cpp_accel.get_service_mmio()
+
+  def get_service_hostmem(self) -> cpp.HostMem:
+    return self.cpp_accel.get_service_hostmem()
+
+  def get_accelerator(self) -> "Accelerator":
+    """
+    Return an accelerator that may be owned by this accelerator connection.
+    If no accelerator is owned, will throw.
+    """
+    return Accelerator(self.cpp_accel.get_accelerator())
+
+
+from .esiCppAccel import HostMemOptions
+
+
+class HWModule:
+  """Represents either the top level or an instance of a hardware module."""
+
+  def __init__(self, parent: Optional["HWModule"], cpp_hwmodule: cpp.HWModule):
+    self.parent = parent
+    self.cpp_hwmodule = cpp_hwmodule
+
+  @property
+  def children(self) -> Dict[cpp.AppID, "Instance"]:
+    return {
+        name: Instance(self, inst)
+        for name, inst in self.cpp_hwmodule.children.items()
+    }
+
+  @property
+  def ports(self) -> Dict[cpp.AppID, BundlePort]:
+    return {
+        name: BundlePort(self, port)
+        for name, port in self.cpp_hwmodule.ports.items()
+    }
+
+  @property
+  def services(self) -> List[cpp.AppID]:
+    return self.cpp_hwmodule.services
+
+
+MMIO = cpp.MMIO
+
+
+class Instance(HWModule):
+  """Subclass of `HWModule` which represents a submodule instance. Adds an
+  AppID, which the top level doesn't have or need."""
+
+  def __init__(self, parent: Optional["HWModule"], cpp_instance: cpp.Instance):
+    super().__init__(parent, cpp_instance)
+    self.cpp_hwmodule: cpp.Instance = cpp_instance
+
+  @property
+  def id(self) -> cpp.AppID:
+    return self.cpp_hwmodule.id
+
+
+class Accelerator(HWModule):
+  """Root of the accelerator design hierarchy."""
+
+  def __init__(self, cpp_accelerator: cpp.Accelerator):
+    super().__init__(None, cpp_accelerator)
+    self.cpp_hwmodule = cpp_accelerator

esiaccel/bin/esi-cosim.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+
+# ===- esi-cosim.py - ESI cosimulation launch utility --------*- python -*-===//
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+#
+# ===----------------------------------------------------------------------===//
+#
+# Utility script to start a simulation and launch a command to interact with it
+# via ESI cosimulation.
+#
+# ===----------------------------------------------------------------------===//
+
+import argparse
+from pathlib import Path
+import sys
+import textwrap
+from typing import Dict, List
+
+from esiaccel.cosim.questa import Questa
+from esiaccel.cosim.verilator import Verilator
+from esiaccel.cosim.simulator import SourceFiles
+
+
+def __main__(args):
+  argparser = argparse.ArgumentParser(
+      description="Wrap a 'inner_cmd' in an ESI cosimulation environment.",
+      formatter_class=argparse.RawDescriptionHelpFormatter,
+      epilog=textwrap.dedent("""
+        Notes:
+          - For Verilator, libEsiCosimDpiServer.so must be in the dynamic
+          library runtime search path (LD_LIBRARY_PATH) and link time path
+          (LIBRARY_PATH). If it is installed to a standard location (e.g.
+          /usr/lib), this should be handled automatically.
+          - This script needs to sit in the same directory as the ESI support
+          SystemVerilog (e.g. Cosim_DpiPkg.sv, Cosim_MMIO.sv, etc.). It can,
+          however, be soft linked to a different location.
+          - The simulator executable(s) must be in your PATH.
+      """))
+
+  argparser.add_argument(
+      "--sim",
+      type=str,
+      default="verilator",
+      help="Name of the RTL simulator to use or path to an executable.")
+  argparser.add_argument("--rundir",
+                         default="run",
+                         help="Directory in which simulation should be run.")
+  argparser.add_argument(
+      "--top",
+      default="ESI_Cosim_Top",
+      help="Name of the 'top' module to use in the simulation.")
+  argparser.add_argument("--no-compile",
+                         action="store_true",
+                         help="Do not run the compile.")
+  argparser.add_argument("--debug",
+                         action="store_true",
+                         help="Enable debug output.")
+  argparser.add_argument("--gui",
+                         action="store_true",
+                         help="Run the simulator in GUI mode (if supported).")
+  argparser.add_argument("--source",
+                         help="Directories containing the source files.",
+                         default="hw")
+
+  argparser.add_argument("inner_cmd",
+                         nargs=argparse.REMAINDER,
+                         help="Command to run in the simulation environment.")
+
+  argparser.add_argument(
+      "--server-only",
+      action="store_true",
+      help="Only run the cosim server, and do not run any inner command.")
+
+  if len(args) <= 1:
+    argparser.print_help()
+    return
+  args = argparser.parse_args(args[1:])
+
+  sources = SourceFiles(args.top)
+  sources.add_dir(Path(args.source))
+
+  if args.sim == "verilator":
+    sim = Verilator(sources, Path(args.rundir), args.debug)
+  elif args.sim == "questa":
+    sim = Questa(sources, Path(args.rundir), args.debug)
+  else:
+    print("Unknown simulator: " + args.sim)
+    print("Supported simulators: ")
+    print("  - verilator")
+    print("  - questa")
+    return 1
+
+  if not args.no_compile:
+    rc = sim.compile()
+    if rc != 0:
+      return rc
+  return sim.run(args.inner_cmd[1:], gui=args.gui, server_only=args.server_only)
+
+
+if __name__ == '__main__':
+  sys.exit(__main__(sys.argv))

esiaccel/cmake/esiaccelConfig.cmake

@@ -0,0 +1,49 @@
+add_library(esiaccel::ESICppRuntime SHARED IMPORTED)
+set_target_properties(esiaccel::ESICppRuntime PROPERTIES
+  INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_LIST_DIR}/../include"
+)
+
+if(WIN32)
+  set_target_properties(esiaccel::ESICppRuntime PROPERTIES
+    IMPORTED_LOCATION "${CMAKE_CURRENT_LIST_DIR}/../ESICppRuntime.dll"
+    IMPORTED_IMPLIB "${CMAKE_CURRENT_LIST_DIR}/../ESICppRuntime.lib"
+  )
+else()
+  set_target_properties(esiaccel::ESICppRuntime PROPERTIES
+    IMPORTED_LOCATION "${CMAKE_CURRENT_LIST_DIR}/../lib/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}/../lib/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}/../lib/libCosimBackend.so"
+  )
+endif()

esiaccel/codegen.py

@@ -0,0 +1,197 @@
+#  Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+#  See https://llvm.org/LICENSE.txt for license information.
+#  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+# Code generation from ESI manifests to source code. C++ header support included
+# with the runtime, though it is intended to be extensible for other languages.
+
+from typing import List, TextIO, Type, Optional
+from .accelerator import AcceleratorConnection, Context
+from .esiCppAccel import ModuleInfo
+from . import types
+
+import argparse
+from pathlib import Path
+import textwrap
+import sys
+
+_thisdir = Path(__file__).absolute().resolve().parent
+
+
+class Generator:
+  """Base class for all generators."""
+
+  language: Optional[str] = None
+
+  def __init__(self, conn: AcceleratorConnection):
+    self.manifest = conn.manifest()
+
+  def generate(self, output_dir: Path, system_name: str):
+    raise NotImplementedError("Generator.generate() must be overridden")
+
+
+class CppGenerator(Generator):
+  """Generate C++ headers from an ESI manifest."""
+
+  language = "C++"
+
+  # Supported bit widths for lone integer types.
+  int_width_support = set([8, 16, 32, 64])
+
+  def get_type_str(self, type: types.ESIType) -> str:
+    """Get the textual code for the storage class of a type.
+
+    Examples: uint32_t, int64_t, CustomStruct."""
+
+    if isinstance(type, (types.BitsType, types.IntType)):
+      if type.bit_width not in self.int_width_support:
+        raise ValueError(f"Unsupported integer width: {type.bit_width}")
+      if isinstance(type, (types.BitsType, types.UIntType)):
+        return f"uint{type.bit_width}_t"
+      return f"int{type.bit_width}_t"
+    raise NotImplementedError(f"Type '{type}' not supported for C++ generation")
+
+  def get_consts_str(self, module_info: ModuleInfo) -> str:
+    """Get the C++ code for a constant in a module."""
+    const_strs: List[str] = [
+        f"static constexpr {self.get_type_str(const.type)} "
+        f"{name} = 0x{const.value:x};"
+        for name, const in module_info.constants.items()
+    ]
+    return "\n".join(const_strs)
+
+  def write_modules(self, output_dir: Path, system_name: str):
+    """Write the C++ header. One for each module in the manifest."""
+
+    for module_info in self.manifest.module_infos:
+      s = f"""
+      /// Generated header for {system_name} module {module_info.name}.
+      #pragma once
+      #include "types.h"
+
+      namespace {system_name} {{
+      class {module_info.name} {{
+      public:
+        {self.get_consts_str(module_info)}
+      }};
+      }} // namespace {system_name}
+      """
+
+      hdr_file = output_dir / f"{module_info.name}.h"
+      with open(hdr_file, "w") as hdr:
+        hdr.write(textwrap.dedent(s))
+
+  def write_type(self, hdr: TextIO, type: types.ESIType):
+    if isinstance(type, (types.BitsType, types.IntType)):
+      # Bit vector types use standard C++ types.
+      return
+    raise NotImplementedError(f"Type '{type}' not supported for C++ generation")
+
+  def write_types(self, output_dir: Path, system_name: str):
+    hdr_file = output_dir / "types.h"
+    with open(hdr_file, "w") as hdr:
+      hdr.write(
+          textwrap.dedent(f"""
+      // Generated header for {system_name} types.
+      #pragma once
+
+      #include <cstdint>
+
+      namespace {system_name} {{
+      """))
+
+      for type in self.manifest.type_table:
+        try:
+          self.write_type(hdr, type)
+        except NotImplementedError:
+          sys.stderr.write(
+              f"Warning: type '{type}' not supported for C++ generation\n")
+
+      hdr.write(
+          textwrap.dedent(f"""
+      }} // namespace {system_name}
+      """))
+
+  def generate(self, output_dir: Path, system_name: str):
+    self.write_types(output_dir, system_name)
+    self.write_modules(output_dir, system_name)
+
+
+def run(generator: Type[Generator] = CppGenerator,
+        cmdline_args=sys.argv) -> int:
+  """Create and run a generator reading options from the command line."""
+
+  argparser = argparse.ArgumentParser(
+      description=f"Generate {generator.language} headers from an ESI manifest",
+      formatter_class=argparse.RawDescriptionHelpFormatter,
+      epilog=textwrap.dedent("""
+        Can read the manifest from either a file OR a running accelerator.
+
+        Usage examples:
+          # To read the manifest from a file:
+          esi-cppgen --file /path/to/manifest.json
+
+          # To read the manifest from a running accelerator:
+          esi-cppgen --platform cosim --connection localhost:1234
+      """))
+
+  argparser.add_argument("--file",
+                         type=str,
+                         default=None,
+                         help="Path to the manifest file.")
+  argparser.add_argument(
+      "--platform",
+      type=str,
+      help="Name of platform for live accelerator connection.")
+  argparser.add_argument(
+      "--connection",
+      type=str,
+      help="Connection string for live accelerator connection.")
+  argparser.add_argument(
+      "--output-dir",
+      type=str,
+      default="esi",
+      help="Output directory for generated files. Recommend adding either `esi`"
+      " or the system name to the end of the path so as to avoid header name"
+      "conflicts. Defaults to `esi`")
+  argparser.add_argument(
+      "--system-name",
+      type=str,
+      default="esi_system",
+      help="Name of the ESI system. For C++, this will be the namespace.")
+
+  if (len(cmdline_args) <= 1):
+    argparser.print_help()
+    return 1
+  args = argparser.parse_args(cmdline_args[1:])
+
+  if args.file is not None and args.platform is not None:
+    print("Cannot specify both --file and --platform")
+    return 1
+
+  conn: AcceleratorConnection
+  if args.file is not None:
+    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 = Context.default().connect(args.platform, args.connection)
+  else:
+    print("Must specify either --file or --platform")
+    return 1
+
+  output_dir = Path(args.output_dir)
+  if output_dir.exists() and not output_dir.is_dir():
+    print(f"Output directory {output_dir} is not a directory")
+    return 1
+  if not output_dir.exists():
+    output_dir.mkdir(parents=True)
+
+  gen = generator(conn)
+  gen.generate(output_dir, args.system_name)
+  return 0
+
+
+if __name__ == '__main__':
+  sys.exit(run())

esiaccel/cosim/Cosim_CycleCount.sv

@@ -0,0 +1,84 @@
+//===- Cosim_CycleCount.sv - ESI cycle counter module -------*- verilog -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// A cosimulated design should instantiate this ONCE to provide cycle count
+// information to the ESI runtime. The module maintains a 64-bit cycle counter
+// and uses request/response channels to provide the count to the runtime.
+//
+//===----------------------------------------------------------------------===//
+
+import Cosim_DpiPkg::*;
+
+module Cosim_CycleCount
+#(
+  // Core clock frequency in Hz. Used by the runtime to convert cycles to time.
+  parameter longint unsigned CORE_CLOCK_FREQUENCY_HZ = 0
+)(
+  input logic clk,
+  input logic rst
+);
+
+  // 64-bit cycle counter.
+  longint unsigned cycle_count;
+
+  always_ff @(posedge clk) begin
+    if (rst)
+      cycle_count <= 0;
+    else
+      cycle_count <= cycle_count + 1;
+  end
+
+  // Request channel (From Host)
+  // 0-bit message used as a trigger.
+  wire req_valid;
+  wire req_ready;
+
+  Cosim_Endpoint_FromHost #(
+    .ENDPOINT_ID("__cosim_cycle_count.arg"),
+    .FROM_HOST_TYPE_ID("!esi.channel<i1>"),
+    .FROM_HOST_SIZE_BITS(1)
+  ) req_ep (
+    .clk(clk),
+    .rst(rst),
+    .DataOutValid(req_valid),
+    .DataOutReady(req_ready),
+    .DataOut()
+  );
+
+  // Response channel (To Host)
+  typedef struct packed {
+    longint unsigned cycle;
+    longint unsigned freq;
+  } RespStruct;
+
+  wire resp_ready;
+  wire resp_valid;
+  RespStruct resp_data;
+
+  assign resp_data.cycle = cycle_count;
+  assign resp_data.freq = CORE_CLOCK_FREQUENCY_HZ;
+
+  // Handshake logic:
+  // When request arrives (req_valid), we are ready to send response (resp_valid).
+  // We consume request only when response is accepted.
+  assign resp_valid = req_valid;
+  assign req_ready = resp_ready;
+
+  Cosim_Endpoint_ToHost #(
+    .ENDPOINT_ID("__cosim_cycle_count.result"),
+    .TO_HOST_TYPE_ID("struct{cycle:int<64>,freq:int<64>}"),
+    .TO_HOST_SIZE_BITS(128)
+  ) resp_ep (
+    .clk(clk),
+    .rst(rst),
+    .DataInValid(resp_valid),
+    .DataInReady(resp_ready),
+    .DataIn(resp_data)
+  );
+
+endmodule

esiaccel/cosim/Cosim_DpiPkg.sv

@@ -0,0 +1,85 @@
+//===- Cosim_DpiPkg.sv - ESI cosim DPI declarations ---------*- verilog -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Package: Cosim_DpiPkg
+//
+// DPI-exposed funcs for cosimserver cosimulation unit-test.
+//
+//===----------------------------------------------------------------------===//
+
+package Cosim_DpiPkg;
+
+// --------------------- Cosim RPC Server --------------------------------------
+
+// Start cosimserver (spawns server for HW-initiated work, listens for
+// connections from new SW-clients).
+import "DPI-C" sv2cCosimserverInit = function int cosim_init();
+
+// Teardown cosimserver (disconnects from primary server port, stops connections
+// from active clients).
+import "DPI-C" sv2cCosimserverFinish = function void cosim_finish();
+
+// --------------------- Endpoint Management -----------------------------------
+
+// Register simulated device endpoints.
+// - return 0 on success, non-zero on failure (duplicate EP registered).
+import "DPI-C" sv2cCosimserverEpRegister =
+  function int cosim_ep_register(
+    // The endpoint ID.
+    input string endpoint_id,
+    // The ESI type id which the _RPC client_ is sending us.
+    input string from_host_type_id,
+    // The send types max size, in bytes.
+    input int from_host_type_size,
+    // The ESI type id which we are sending to the _RPC client_.
+    input string to_host_type_id,
+    // The recv types max size, in bytes.
+    input int to_host_type_size);
+
+// --------------------- Endpoint Accessors ------------------------------------
+
+// Attempt to send data to a client.
+// - return 0 on success, negative on failure (unregistered EP).
+import "DPI-C" sv2cCosimserverEpTryPut =
+  function int cosim_ep_tryput(
+    // The ID of the endpoint to which the data should be sent.
+    input string endpoint_id,
+    // A data buffer.
+    input byte unsigned data[],
+    // (Optional) Size of the buffer. If negative, will be dynamically detected.
+    input int data_size = -1
+    );
+
+// Attempt to recieve data from a client.
+//   - Returns negative when call failed (e.g. EP not registered).
+//   - If no message, return 0 with size_bytes == 0.
+//   - Assumes buffer is large enough to contain entire message. Fails if not
+//   large enough. (In the future, will add support for getting the message into
+//   a fixed-size buffer over multiple calls.)
+import "DPI-C" sv2cCosimserverEpTryGet =
+  function int cosim_ep_tryget(
+    // The ID of the endpoint from which data should be recieved.
+    input string endpoint_id,
+    // The buffer in which to put the data. This should be 'output', but the
+    // open source simulator Verilator doesn't seem to have a way to do this.
+    inout byte unsigned data[],
+    // Input: indicates the size of the data[] buffer. If -1, dynamically detect
+    // size.
+    // Output: the size of the message.
+    inout int unsigned data_size
+    );
+
+// --------------------- Manifest ----------------------------------------------
+
+import "DPI-C" sv2cCosimserverSetManifest =
+  function void cosim_set_manifest(
+    input int signed esi_version,
+    input byte unsigned compressed_manifest[]
+  );
+
+endpackage // Cosim_DpiPkg