20 #include "cosim.grpc.pb.h"
22 #include <grpc/grpc.h>
23 #include <grpcpp/channel.h>
24 #include <grpcpp/client_context.h>
25 #include <grpcpp/create_channel.h>
26 #include <grpcpp/security/credentials.h>
38 using grpc::ClientContext;
39 using grpc::ClientReader;
40 using grpc::ClientReaderWriter;
41 using grpc::ClientWriter;
46 throw std::runtime_error(msg +
". Code " + to_string(s.error_code()) +
47 ": " + s.error_message() +
" (" +
48 s.error_details() +
")");
54 : stub(std::move(stub)) {}
55 std::unique_ptr<ChannelServer::Stub>
stub;
58 bool getChannelDesc(
const std::string &channelName,
59 esi::cosim::ChannelDesc &desc);
67 std::unique_ptr<AcceleratorConnection>
70 std::string host =
"localhost";
73 if ((colon = connectionString.find(
':')) != std::string::npos) {
74 portStr = connectionString.substr(colon + 1);
75 host = connectionString.substr(0, colon);
76 }
else if (connectionString.ends_with(
"cosim.cfg")) {
77 std::ifstream cfg(connectionString);
78 std::string line, key, value;
80 while (getline(cfg, line))
81 if ((colon = line.find(
":")) != std::string::npos) {
82 key = line.substr(0, colon);
83 value = line.substr(colon + 1);
86 else if (key ==
"host")
90 if (portStr.size() == 0)
91 throw std::runtime_error(
"port line not found in file");
92 }
else if (connectionString ==
"env") {
93 char *hostEnv = getenv(
"ESI_COSIM_HOST");
98 char *portEnv = getenv(
"ESI_COSIM_PORT");
102 throw std::runtime_error(
"ESI_COSIM_PORT environment variable not set");
104 throw std::runtime_error(
"Invalid connection std::string '" +
105 connectionString +
"'");
107 uint16_t port = stoul(portStr);
108 auto conn = make_unique<CosimAccelerator>(
ctxt, host, port);
112 char *manifestMethod = getenv(
"ESI_COSIM_MANIFEST_MMIO");
113 if (manifestMethod !=
nullptr)
120 CosimAccelerator::CosimAccelerator(
Context &
ctxt, std::string hostname,
124 auto channel = grpc::CreateChannel(hostname +
":" + std::to_string(port),
125 grpc::InsecureChannelCredentials());
136 class CosimSysInfo :
public SysInfo {
138 CosimSysInfo(ChannelServer::Stub *rpcClient) : rpcClient(rpcClient) {}
140 uint32_t getEsiVersion()
const override {
141 ::esi::cosim::Manifest response = getManifest();
142 return response.esi_version();
145 std::vector<uint8_t> getCompressedManifest()
const override {
146 ::esi::cosim::Manifest response = getManifest();
147 std::string compressedManifestStr = response.compressed_manifest();
148 return std::vector<uint8_t>(compressedManifestStr.begin(),
149 compressedManifestStr.end());
153 ::esi::cosim::Manifest getManifest()
const {
154 ::esi::cosim::Manifest response;
158 ClientContext context;
160 Status s = rpcClient->GetManifest(&context, arg, &response);
162 std::this_thread::sleep_for(std::chrono::milliseconds(10));
163 }
while (response.esi_version() < 0);
167 esi::cosim::ChannelServer::Stub *rpcClient;
175 WriteCosimChannelPort(ChannelServer::Stub *rpcClient,
const ChannelDesc &desc,
176 const Type *type, std::string name)
178 ~WriteCosimChannelPort() =
default;
180 void connectImpl(std::optional<unsigned> bufferSize)
override {
181 if (desc.type() != getType()->getID())
182 throw std::runtime_error(
"Channel '" + name +
183 "' has wrong type. Expected " +
184 getType()->getID() +
", got " + desc.type());
185 if (desc.dir() != ChannelDesc::Direction::ChannelDesc_Direction_TO_SERVER)
186 throw std::runtime_error(
"Channel '" + name +
187 "' is not a to server channel");
188 assert(desc.name() == name);
193 ClientContext context;
194 AddressedMessage msg;
195 msg.set_channel_name(name);
196 msg.mutable_message()->set_data(
data.getBytes(),
data.getSize());
197 VoidMessage response;
198 grpc::Status sendStatus = rpcClient->SendToServer(&context, msg, &response);
199 if (!sendStatus.ok())
200 throw std::runtime_error(
"Failed to write to channel '" + name +
201 "': " + std::to_string(sendStatus.error_code()) +
202 " " + sendStatus.error_message() +
203 ". Details: " + sendStatus.error_details());
212 ChannelServer::Stub *rpcClient;
223 class ReadCosimChannelPort
225 public grpc::ClientReadReactor<esi::cosim::Message> {
227 ReadCosimChannelPort(ChannelServer::Stub *rpcClient,
const ChannelDesc &desc,
228 const Type *type, std::string name)
231 virtual ~ReadCosimChannelPort() { disconnect(); }
233 void connectImpl(std::optional<unsigned> bufferSize)
override {
235 if (desc.type() != getType()->getID())
236 throw std::runtime_error(
"Channel '" + name +
237 "' has wrong type. Expected " +
238 getType()->getID() +
", got " + desc.type());
239 if (desc.dir() != ChannelDesc::Direction::ChannelDesc_Direction_TO_CLIENT)
240 throw std::runtime_error(
"Channel '" + name +
241 "' is not a to client channel");
242 assert(desc.name() == name);
245 context = std::make_unique<ClientContext>();
246 rpcClient->async()->ConnectToClientChannel(context.get(), &desc,
this);
248 StartRead(&incomingMessage);
253 void OnReadDone(
bool ok)
override {
259 const std::string &messageString = incomingMessage.data();
260 MessageData data(
reinterpret_cast<const uint8_t *
>(messageString.data()),
261 messageString.size());
262 while (!callback(data))
265 std::this_thread::sleep_for(std::chrono::milliseconds(10));
268 StartRead(&incomingMessage);
272 void disconnect()
override {
275 context->TryCancel();
281 ChannelServer::Stub *rpcClient;
287 std::unique_ptr<ClientContext> context;
289 esi::cosim::Message incomingMessage;
294 std::map<std::string, ChannelPort &>
297 std::map<std::string, ChannelPort &> channelResults;
302 return channelResults;
303 const std::map<std::string, std::string> &channelAssignments = f->second;
306 for (
auto [name, dir, type] : bundleType->
getChannels()) {
307 auto f = channelAssignments.find(name);
308 if (f == channelAssignments.end())
309 throw std::runtime_error(
"Could not find channel assignment for '" +
310 idPath.
toStr() +
"." + name +
"'");
311 std::string channelName = f->second;
317 throw std::runtime_error(
"Could not find channel '" + channelName +
318 "' in cosimulation");
322 port =
new WriteCosimChannelPort(
rpcClient->
stub.get(), chDesc, type,
325 port =
new ReadCosimChannelPort(
rpcClient->
stub.get(), chDesc, type,
329 channelResults.emplace(name, *port);
331 return channelResults;
339 ClientContext context;
341 ListOfChannels response;
342 Status s = stub->ListChannels(&context, arg, &response);
344 for (
const auto &channel : response.channels())
345 if (channel.name() == channelName) {
353 class CosimMMIO :
public MMIO {
358 ChannelDesc cmdArg, cmdResp;
359 if (!rpcClient->
getChannelDesc(
"__cosim_mmio_read_write.arg", cmdArg) ||
360 !rpcClient->
getChannelDesc(
"__cosim_mmio_read_write.result", cmdResp))
361 throw std::runtime_error(
"Could not find MMIO channels");
366 {{
"write", new BitsType(
"i1", 1)},
367 {
"offset", new UIntType(
"ui32", 32)},
368 {
"data", new BitsType(
"i64", 64)}}));
371 cmdArgPort = std::make_unique<WriteCosimChannelPort>(
372 rpcClient->
stub.get(), cmdArg, cmdType,
"__cosim_mmio_read_write.arg");
373 cmdRespPort = std::make_unique<ReadCosimChannelPort>(
374 rpcClient->
stub.get(), cmdResp, i64Type,
375 "__cosim_mmio_read_write.result");
381 #pragma pack(push, 1)
390 uint64_t read(uint32_t addr)
const override {
391 MMIOCmd cmd{.offset = addr, .write =
false};
393 std::future<MessageData> result = cmdMMIO->call(arg);
395 return *result.get().as<uint64_t>();
398 void write(uint32_t addr, uint64_t data)
override {
399 MMIOCmd cmd{.data =
data, .offset =
addr, .write =
true};
401 std::future<MessageData> result = cmdMMIO->call(arg);
407 if (
auto t =
ctxt.getType(type->
getID())) {
411 ctxt.registerType(type);
414 std::unique_ptr<WriteCosimChannelPort> cmdArgPort;
415 std::unique_ptr<ReadCosimChannelPort> cmdRespPort;
416 std::unique_ptr<FuncService::Function> cmdMMIO;
419 class CosimHostMem :
public HostMem {
423 struct CosimHostMemRegion :
public HostMemRegion {
424 CosimHostMemRegion(std::size_t size) {
428 virtual ~CosimHostMemRegion() { free(ptr); }
429 virtual void *getPtr()
const override {
return ptr; }
430 virtual std::size_t getSize()
const override {
return size; }
437 virtual std::unique_ptr<HostMemRegion>
439 return std::unique_ptr<HostMemRegion>(
new CosimHostMemRegion(size));
441 virtual bool mapMemory(
void *ptr, std::size_t size,
445 virtual void unmapMemory(
void *ptr)
const override {}
456 if (prefix.size() > 0)
459 if (implName ==
"cosim") {
461 for (
auto client : clients) {
462 AppIDPath fullClientPath = prefix + client.relPath;
463 std::map<std::string, std::string> channelAssignments;
464 for (
auto assignment : std::any_cast<std::map<std::string, std::any>>(
465 client.implOptions.at(
"channel_assignments")))
466 channelAssignments[assignment.first] =
467 std::any_cast<std::string>(assignment.second);
468 clientChannelAssignments[fullClientPath] = std::move(channelAssignments);
473 return new CosimMMIO(getCtxt(), rpcClient);
475 return new CosimHostMem();
476 }
else if (svcType ==
typeid(
SysInfo)) {
477 switch (manifestMethod) {
478 case ManifestMethod::Cosim:
479 return new CosimSysInfo(rpcClient->
stub.get());
481 return new MMIOSysInfo(getService<services::MMIO>());
483 }
else if (svcType ==
typeid(
CustomService) && implName ==
"cosim") {
490 manifestMethod = method;
assert(baseType &&"element must be base type")
esi::backends::cosim::CosimAccelerator::StubContainer StubContainer
static void checkStatus(Status s, const std::string &msg)
REGISTER_ACCELERATOR("cosim", backends::cosim::CosimAccelerator)
Abstract class representing a connection to an accelerator.
virtual void disconnect()
Disconnect from the accelerator cleanly.
std::string toStr() const
static bool isWrite(BundleType::Direction bundleDir)
Compute the direction of a channel given the bundle direction and the bundle port's direction.
Bundles represent a collection of channels.
const ChannelVector & getChannels() const
Unidirectional channels are the basic communication primitive between the host and accelerator.
AcceleratorConnections, Accelerators, and Manifests must all share a context.
A logical chunk of data representing serialized data.
static MessageData from(T &t)
Cast from a type to its raw bytes.
A ChannelPort which reads data from the accelerator.
virtual void disconnect() override
Structs are an ordered collection of fields, each with a name and a type.
Root class of the ESI type system.
A ChannelPort which sends data to the accelerator.
Connect to an ESI simulation.
std::map< AppIDPath, std::map< std::string, std::string > > clientChannelAssignments
virtual std::map< std::string, ChannelPort & > requestChannelsFor(AppIDPath, const BundleType *) override
Request the host side channel ports for a particular instance (identified by the AppID path).
std::set< std::unique_ptr< ChannelPort > > channels
StubContainer * rpcClient
A service for which there are no standard services registered.
Implement the SysInfo API for a standard MMIO protocol.
Parent class of all APIs modeled as 'services'.
const std::type_info & Type
Information about the Accelerator system.
def connect(destination, source)
Direction get(bool isOutput)
Returns an output direction if isOutput is true, otherwise returns an input direction.
std::map< std::string, std::any > ServiceImplDetails
std::vector< HWClientDetail > HWClientDetails
Hack around C++ not having a way to forward declare a nested class.
std::unique_ptr< ChannelServer::Stub > stub
bool getChannelDesc(const std::string &channelName, esi::cosim::ChannelDesc &desc)
Get the type ID for a channel name.
StubContainer(std::unique_ptr< ChannelServer::Stub > stub)
Options for allocating host memory.