CIRCT  20.0.0git
Cosim.cpp
Go to the documentation of this file.
1 //===- Cosim.cpp - Connection to ESI simulation via GRPC ------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // DO NOT EDIT!
10 // This file is distributed as part of an ESI package. The source for this file
11 // should always be modified within CIRCT
12 // (lib/dialect/ESI/runtime/cpp/lib/backends/Cosim.cpp).
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #include "esi/backends/Cosim.h"
17 #include "esi/Services.h"
18 #include "esi/Utils.h"
19 
20 #include "cosim.grpc.pb.h"
21 
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>
27 
28 #include <fstream>
29 #include <iostream>
30 #include <set>
31 
32 using namespace esi;
33 using namespace esi::cosim;
34 using namespace esi::services;
35 using namespace esi::backends::cosim;
36 
37 using grpc::Channel;
38 using grpc::ClientContext;
39 using grpc::ClientReader;
40 using grpc::ClientReaderWriter;
41 using grpc::ClientWriter;
42 using grpc::Status;
43 
44 static void checkStatus(Status s, const std::string &msg) {
45  if (!s.ok())
46  throw std::runtime_error(msg + ". Code " + to_string(s.error_code()) +
47  ": " + s.error_message() + " (" +
48  s.error_details() + ")");
49 }
50 
51 /// Hack around C++ not having a way to forward declare a nested class.
53  StubContainer(std::unique_ptr<ChannelServer::Stub> stub)
54  : stub(std::move(stub)) {}
55  std::unique_ptr<ChannelServer::Stub> stub;
56 
57  /// Get the type ID for a channel name.
58  bool getChannelDesc(const std::string &channelName,
59  esi::cosim::ChannelDesc &desc);
60 };
62 
63 /// Parse the connection std::string and instantiate the accelerator. Support
64 /// the traditional 'host:port' syntax and a path to 'cosim.cfg' which is output
65 /// by the cosimulation when it starts (which is useful when it chooses its own
66 /// port).
67 std::unique_ptr<AcceleratorConnection>
68 CosimAccelerator::connect(Context &ctxt, std::string connectionString) {
69  std::string portStr;
70  std::string host = "localhost";
71 
72  size_t colon;
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;
79 
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);
84  if (key == "port")
85  portStr = value;
86  else if (key == "host")
87  host = value;
88  }
89 
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");
94  if (hostEnv)
95  host = hostEnv;
96  else
97  host = "localhost";
98  char *portEnv = getenv("ESI_COSIM_PORT");
99  if (portEnv)
100  portStr = portEnv;
101  else
102  throw std::runtime_error("ESI_COSIM_PORT environment variable not set");
103  } else {
104  throw std::runtime_error("Invalid connection std::string '" +
105  connectionString + "'");
106  }
107  uint16_t port = stoul(portStr);
108  auto conn = make_unique<CosimAccelerator>(ctxt, host, port);
109 
110  // Using the MMIO manifest method is really only for internal debugging, so it
111  // doesn't need to be part of the connection string.
112  char *manifestMethod = getenv("ESI_COSIM_MANIFEST_MMIO");
113  if (manifestMethod != nullptr)
114  conn->setManifestMethod(ManifestMethod::MMIO);
115 
116  return conn;
117 }
118 
119 /// Construct and connect to a cosim server.
120 CosimAccelerator::CosimAccelerator(Context &ctxt, std::string hostname,
121  uint16_t port)
123  // Connect to the simulation.
124  auto channel = grpc::CreateChannel(hostname + ":" + std::to_string(port),
125  grpc::InsecureChannelCredentials());
126  rpcClient = new StubContainer(ChannelServer::NewStub(channel));
127 }
129  disconnect();
130  if (rpcClient)
131  delete rpcClient;
132  channels.clear();
133 }
134 
135 namespace {
136 class CosimSysInfo : public SysInfo {
137 public:
138  CosimSysInfo(ChannelServer::Stub *rpcClient) : rpcClient(rpcClient) {}
139 
140  uint32_t getEsiVersion() const override {
141  ::esi::cosim::Manifest response = getManifest();
142  return response.esi_version();
143  }
144 
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());
150  }
151 
152 private:
153  ::esi::cosim::Manifest getManifest() const {
154  ::esi::cosim::Manifest response;
155  // To get around the a race condition where the manifest may not be set yet,
156  // loop until it is. TODO: fix this with the DPI API change.
157  do {
158  ClientContext context;
159  VoidMessage arg;
160  Status s = rpcClient->GetManifest(&context, arg, &response);
161  checkStatus(s, "Failed to get manifest");
162  std::this_thread::sleep_for(std::chrono::milliseconds(10));
163  } while (response.esi_version() < 0);
164  return response;
165  }
166 
167  esi::cosim::ChannelServer::Stub *rpcClient;
168 };
169 } // namespace
170 
171 namespace {
172 /// Cosim client implementation of a write channel port.
173 class WriteCosimChannelPort : public WriteChannelPort {
174 public:
175  WriteCosimChannelPort(ChannelServer::Stub *rpcClient, const ChannelDesc &desc,
176  const Type *type, std::string name)
177  : WriteChannelPort(type), rpcClient(rpcClient), desc(desc), name(name) {}
178  ~WriteCosimChannelPort() = default;
179 
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);
189  }
190 
191  /// Send a write message to the server.
192  void write(const MessageData &data) override {
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());
204  }
205 
206  bool tryWrite(const MessageData &data) override {
207  write(data);
208  return true;
209  }
210 
211 protected:
212  ChannelServer::Stub *rpcClient;
213  /// The channel description as provided by the server.
214  ChannelDesc desc;
215  /// The name of the channel from the manifest.
216  std::string name;
217 };
218 } // namespace
219 
220 namespace {
221 /// Cosim client implementation of a read channel port. Since gRPC read protocol
222 /// streams messages back, this implementation is quite complex.
223 class ReadCosimChannelPort
224  : public ReadChannelPort,
225  public grpc::ClientReadReactor<esi::cosim::Message> {
226 public:
227  ReadCosimChannelPort(ChannelServer::Stub *rpcClient, const ChannelDesc &desc,
228  const Type *type, std::string name)
229  : ReadChannelPort(type), rpcClient(rpcClient), desc(desc), name(name),
230  context(nullptr) {}
231  virtual ~ReadCosimChannelPort() { disconnect(); }
232 
233  void connectImpl(std::optional<unsigned> bufferSize) override {
234  // Sanity checking.
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);
243 
244  // Initiate a stream of messages from the server.
245  context = std::make_unique<ClientContext>();
246  rpcClient->async()->ConnectToClientChannel(context.get(), &desc, this);
247  StartCall();
248  StartRead(&incomingMessage);
249  }
250 
251  /// Gets called when there's a new message from the server. It'll be stored in
252  /// `incomingMessage`.
253  void OnReadDone(bool ok) override {
254  if (!ok)
255  // This happens when we are disconnecting since we are canceling the call.
256  return;
257 
258  // Read the delivered message and push it onto the queue.
259  const std::string &messageString = incomingMessage.data();
260  MessageData data(reinterpret_cast<const uint8_t *>(messageString.data()),
261  messageString.size());
262  while (!callback(data))
263  // Blocking here could cause deadlocks in specific situations.
264  // TODO: Implement a way to handle this better.
265  std::this_thread::sleep_for(std::chrono::milliseconds(10));
266 
267  // Initiate the next read.
268  StartRead(&incomingMessage);
269  }
270 
271  /// Disconnect this channel from the server.
272  void disconnect() override {
273  if (!context)
274  return;
275  context->TryCancel();
276  context.reset();
278  }
279 
280 protected:
281  ChannelServer::Stub *rpcClient;
282  /// The channel description as provided by the server.
283  ChannelDesc desc;
284  /// The name of the channel from the manifest.
285  std::string name;
286 
287  std::unique_ptr<ClientContext> context;
288  /// Storage location for the incoming message.
289  esi::cosim::Message incomingMessage;
290 };
291 
292 } // namespace
293 
294 std::map<std::string, ChannelPort &>
296  const BundleType *bundleType) {
297  std::map<std::string, ChannelPort &> channelResults;
298 
299  // Find the client details for the port at 'fullPath'.
300  auto f = clientChannelAssignments.find(idPath);
301  if (f == clientChannelAssignments.end())
302  return channelResults;
303  const std::map<std::string, std::string> &channelAssignments = f->second;
304 
305  // Each channel in a bundle has a separate cosim endpoint. Find them all.
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;
312 
313  // Get the endpoint, which may or may not exist. Construct the port.
314  // Everything is validated when the client calls 'connect()' on the port.
315  ChannelDesc chDesc;
316  if (!rpcClient->getChannelDesc(channelName, chDesc))
317  throw std::runtime_error("Could not find channel '" + channelName +
318  "' in cosimulation");
319 
320  ChannelPort *port;
321  if (BundlePort::isWrite(dir)) {
322  port = new WriteCosimChannelPort(rpcClient->stub.get(), chDesc, type,
323  channelName);
324  } else {
325  port = new ReadCosimChannelPort(rpcClient->stub.get(), chDesc, type,
326  channelName);
327  }
328  channels.emplace(port);
329  channelResults.emplace(name, *port);
330  }
331  return channelResults;
332 }
333 
334 /// Get the channel description for a channel name. Iterate through the list
335 /// each time. Since this will only be called a small number of times on a small
336 /// list, it's not worth doing anything fancy.
337 bool StubContainer::getChannelDesc(const std::string &channelName,
338  ChannelDesc &desc) {
339  ClientContext context;
340  VoidMessage arg;
341  ListOfChannels response;
342  Status s = stub->ListChannels(&context, arg, &response);
343  checkStatus(s, "Failed to list channels");
344  for (const auto &channel : response.channels())
345  if (channel.name() == channelName) {
346  desc = channel;
347  return true;
348  }
349  return false;
350 }
351 
352 namespace {
353 class CosimMMIO : public MMIO {
354 public:
355  CosimMMIO(Context &ctxt, StubContainer *rpcClient) {
356  // We have to locate the channels ourselves since this service might be used
357  // to retrieve the manifest.
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");
362 
363  const esi::Type *i64Type = getType(ctxt, new UIntType(cmdResp.type(), 64));
364  const esi::Type *cmdType =
365  getType(ctxt, new StructType(cmdArg.type(),
366  {{"write", new BitsType("i1", 1)},
367  {"offset", new UIntType("ui32", 32)},
368  {"data", new BitsType("i64", 64)}}));
369 
370  // Get ports, create the function, then connect to it.
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");
376  cmdMMIO.reset(FuncService::Function::get(AppID("__cosim_mmio"), *cmdArgPort,
377  *cmdRespPort));
378  cmdMMIO->connect();
379  }
380 
381 #pragma pack(push, 1)
382  struct MMIOCmd {
383  uint64_t data;
384  uint32_t offset;
385  bool write;
386  };
387 #pragma pack(pop)
388 
389  // Call the read function and wait for a response.
390  uint64_t read(uint32_t addr) const override {
391  MMIOCmd cmd{.offset = addr, .write = false};
392  auto arg = MessageData::from(cmd);
393  std::future<MessageData> result = cmdMMIO->call(arg);
394  result.wait();
395  return *result.get().as<uint64_t>();
396  }
397 
398  void write(uint32_t addr, uint64_t data) override {
399  MMIOCmd cmd{.data = data, .offset = addr, .write = true};
400  auto arg = MessageData::from(cmd);
401  std::future<MessageData> result = cmdMMIO->call(arg);
402  result.wait();
403  }
404 
405 private:
406  const esi::Type *getType(Context &ctxt, esi::Type *type) {
407  if (auto t = ctxt.getType(type->getID())) {
408  delete type;
409  return *t;
410  }
411  ctxt.registerType(type);
412  return type;
413  }
414  std::unique_ptr<WriteCosimChannelPort> cmdArgPort;
415  std::unique_ptr<ReadCosimChannelPort> cmdRespPort;
416  std::unique_ptr<FuncService::Function> cmdMMIO;
417 };
418 
419 class CosimHostMem : public HostMem {
420 public:
421  CosimHostMem() {}
422 
423  struct CosimHostMemRegion : public HostMemRegion {
424  CosimHostMemRegion(std::size_t size) {
425  ptr = malloc(size);
426  this->size = size;
427  }
428  virtual ~CosimHostMemRegion() { free(ptr); }
429  virtual void *getPtr() const override { return ptr; }
430  virtual std::size_t getSize() const override { return size; }
431 
432  private:
433  void *ptr;
434  std::size_t size;
435  };
436 
437  virtual std::unique_ptr<HostMemRegion>
438  allocate(std::size_t size, HostMem::Options opts) const override {
439  return std::unique_ptr<HostMemRegion>(new CosimHostMemRegion(size));
440  }
441  virtual bool mapMemory(void *ptr, std::size_t size,
442  HostMem::Options opts) const override {
443  return true;
444  }
445  virtual void unmapMemory(void *ptr) const override {}
446 };
447 
448 } // namespace
449 
450 Service *CosimAccelerator::createService(Service::Type svcType,
451  AppIDPath idPath, std::string implName,
452  const ServiceImplDetails &details,
453  const HWClientDetails &clients) {
454  // Compute our parents idPath path.
455  AppIDPath prefix = std::move(idPath);
456  if (prefix.size() > 0)
457  prefix.pop_back();
458 
459  if (implName == "cosim") {
460  // Get the channel assignments for each client.
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);
469  }
470  }
471 
472  if (svcType == typeid(services::MMIO)) {
473  return new CosimMMIO(getCtxt(), rpcClient);
474  } else if (svcType == typeid(services::HostMem)) {
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>());
482  }
483  } else if (svcType == typeid(CustomService) && implName == "cosim") {
484  return new CustomService(idPath, details, clients);
485  }
486  return nullptr;
487 }
488 
489 void CosimAccelerator::setManifestMethod(ManifestMethod method) {
490  manifestMethod = method;
491 }
492 
assert(baseType &&"element must be base type")
esi::backends::cosim::CosimAccelerator::StubContainer StubContainer
Definition: Cosim.cpp:61
static void checkStatus(Status s, const std::string &msg)
Definition: Cosim.cpp:44
REGISTER_ACCELERATOR("cosim", backends::cosim::CosimAccelerator)
Abstract class representing a connection to an accelerator.
Definition: Accelerator.h:78
virtual void disconnect()
Disconnect from the accelerator cleanly.
std::string toStr() const
Definition: Manifest.cpp:690
static bool isWrite(BundleType::Direction bundleDir)
Compute the direction of a channel given the bundle direction and the bundle port's direction.
Definition: Ports.h:188
Bundles represent a collection of channels.
Definition: Types.h:44
const ChannelVector & getChannels() const
Definition: Types.h:54
Unidirectional channels are the basic communication primitive between the host and accelerator.
Definition: Ports.h:33
AcceleratorConnections, Accelerators, and Manifests must all share a context.
Definition: Context.h:31
A logical chunk of data representing serialized data.
Definition: Common.h:92
static MessageData from(T &t)
Cast from a type to its raw bytes.
Definition: Common.h:118
A ChannelPort which reads data from the accelerator.
Definition: Ports.h:103
virtual void disconnect() override
Definition: Ports.h:108
Structs are an ordered collection of fields, each with a name and a type.
Definition: Types.h:130
Root class of the ESI type system.
Definition: Types.h:27
ID getID() const
Definition: Types.h:33
Unsigned integer.
Definition: Types.h:124
A ChannelPort which sends data to the accelerator.
Definition: Ports.h:74
Connect to an ESI simulation.
Definition: Cosim.h:37
std::map< AppIDPath, std::map< std::string, std::string > > clientChannelAssignments
Definition: Cosim.h:78
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).
Definition: Cosim.cpp:295
std::set< std::unique_ptr< ChannelPort > > channels
Definition: Cosim.h:75
A service for which there are no standard services registered.
Definition: Services.h:77
Implement the SysInfo API for a standard MMIO protocol.
Definition: Services.h:180
Parent class of all APIs modeled as 'services'.
Definition: Services.h:45
const std::type_info & Type
Definition: Services.h:47
Information about the Accelerator system.
Definition: Services.h:93
def connect(destination, source)
Definition: support.py:39
Direction get(bool isOutput)
Returns an output direction if isOutput is true, otherwise returns an input direction.
Definition: CalyxOps.cpp:55
Definition: esi.py:1
std::map< std::string, std::any > ServiceImplDetails
Definition: Common.h:87
std::vector< HWClientDetail > HWClientDetails
Definition: Common.h:86
Hack around C++ not having a way to forward declare a nested class.
Definition: Cosim.cpp:52
std::unique_ptr< ChannelServer::Stub > stub
Definition: Cosim.cpp:55
bool getChannelDesc(const std::string &channelName, esi::cosim::ChannelDesc &desc)
Get the type ID for a channel name.
Definition: Cosim.cpp:337
StubContainer(std::unique_ptr< ChannelServer::Stub > stub)
Definition: Cosim.cpp:53
Options for allocating host memory.
Definition: Services.h:209