loopback_typed.cpp

Go to the documentation of this file.

#include "loopback/LoopbackIP.h"
#include "loopback/SerialCoordTranslator.h"
 
#include "probe_runner.h"
 
#include "esi/Accelerator.h"
#include "esi/Manifest.h"
#include "esi/Services.h"
#include "esi/TypedPorts.h"
 
#include <cstdint>
#include <iostream>
#include <random>
#include <stdexcept>
#include <vector>
 
using namespace esi;
 
static int runLoopbackI8(Accelerator *accel) {
  AppIDPath lastLookup;
  BundlePort *inPort = accel->resolvePort(
      {AppID("loopback_inst", 0), AppID("loopback_tohw")}, lastLookup);
  if (!inPort)
    throw std::runtime_error("No loopback_tohw port found");
  BundlePort *outPort = accel->resolvePort(
      {AppID("loopback_inst", 0), AppID("loopback_fromhw")}, lastLookup);
  if (!outPort)
    throw std::runtime_error("No loopback_fromhw port found");
 
  // Use TypedWritePort and TypedReadPort instead of raw channels.
  TypedWritePort<uint8_t> toHw(inPort->getRawWrite("recv"));
  TypedReadPort<uint8_t> fromHw(outPort->getRawRead("send"));
  toHw.connect();
  fromHw.connect();
 
  uint8_t sendVal = 0x5a;
  toHw.write(sendVal);
 
  std::unique_ptr<uint8_t> got = fromHw.read();
  if (!got || *got != sendVal)
    throw std::runtime_error("Loopback byte mismatch");
 
  std::cout << "loopback_i8 ok: 0x" << std::hex << (int)*got << std::dec
            << "\n";
  return 0;
}
 
static int runStructFunc(Accelerator *accel) {
  AppIDPath lastLookup;
  BundlePort *port = accel->resolvePort({AppID("structFunc")}, lastLookup);
  if (!port)
    throw std::runtime_error("No structFunc port found");
 
  // Use TypedFunction instead of raw FuncService::Function.
  TypedFunction<esi_system::ArgStruct, esi_system::ResultStruct> func =
      port->getAs<services::FuncService::Function>();
  func.connect();
 
  esi_system::ArgStruct arg{};
  arg.a = 0x1234;
  arg.b = static_cast<int8_t>(-7);
 
  esi_system::ResultStruct res = func.call(arg).get();
 
  int8_t expectedX = static_cast<int8_t>(arg.b + 1);
  if (res.x != expectedX || res.y != arg.b)
    throw std::runtime_error("Struct func result mismatch");
 
  std::cout << "struct_func ok: b=" << (int)arg.b << " x=" << (int)res.x
            << " y=" << (int)res.y << "\n";
  return 0;
}
 
static int runOddStructFunc(Accelerator *accel) {
  AppIDPath lastLookup;
  BundlePort *port = accel->resolvePort({AppID("oddStructFunc")}, lastLookup);
  if (!port)
    throw std::runtime_error("No oddStructFunc port found");
 
  // Use TypedFunction with OddStruct for both arg and result.
  TypedFunction<esi_system::OddStruct, esi_system::OddStruct> func =
      port->getAs<services::FuncService::Function>();
  func.connect();
 
  esi_system::OddStruct arg{};
  arg.a = 0xabc;
  arg.b = static_cast<int8_t>(-17);
  arg.inner.p = 5;
  arg.inner.q = static_cast<int8_t>(-7);
  arg.inner.r[0] = 3;
  arg.inner.r[1] = 4;
 
  esi_system::OddStruct res = func.call(arg).get();
 
  uint16_t expectA = static_cast<uint16_t>(arg.a + 1);
  int8_t expectB = static_cast<int8_t>(arg.b - 3);
  uint8_t expectP = static_cast<uint8_t>(arg.inner.p + 5);
  int8_t expectQ = static_cast<int8_t>(arg.inner.q + 2);
  uint8_t expectR0 = static_cast<uint8_t>(arg.inner.r[0] + 1);
  uint8_t expectR1 = static_cast<uint8_t>(arg.inner.r[1] + 2);
  if (res.a != expectA || res.b != expectB || res.inner.p != expectP ||
      res.inner.q != expectQ || res.inner.r[0] != expectR0 ||
      res.inner.r[1] != expectR1)
    throw std::runtime_error("Odd struct func result mismatch");
 
  std::cout << "odd_struct_func ok: a=" << res.a << " b=" << (int)res.b
            << " p=" << (int)res.inner.p << " q=" << (int)res.inner.q
            << " r0=" << (int)res.inner.r[0] << " r1=" << (int)res.inner.r[1]
            << "\n";
  return 0;
}
 
static int runArrayFunc(Accelerator *accel) {
  AppIDPath lastLookup;
  BundlePort *port = accel->resolvePort({AppID("arrayFunc")}, lastLookup);
  if (!port)
    throw std::runtime_error("No arrayFunc port found");
 
  auto *func = port->getAs<services::FuncService::Function>();
  if (!func)
    throw std::runtime_error("arrayFunc not a FuncService::Function");
  func->connect();
 
  int8_t argArray[1] = {static_cast<int8_t>(-3)};
  MessageData resMsg =
      func->call(MessageData(reinterpret_cast<const uint8_t *>(argArray),
                             sizeof(argArray)))
          .get();
 
  const auto *res = resMsg.as<esi_system::ResultArray>();
  int8_t a = (*res)[0];
  int8_t b = (*res)[1];
  int8_t expect0 = argArray[0];
  int8_t expect1 = static_cast<int8_t>(argArray[0] + 1);
 
  bool ok = (a == expect0 && b == expect1) || (a == expect1 && b == expect0);
  if (!ok)
    throw std::runtime_error("Array func result mismatch");
 
  int8_t low = a;
  int8_t high = b;
  if (low > high) {
    int8_t tmp = low;
    low = high;
    high = tmp;
  }
  std::cout << "array_func ok: " << (int)low << " " << (int)high << "\n";
  return 0;
}
 
static int runSInt4Loopback(Accelerator *accel) {
  AppIDPath lastLookup;
  BundlePort *port = accel->resolvePort({AppID("sint4Func")}, lastLookup);
  if (!port)
    throw std::runtime_error("No sint4Func port found");
 
  // Use TypedFunction<int8_t, int8_t> for si4 → si4 loopback.
  // si4 fits in int8_t (width 4 <= 8). Tests sign extension of small widths.
  TypedFunction<int8_t, int8_t> func =
      port->getAs<services::FuncService::Function>();
  func.connect();
 
  // Test positive value.
  int8_t posArg = 5;
  int8_t posResult = func.call(posArg).get();
  if (posResult != posArg)
    throw std::runtime_error("sint4 loopback positive mismatch: got " +
                             std::to_string(posResult));
 
  // Test negative value (-3, which is 0x0D in si4 wire format).
  int8_t negArg = -3;
  int8_t negResult = func.call(negArg).get();
  if (negResult != negArg)
    throw std::runtime_error("sint4 loopback negative mismatch: got " +
                             std::to_string(negResult));
 
  std::cout << "sint4_loopback ok: pos=" << (int)posResult
            << " neg=" << (int)negResult << "\n";
  return 0;
}
 
//
// SerialCoordTranslator test
//
 
using SerialCoordInput = esi_system::
    _struct_x_translation_i32_y_translation_i32_coords__esi_list__hw_struct_x__i32__y__i32___serial_coord_args;
using SerialCoordResult = esi_system::
    _struct_coords__esi_list__hw_struct_x__i32__y__i32___serial_coord_result;
using SerialCoordValue = SerialCoordInput::value_type;
 
static int serialCoordTranslateTest(Accelerator *accel) {
  size_t numCoords = 100;
  uint32_t xTrans = 10, yTrans = 20;
 
  // Generate random coordinates.
  std::mt19937 rng(0xDEADBEEF);
  std::uniform_int_distribution<uint32_t> dist(0, 1000000);
  std::vector<SerialCoordValue> coords;
  coords.reserve(numCoords);
  for (uint32_t i = 0; i < numCoords; ++i)
    coords.emplace_back(dist(rng), dist(rng));
 
  auto childIt = accel->getChildren().find(AppID("coord_translator_serial"));
  if (childIt == accel->getChildren().end())
    throw std::runtime_error("Serial coord translate test: no "
                             "'coord_translator_serial' child found");
 
  esi_system::SerialCoordTranslator translator(childIt->second);
  auto connected = translator.connect();
 
  // Drive the serial-list window through the generated facade. The
  // TypedFunction member handles frame packing and result reassembly;
  // the emplace-style call() overload constructs SerialCoordInput
  // in-place from the forwarded constructor arguments.
  SerialCoordResult result =
      connected->translate_coords_serial(xTrans, yTrans, coords).get();
 
  if (result.coords_count() != coords.size())
    throw std::runtime_error("Serial coord translate result size mismatch");
  size_t i = 0;
  for (const SerialCoordValue &got : result.coords()) {
    uint32_t expX = coords[i].x + xTrans;
    uint32_t expY = coords[i].y + yTrans;
    if (got.x != expX || got.y != expY)
      throw std::runtime_error("Serial coord translate result mismatch");
    ++i;
  }
  std::cout << "serial_coord_translate ok\n";
  return 0;
}
 
static int runDepthConstant(Accelerator *) {
  std::cout << "depth: 0x" << std::hex << esi_system::LoopbackIP::depth
            << std::dec << "\n";
  std::cout << "depth_constant ok\n";
  return 0;
}
 
ESI_PROBE_REGISTRY(
    "loopback-typed-cpp",
    "Loopback cosim test using generated ESI headers and typed ports.",
    {"depth_constant", &runDepthConstant}, {"loopback_i8", &runLoopbackI8},
    {"sint4_loopback", &runSInt4Loopback}, {"struct_func", &runStructFunc},
    {"odd_struct_func", &runOddStructFunc}, {"array_func", &runArrayFunc},
    {"serial_coord_translate", &serialCoordTranslateTest}, );