45 uncompress(dst.data(), &dstSize, compressed.data(), compressed.size());
47 throw std::runtime_error(
"zlib uncompress failed with rc=" +
49 return std::string(
reinterpret_cast<char *
>(dst.data()), dstSize);
59 auto offsetIter = client.implOptions.find(
"offset");
60 if (offsetIter == client.implOptions.end())
61 throw std::runtime_error(
"MMIO client missing 'offset' option");
62 Constant offset = std::any_cast<Constant>(offsetIter->second);
63 uint64_t offsetVal = std::any_cast<uint64_t>(offset.
value);
64 if (offsetVal >= 1ull << 32)
65 throw std::runtime_error(
"MMIO client offset mustn't exceed 32 bits");
67 auto sizeIter = client.implOptions.find(
"size");
68 if (sizeIter == client.implOptions.end())
69 throw std::runtime_error(
"MMIO client missing 'size' option");
70 Constant size = std::any_cast<Constant>(sizeIter->second);
71 uint64_t sizeVal = std::any_cast<uint64_t>(size.
value);
72 if (sizeVal >= 1ull << 32)
73 throw std::runtime_error(
"MMIO client size mustn't exceed 32 bits");
83 auto regionIter =
regions.find(
id);
84 if (regionIter ==
regions.end())
91class MMIOPassThrough :
public MMIO {
94 :
MMIO(parent->getConnection(), clients), parent(parent) {}
95 uint64_t read(uint32_t addr)
const override {
return parent->
read(addr); }
96 void write(uint32_t addr, uint64_t data)
override {
97 parent->write(addr, data);
108 if (service !=
typeid(
MMIO))
110 return new MMIOPassThrough(clients,
this);
118 :
ServicePort(id, nullptr, {}), parent(parent), desc(desc) {}
120 if (addr >= desc.size)
121 throw std::runtime_error(
"MMIO read out of bounds: " +
toHex(addr));
122 return parent->read(desc.base + addr);
125 if (addr >= desc.size)
126 throw std::runtime_error(
"MMIO write out of bounds: " +
toHex(addr));
127 parent->write(desc.base + addr, data);
136 throw std::runtime_error(
"Invalid magic number: " +
toHex(reg));
143 throw std::runtime_error(
"Unsupported ESI header version: " +
144 std::to_string(version));
146 uint64_t size =
mmio->
read(manifestPtr);
147 uint64_t numWords = (size + 7) / 8;
148 std::vector<uint64_t> manifestWords(numWords);
149 for (
size_t i = 0; i < numWords; ++i)
150 manifestWords[i] =
mmio->
read(manifestPtr + 8 + (i * 8));
152 std::vector<uint8_t> manifest;
153 for (
size_t i = 0; i < size; ++i) {
154 uint64_t word = manifestWords[i / 8];
155 manifest.push_back(word >> (8 * (i % 8)));
166 if (
auto f = details.find(
"service"); f != details.end()) {
182 if (
auto f = details.find(
"service"); f != details.end())
184 symbol = std::any_cast<std::string>(f->second).substr(1);
190 return new Function(
id.back(), type,
198 id,
type, {{std::string(
"arg"),
arg}, {std::string(
"result"),
result}});
203 if (channels.size() != 2)
204 throw std::runtime_error(
"FuncService must have exactly two channels");
205 arg = &getRawWrite(
"arg");
207 result = &getRawRead(
"result");
211std::future<MessageData>
213 std::scoped_lock<std::mutex> lock(callMutex);
215 return result->readAsync();
221 if (
auto f = details.find(
"service"); f != details.end())
223 symbol = std::any_cast<std::string>(f->second).substr(1);
241 return new Callback(acc,
id, type, {{
"arg", arg}, {
"result", result}});
246 if (channels.size() != 2)
247 throw std::runtime_error(
"CallService must have exactly two channels");
248 result = &getRawWrite(
"result");
250 arg = &getRawRead(
"arg");
253 arg->connect([
this, callback](
MessageData argMsg) ->
bool {
254 MessageData resultMsg = callback(std::move(argMsg));
255 this->result->write(std::move(resultMsg));
261 acc.getServiceThread()->addListener(
263 MessageData resultMsg = callback(std::move(argMsg));
264 this->result->write(std::move(resultMsg));
271 std::string implName,
276 return new FuncService(
id, *acc, details, clients);
286 if (svcName ==
"esi.service.std.func")
288 if (svcName ==
"esi.service.std.call")
constexpr uint32_t MAX_MANIFEST_SIZE
Abstract class representing a connection to an accelerator.
ServiceClass * getService(AppIDPath id={}, std::string implName={}, ServiceImplDetails details={}, HWClientDetails clients={})
Get a typed reference to a particular service type.
virtual const BundleEngineMap & getEngineMapFor(AppIDPath id)
PortMap requestPorts(const AppIDPath &idPath, const BundleType *bundleType) const
Request ports for all the channels in a bundle.
Services provide connections to 'bundles' – collections of named, unidirectional communication channe...
Bundles represent a collection of channels.
A logical chunk of data representing serialized data.
A ChannelPort which reads data from the accelerator.
A ChannelPort which sends data to the accelerator.
A function call which gets attached to a service port.
static Callback * get(AcceleratorConnection &acc, AppID id, BundleType *type, WriteChannelPort &result, ReadChannelPort &arg)
Callback(AcceleratorConnection &acc, AppID id, const BundleType *, PortMap channels)
void connect(std::function< MessageData(const MessageData &)> callback, bool quick=false)
Connect a callback to code which will be executed when the accelerator invokes the callback.
Service for servicing function calls from the accelerator.
virtual std::string getServiceSymbol() const override
CallService(AcceleratorConnection &acc, AppIDPath id, ServiceImplDetails details)
virtual BundlePort * getPort(AppIDPath id, const BundleType *type) const override
Get specialized port for this service to attach to the given appid path.
A service for which there are no standard services registered.
virtual BundlePort * getPort(AppIDPath id, const BundleType *type) const override
Get specialized port for this service to attach to the given appid path.
std::string serviceSymbol
CustomService(AppIDPath idPath, AcceleratorConnection &, const ServiceImplDetails &details, const HWClientDetails &clients)
A function call which gets attached to a service port.
std::future< MessageData > call(const MessageData &arg)
static Function * get(AppID id, BundleType *type, WriteChannelPort &arg, ReadChannelPort &result)
Service for calling functions.
virtual std::string getServiceSymbol() const override
virtual BundlePort * getPort(AppIDPath id, const BundleType *type) const override
Get specialized port for this service to attach to the given appid path.
FuncService(AppIDPath id, AcceleratorConnection &, ServiceImplDetails details, HWClientDetails clients)
virtual std::string getServiceSymbol() const override
static constexpr std::string_view StdName
virtual std::vector< uint8_t > getCompressedManifest() const override
Return the zlib compressed JSON system manifest.
uint32_t getEsiVersion() const override
Get the ESI version number to check version compatibility.
MMIOSysInfo(const MMIO *)
A "slice" of some parent MMIO space.
virtual uint64_t read(uint32_t addr) const
Read a 64-bit value from this region, not the global address space.
MMIORegion(AppID id, MMIO *parent, RegionDescriptor desc)
virtual void write(uint32_t addr, uint64_t data)
Write a 64-bit value to this region, not the global address space.
virtual uint64_t read(uint32_t addr) const =0
Read a 64-bit value from the global MMIO space.
virtual BundlePort * getPort(AppIDPath id, const BundleType *type) const override
Get a MMIO region port for a particular region descriptor.
std::map< AppIDPath, RegionDescriptor > regions
MMIO base address table.
static constexpr std::string_view StdName
virtual Service * getChildService(Service::Type service, AppIDPath id={}, std::string implName={}, ServiceImplDetails details={}, HWClientDetails clients={}) override
If the service is a MMIO service, return a region of the MMIO space which peers into ours.
MMIO(AcceleratorConnection &, const HWClientDetails &clients)
virtual std::string getServiceSymbol() const override
Add a custom interface to a service client at a particular point in the design hierarchy.
static Service::Type lookupServiceType(const std::string &)
Resolve a service type from a string.
static Service * createService(AcceleratorConnection *acc, Service::Type svcType, AppIDPath id, std::string implName, ServiceImplDetails details, HWClientDetails clients)
Create a service instance from the given details.
Parent class of all APIs modeled as 'services'.
AcceleratorConnection & getConnection() const
const std::type_info & Type
virtual Service * getChildService(Service::Type service, AppIDPath id={}, std::string implName={}, ServiceImplDetails details={}, HWClientDetails clients={})
Create a "child" service of this service.
AcceleratorConnection & conn
Information about the Accelerator system.
virtual std::string getJsonManifest() const
Return the JSON-formatted system manifest.
virtual std::vector< uint8_t > getCompressedManifest() const =0
Return the zlib compressed JSON system manifest.
virtual std::string getServiceSymbol() const override
constexpr uint64_t MagicNumber
std::map< std::string, std::any > ServiceImplDetails
std::string toHex(void *val)
constexpr uint32_t MetadataOffset
std::map< std::string, ChannelPort & > PortMap
std::vector< HWClientDetail > HWClientDetails
A description of a hardware client.
Describe a region (slice) of MMIO space.