esiaccel 0.0.10__cp310-cp310-win_amd64.whl → 0.1.5.dev406__cp310-cp310-win_amd64.whl

esiaccel/include/esi/CLI.h

@@ -0,0 +1,77 @@
+//===- CLI.h - ESI runtime tool CLI parser common ---------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains the common CLI parser code for ESI runtime tools. Exposed
+// publicly so that out-of-tree tools can use it. This is a header-only library
+// to make compilation easier for out-of-tree tools.
+//
+// DO NOT EDIT!
+// This file is distributed as part of an ESI package. The source for this file
+// should always be modified within CIRCT (lib/dialect/ESI/runtime/cpp).
+//
+//===----------------------------------------------------------------------===//
+
+// NOLINTNEXTLINE(llvm-header-guard)
+#ifndef ESI_CLI_H
+#define ESI_CLI_H
+
+#include "CLI/CLI.hpp"
+#include "esi/Context.h"
+
+namespace esi {
+
+/// Common options and code for ESI runtime tools.
+class CliParser : public CLI::App {
+public:
+  CliParser(const std::string &toolName)
+      : CLI::App(toolName), debug(false), verbose(false) {
+    add_option("backend", backend, "Backend to use for connection")->required();
+    add_option("connection", connStr,
+               "Connection string to use for accelerator communication")
+        ->required();
+    add_flag("--debug", debug, "Enable debug logging");
+#ifdef ESI_RUNTIME_TRACE
+    add_flag("--trace", trace, "Enable trace logging");
+#endif
+    add_flag("-v,--verbose", verbose, "Enable verbose (info) logging");
+    require_subcommand(0, 1);
+  }
+
+  /// Run the parser.
+  int esiParse(int argc, const char **argv) {
+    CLI11_PARSE(*this, argc, argv);
+    if (trace)
+      ctxt = Context::withLogger<ConsoleLogger>(Logger::Level::Trace);
+    else if (debug)
+      ctxt = Context::withLogger<ConsoleLogger>(Logger::Level::Debug);
+    else if (verbose)
+      ctxt = Context::withLogger<ConsoleLogger>(Logger::Level::Info);
+    return 0;
+  }
+
+  /// Connect to the accelerator using the specified backend and connection.
+  std::unique_ptr<AcceleratorConnection> connect() {
+    return ctxt.connect(backend, connStr);
+  }
+
+  /// Get the context.
+  Context &getContext() { return ctxt; }
+
+protected:
+  Context ctxt;
+
+  std::string backend;
+  std::string connStr;
+  bool trace = false;
+  bool debug = false;
+  bool verbose = false;
+};
+
+} // namespace esi
+
+#endif // ESI_CLI_H

esiaccel/include/esi/Common.h

@@ -20,11 +20,13 @@
 #include <cstdint>
 #include <map>
 #include <optional>
+#include <span>
 #include <stdexcept>
 #include <string>
 #include <vector>
 
 namespace esi {
+class Type;
 
 //===----------------------------------------------------------------------===//
 // Common accelerator description types.
@@ -34,7 +36,6 @@ struct AppID {
   std::string name;
   std::optional<uint32_t> idx;
 
-  AppID(const AppID &) = default;
   AppID(const std::string &name, std::optional<uint32_t> idx = std::nullopt)
       : name(name), idx(idx) {}
 
@@ -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);
 
@@ -49,18 +57,26 @@ class AppIDPath : public std::vector<AppID> {
 public:
   using std::vector<AppID>::vector;
 
-  AppIDPath operator+(const AppIDPath &b);
+  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);
 
+struct Constant {
+  std::any value;
+  std::optional<const Type *> type;
+};
+
 struct ModuleInfo {
-  const std::optional<std::string> name;
-  const std::optional<std::string> summary;
-  const std::optional<std::string> version;
-  const std::optional<std::string> repo;
-  const std::optional<std::string> commitHash;
-  const std::map<std::string, std::any> extra;
+  std::optional<std::string> name;
+  std::optional<std::string> summary;
+  std::optional<std::string> version;
+  std::optional<std::string> repo;
+  std::optional<std::string> commitHash;
+  std::map<std::string, Constant> constants;
+  std::map<std::string, std::any> extra;
 };
 
 /// A description of a service port. Used pretty exclusively in setting up the
@@ -70,11 +86,22 @@ struct ServicePortDesc {
   std::string portName;
 };
 
+/// Details about how to connect to a particular channel.
+struct ChannelAssignment {
+  /// The name of the type of connection. Typically, the name of the DMA engine
+  /// or "cosim" if a cosimulation channel is being used.
+  std::string type;
+  /// Implementation-specific options.
+  std::map<std::string, std::any> implOptions;
+};
+using ChannelAssignments = std::map<std::string, ChannelAssignment>;
+
 /// A description of a hardware client. Used pretty exclusively in setting up
 /// the design.
 struct HWClientDetail {
   AppIDPath relPath;
   ServicePortDesc port;
+  ChannelAssignments channelAssignments;
   std::map<std::string, std::any> implOptions;
 };
 using HWClientDetails = std::vector<HWClientDetail>;
@@ -87,13 +114,32 @@ 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) {}
   ~MessageData() = default;
 
   const uint8_t *getBytes() const { return data.data(); }
+
+  /// 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(); }
 
   /// Cast to a type. Throws if the size of the data does not match the size of
   /// the message. The lifetime of the resulting pointer is tied to the lifetime
@@ -113,6 +159,9 @@ public:
     return MessageData(reinterpret_cast<const uint8_t *>(&t), sizeof(T));
   }
 
+  /// Convert the data to a hex string.
+  std::string toHex() const;
+
 private:
   std::vector<uint8_t> data;
 };
@@ -120,14 +169,14 @@ 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.
 //===----------------------------------------------------------------------===//
 
 namespace esi {
-std::string toHex(uint32_t val);
+std::string toHex(void *val);
+std::string toHex(uint64_t val);
 } // namespace esi
 
 #endif // ESI_COMMON_H

esiaccel/include/esi/Context.h

@@ -16,6 +16,7 @@
 #ifndef ESI_CONTEXT_H
 #define ESI_CONTEXT_H
 
+#include "esi/Logging.h"
 #include "esi/Types.h"
 
 #include <exception>
@@ -28,8 +29,16 @@ class AcceleratorConnection;
 /// AcceleratorConnections, Accelerators, and Manifests must all share a
 /// context. It owns all the types, uniquifying them.
 class Context {
-
 public:
+  Context() : logger(std::make_unique<ConsoleLogger>(Logger::Level::Warning)) {}
+  Context(std::unique_ptr<Logger> logger) : logger(std::move(logger)) {}
+
+  /// 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...));
+  }
+
   /// Resolve a type id to the type.
   std::optional<const Type *> getType(Type::ID id) const {
     if (auto f = types.find(id); f != types.end())
@@ -44,6 +53,17 @@ public:
   std::unique_ptr<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) {
+    if (!logger)
+      throw std::invalid_argument("logger must not be null");
+    this->logger = std::move(logger);
+  }
+  inline Logger &getLogger() { return *logger; }
+
+private:
+  std::unique_ptr<Logger> logger;
+
 private:
   using TypeCache = std::map<Type::ID, std::unique_ptr<Type>>;
   TypeCache types;

esiaccel/include/esi/Design.h

@@ -73,8 +73,10 @@ public:
     return ret;
   }
   /// Access the module's ports by ID.
-  const std::map<AppID, const BundlePort &> &getPorts() const {
-    return portIndex;
+  const std::map<AppID, BundlePort &> &getPorts() const { return portIndex; }
+  /// Access the services provided by this module.
+  const std::vector<services::Service *> &getServices() const {
+    return services;
   }
 
   /// Master poll method. Calls the `poll` method on all locally owned ports and
@@ -82,13 +84,22 @@ public:
   /// the `poll` calls returns true.
   bool poll();
 
+  /// Attempt to resolve a path to a module instance. If a child is not found,
+  /// return null and set lastLookup to the path which wasn't found.
+  const HWModule *resolveInst(const AppIDPath &path,
+                              AppIDPath &lastLookup) const;
+
+  /// Attempt to resolve a path to a port. If a child or port is not found,
+  /// return null and set lastLookup to the path which wasn't found.
+  BundlePort *resolvePort(const AppIDPath &path, AppIDPath &lastLookup) const;
+
 protected:
   const std::optional<ModuleInfo> info;
   const std::vector<std::unique_ptr<Instance>> children;
   const std::map<AppID, Instance *> childIndex;
   const std::vector<services::Service *> services;
   const std::vector<std::unique_ptr<BundlePort>> ports;
-  const std::map<AppID, const BundlePort &> portIndex;
+  const std::map<AppID, BundlePort &> portIndex;
 };
 
 /// Subclass of `HWModule` which represents a submodule instance. Adds an AppID,

esiaccel/include/esi/Engines.h

@@ -0,0 +1,124 @@
+//===- Engines.h - Implement port communication -----------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// DO NOT EDIT!
+// This file is distributed as part of an ESI package. The source for this file
+// should always be modified within CIRCT.
+//
+//===----------------------------------------------------------------------===//
+//
+// Engines (as in DMA engine) implement the actual communication between the
+// host and the accelerator. They are low level of the ESI runtime API and are
+// not intended to be used directly by users.
+//
+// They are called "engines" rather than "DMA engines" since communication need
+// not be implemented via DMA.
+//
+//===----------------------------------------------------------------------===//
+
+// NOLINTNEXTLINE(llvm-header-guard)
+#ifndef ESI_ENGINGES_H
+#define ESI_ENGINGES_H
+
+#include "esi/Common.h"
+#include "esi/Ports.h"
+#include "esi/Services.h"
+#include "esi/Utils.h"
+
+#include <cassert>
+#include <future>
+
+namespace esi {
+class Accelerator;
+
+/// Engines implement the actual channel communication between the host and the
+/// accelerator. Engines can support multiple channels. They are low level of
+/// the ESI runtime API and are not intended to be used directly by users.
+class Engine {
+public:
+  Engine(AcceleratorConnection &conn) : connected(false), conn(conn) {}
+  virtual ~Engine() = default;
+  /// Start the engine, if applicable.
+  virtual void connect() { connected = true; };
+  /// Stop the engine, if applicable.
+  virtual void disconnect() { connected = false; };
+  /// Get a port for a channel, from the cache if it exists or create it. An
+  /// engine may override this method if different behavior is desired.
+  virtual ChannelPort &requestPort(AppIDPath idPath,
+                                   const std::string &channelName,
+                                   BundleType::Direction dir, const Type *type);
+
+protected:
+  /// Each engine needs to know how to create a ports. This method is called if
+  /// a port doesn't exist in the engine cache.
+  virtual std::unique_ptr<ChannelPort>
+  createPort(AppIDPath idPath, const std::string &channelName,
+             BundleType::Direction dir, const Type *type) = 0;
+
+  bool connected;
+  AcceleratorConnection &conn;
+
+private:
+  std::map<std::pair<AppIDPath, std::string>, std::unique_ptr<ChannelPort>>
+      ownedPorts;
+};
+
+/// Since engines can support multiple channels BUT not necessarily all of the
+/// channels in a bundle, a mapping from bundle channels to engines is needed.
+class BundleEngineMap {
+  friend class AcceleratorConnection;
+
+public:
+  /// Request ports for all the channels in a bundle. If the engine doesn't
+  /// exist for a particular channel, skip said channel.
+  PortMap requestPorts(const AppIDPath &idPath,
+                       const BundleType *bundleType) const;
+
+private:
+  /// Set a particlar engine for a particular channel. Should only be called by
+  /// AcceleratorConnection while registering engines.
+  void setEngine(const std::string &channelName, Engine *engine);
+  std::map<std::string, Engine *> bundleEngineMap;
+};
+
+namespace registry {
+
+/// Create an engine by name. This is the primary way to create engines for
+/// "normal" backends.
+std::unique_ptr<Engine> createEngine(AcceleratorConnection &conn,
+                                     const std::string &dmaEngineName,
+                                     AppIDPath idPath,
+                                     const ServiceImplDetails &details,
+                                     const HWClientDetails &clients);
+
+namespace internal {
+
+/// Engines can register themselves for pluggable functionality.
+using EngineCreate = std::function<std::unique_ptr<Engine>(
+    AcceleratorConnection &conn, AppIDPath idPath,
+    const ServiceImplDetails &details, const HWClientDetails &clients)>;
+void registerEngine(const std::string &name, EngineCreate create);
+
+/// Helper struct to register engines.
+template <typename TEngine>
+struct RegisterEngine {
+  RegisterEngine(const char *name) { registerEngine(name, &TEngine::create); }
+};
+
+#define CONCAT_(prefix, suffix) prefix##suffix
+#define CONCAT(prefix, suffix) CONCAT_(prefix, suffix)
+#define REGISTER_ENGINE(Name, TEngine)                                         \
+  static ::esi::registry::internal::RegisterEngine<TEngine> CONCAT(            \
+      __register_engine__, __LINE__)(Name)
+
+} // namespace internal
+} // namespace registry
+
+} // namespace esi
+
+#endif // ESI_PORTS_H

esiaccel/include/esi/Logging.h

@@ -0,0 +1,231 @@
+//===- Logging.h - ESI Runtime logging --------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// ESI runtime logging is very simple but very flexible. Rather than mandating a
+// particular logging library, it allows users to hook into their existing
+// logging system by implementing a simple interface.
+//
+//===----------------------------------------------------------------------===//
+//
+// DO NOT EDIT!
+// This file is distributed as part of an ESI package. The source for this file
+// should always be modified within CIRCT.
+//
+//===----------------------------------------------------------------------===//
+
+// NOLINTNEXTLINE(llvm-header-guard)
+#ifndef ESI_LOGGING_H
+#define ESI_LOGGING_H
+
+#include <any>
+#include <functional>
+#include <iosfwd>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <string>
+
+namespace esi {
+
+class Logger {
+public:
+  enum class Level {
+    Trace, // Trace is even more detailed than debug and requires a compiler
+           // flag to be enabled when the runtime is built. Allows clients to do
+           // things like log every single message or interaction.
+    Debug, // Information useful when trying to debug an application.
+    Info,  // General information, like connecting to an accelerator.
+    Warning, // May indicate a problem.
+    Error,   // Many errors will be followed by exceptions which may get caught.
+  };
+  Logger(bool debugEnabled, bool traceEnabled)
+      : debugEnabled(debugEnabled), traceEnabled(traceEnabled) {}
+  virtual ~Logger() = default;
+  bool getDebugEnabled() { return debugEnabled; }
+  bool getTraceEnabled() { return traceEnabled; }
+
+  /// Report a log message.
+  /// Arguments:
+  ///   level: The log level as defined by the 'Level' enum above.
+  ///   subsystem: The subsystem that generated the log message.
+  ///   msg: The log message.
+  ///   details: Optional additional structured details to include in the log
+  ///            message. If there are no details, this should be nullptr.
+  virtual void
+  log(Level level, const std::string &subsystem, const std::string &msg,
+      const std::map<std::string, std::any> *details = nullptr) = 0;
+
+  /// Report an error.
+  virtual void error(const std::string &subsystem, const std::string &msg,
+                     const std::map<std::string, std::any> *details = nullptr) {
+    log(Level::Error, subsystem, msg, details);
+  }
+  /// Report a warning.
+  virtual void
+  warning(const std::string &subsystem, const std::string &msg,
+          const std::map<std::string, std::any> *details = nullptr) {
+    log(Level::Warning, subsystem, msg, details);
+  }
+  /// Report an informational message.
+  virtual void info(const std::string &subsystem, const std::string &msg,
+                    const std::map<std::string, std::any> *details = nullptr) {
+    log(Level::Info, subsystem, msg, details);
+  }
+
+  /// Report a debug message. This is not virtual so that it can be inlined to
+  /// minimize performance impact that debug messages have, allowing debug
+  /// messages in Release builds.
+  inline void debug(const std::string &subsystem, const std::string &msg,
+                    const std::map<std::string, std::any> *details = nullptr) {
+    if (debugEnabled)
+      debugImpl(subsystem, msg, details);
+  }
+  /// Call the debug function callback only if debug is enabled then log a debug
+  /// message. Allows users to run heavy weight debug message generation code
+  /// only when debug is enabled, which in turns allows users to provide
+  /// fully-featured debug messages in Release builds with minimal performance
+  /// impact. Not virtual so that it can be inlined.
+  inline void
+  debug(std::function<
+        void(std::string &subsystem, std::string &msg,
+             std::unique_ptr<std::map<std::string, std::any>> &details)>
+            debugFunc) {
+    if (debugEnabled)
+      debugImpl(debugFunc);
+  }
+
+  /// Log a trace message. If tracing is not enabled, this is a no-op. Since it
+  /// is inlined, the compiler will hopefully optimize it away creating a
+  /// zero-overhead call. This means that clients are free to go crazy with
+  /// trace messages.
+  inline void trace(const std::string &subsystem, const std::string &msg,
+                    const std::map<std::string, std::any> *details = nullptr) {
+#ifdef ESI_RUNTIME_TRACE
+    if (traceEnabled)
+      log(Level::Trace, subsystem, msg, details);
+#endif
+  }
+  /// Log a trace message using a callback. Same as above, users can go hog-wild
+  /// calling this.
+  inline void
+  trace(std::function<
+        void(std::string &subsystem, std::string &msg,
+             std::unique_ptr<std::map<std::string, std::any>> &details)>
+            traceFunc) {
+#ifdef ESI_RUNTIME_TRACE
+    if (!traceEnabled)
+      return;
+    std::string subsystem;
+    std::string msg;
+    std::unique_ptr<std::map<std::string, std::any>> details = nullptr;
+    traceFunc(subsystem, msg, details);
+    log(Level::Trace, subsystem, msg, details.get());
+#endif
+  }
+
+protected:
+  /// Overrideable version of debug. Only gets called if debug is enabled.
+  virtual void debugImpl(const std::string &subsystem, const std::string &msg,
+                         const std::map<std::string, std::any> *details) {
+    log(Level::Debug, subsystem, msg, details);
+  }
+  /// Overrideable version of debug. Only gets called if debug is enabled.
+  virtual void
+  debugImpl(std::function<
+            void(std::string &subsystem, std::string &msg,
+                 std::unique_ptr<std::map<std::string, std::any>> &details)>
+                debugFunc) {
+    if (!debugEnabled)
+      return;
+    std::string subsystem;
+    std::string msg;
+    std::unique_ptr<std::map<std::string, std::any>> details = nullptr;
+    debugFunc(subsystem, msg, details);
+    debugImpl(subsystem, msg, details.get());
+  }
+
+  /// Enable or disable debug messages.
+  bool debugEnabled = false;
+
+  /// Enable or disable trace messages.
+  bool traceEnabled;
+};
+
+/// A thread-safe logger which calls functions implemented by subclasses. Only
+/// protects the `log` method. If subclasses override other methods and need to
+/// protect them, they need to do that themselves.
+class TSLogger : public Logger {
+public:
+  using Logger::Logger;
+
+  /// Grabs the lock and calls logImpl.
+  void log(Level level, const std::string &subsystem, const std::string &msg,
+           const std::map<std::string, std::any> *details) override final;
+
+protected:
+  /// Subclasses must implement this method to log messages.
+  virtual void logImpl(Level level, const std::string &subsystem,
+                       const std::string &msg,
+                       const std::map<std::string, std::any> *details) = 0;
+
+  /// Mutex to protect the stream from interleaved logging writes.
+  std::mutex mutex;
+};
+
+/// A logger that writes to a C++ std::ostream.
+class StreamLogger : public TSLogger {
+public:
+  /// Create a stream logger that logs to the given output stream and error
+  /// output stream.
+  StreamLogger(Level minLevel, std::ostream &out, std::ostream &error)
+      : TSLogger(minLevel <= Level::Debug, minLevel <= Level::Trace),
+        minLevel(minLevel), outStream(out), errorStream(error) {}
+  /// Create a stream logger that logs to stdout, stderr.
+  StreamLogger(Level minLevel);
+  void logImpl(Level level, const std::string &subsystem,
+               const std::string &msg,
+               const std::map<std::string, std::any> *details) override;
+
+private:
+  /// The minimum log level to emit.
+  Level minLevel;
+
+  /// Everything except errors goes here.
+  std::ostream &outStream;
+  /// Just for errors.
+  std::ostream &errorStream;
+};
+
+/// A logger that writes to the console. Includes color support.
+class ConsoleLogger : public TSLogger {
+public:
+  /// Create a stream logger that logs to stdout, stderr.
+  ConsoleLogger(Level minLevel);
+  void logImpl(Level level, const std::string &subsystem,
+               const std::string &msg,
+               const std::map<std::string, std::any> *details) override;
+
+private:
+  /// The minimum log level to emit.
+  Level minLevel;
+};
+
+/// A logger that does nothing.
+class NullLogger : public Logger {
+public:
+  NullLogger() : Logger(false, false) {}
+  void log(Level, const std::string &, const std::string &,
+           const std::map<std::string, std::any> *) override {}
+};
+
+/// 'Stringify' a std::any. This is used to log std::any values by some loggers.
+std::string toString(const std::any &a);
+
+} // namespace esi
+
+#endif // ESI_LOGGING_H

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