carrier.cpp

Go to the documentation of this file.

// Copyright (c) 2024 anabrid GmbH
// Contact: https://www.anabrid.com/licensing/
// SPDX-License-Identifier: MIT OR GPL-2.0-or-later
 
#include "pb_decode.h"
#include "redac/calibration.h"
#include "run/run_manager.h"
 
#include <entity/visitor.h>
#include <lucidac/lucidac.h>
#include <mode/mode.h>
#include <span>
#include <net/settings.h>
#include <redac/redac.h>
#include <utils/is_number.h>
 
carrier::Carrier::Carrier(std::vector<platform::Cluster> clusters, carrier::Carrier_HAL *hardware)
    : Entity("", hardware), hardware(hardware), clusters(std::move(clusters)) {
  classifier.class_enum = CLASS_;
}
 
carrier::Carrier *carrier::Carrier::from_entity_classifier(entities::EntityClassifier classifier,
                                                                    __attribute__((__unused__))
                                                                    const bus::addr_t block_address) {
  if (!classifier or classifier.class_enum != entities::EntityClass::CARRIER)
    return nullptr;
 
  auto type = classifier.type_as<TYPES>();
  switch (type) {
  case TYPES::UNKNOWN:
    // This is already checked by !classifier above
    return nullptr;
  case TYPES::LUCIDAC:
    return platform::LUCIDAC::from_entity_classifier(classifier, block_address);
  case TYPES::mREDAC:
    return platform::REDAC::from_entity_classifier(classifier, block_address);
  }
  // Any unknown value results in a nullptr here.
  // Adding default case to switch suppresses warnings about missing cases.
  return nullptr;
}
 
carrier::Carrier *carrier::Carrier::detect() {
  return entities::detect<carrier::Carrier>(bus::address_from_tuple(bus::CARRIER_BADDR, 0));
}
 
UnitResult carrier::Carrier::better_init() {
  LOG(ANABRID_DEBUG_INIT, __PRETTY_FUNCTION__);
 
  entity_id = net::StartupConfig::get().mac;
 
  if (entity_id.empty())
    return UnitResult::err("Cannot determine Carrier MAC");
 
  // Detect CTRL-block
  ctrl_block = entities::detect<blocks::CTRLBlock>(bus::address_from_tuple(bus::CTRL_BLOCK_BADDR, 0));
  if (!ctrl_block) {
    return UnitResult::err("Missing CTRL Block");
  }
 
  for (auto &cluster : clusters) {
    TRY_TRUE(cluster.init());
  }
 
  reset(entities::ResetAction::EVERYTHING);
 
  return UnitResult::ok();
}
 
uint8_t carrier::Carrier::get_active_adc_channel_range() const{
  uint8_t num_adc_channels = 0;
  for(size_t idx = 0; idx < m_adc_channels.size(); idx++){
    if(m_adc_channels[idx].src != ADCChannel::DISABLED)
      num_adc_channels = idx + 1;
  }
  return num_adc_channels;
}
 
std::vector<entities::Entity *> carrier::Carrier::get_child_entities() {
  std::vector<entities::Entity *> children;
  for (auto &cluster : clusters) {
    children.push_back(&cluster);
  }
  if (ctrl_block)
    children.push_back(ctrl_block);
  return children;
}
 
entities::Entity *carrier::Carrier::get_child_entity(std::string_view child_id) {
  auto opt_int = utils::view_to_number(child_id);
  if (opt_int.has_value()) {
    auto cluster_idx = opt_int.value();
    if (cluster_idx < 0 or clusters.size() < cluster_idx)
      return nullptr;
    return &clusters[cluster_idx];
  }
  if (child_id == "CTRL")
    return ctrl_block;
  if (child_id.size() == 17)
    return this;
  return nullptr;
}
 
ConfigResult carrier::Carrier::config(const pb_Item &item) {
  if (TRY(Entity::config(item)))
    return ConfigResult::ok(true);
 
  if (!hardware)
    return ConfigResult::err("Carrier cannot be configured without hardware");
 
  if (item.which_kind == pb_Item_adc_config_tag) {
    auto& carrier_config = item.kind.adc_config;
 
    if (carrier_config.channels_count > m_adc_channels.size())
      return ConfigResult::err("Channel count too large");
 
    m_adc_channels.fill(ADCChannel());
    for (size_t idx = 0; idx < carrier_config.channels_count; ++idx) {
      auto& channel = m_adc_channels[idx];
 
      auto& config_channel = carrier_config.channels[idx];
      channel.src = config_channel.idx;
      channel.gain = config_channel.gain;
      channel.offset = config_channel.offset;
      channel.probe = config_channel.probe;
    }
 
    if (!hardware->write_adc_bus_mux(m_adc_channels))
      return ConfigResult::err("Could not configure ACLs from configuration");
 
    return ConfigResult::ok(true);
  }
 
  return ConfigResult::ok(false);
}
 
void carrier::Carrier::extract(entities::ExtractVisitor &collector) {
  Entity::extract(collector);
 
  if (collector.include_specification()) {
    auto& entity_spec = collector.create(pb_Item_entity_specification_tag).kind.entity_specification;
    entity_spec.has_entity = true;
    encode_classifier(entity_spec.entity);
  }
 
  if (collector.include_configuration()) {
    auto& item = collector.create(pb_Item_adc_config_tag);
    auto& carrier_config = item.kind.adc_config = pb_AdcConfig_init_zero;
    for (auto & channel : m_adc_channels) {
      if (channel.src == ADCChannel::DISABLED) continue;
      auto& pb_channel = carrier_config.channels[carrier_config.channels_count++];
      pb_channel.idx = static_cast<uint32_t>(channel.src);
      pb_channel.gain = channel.gain;
      pb_channel.offset = channel.offset;
      pb_channel.probe = channel.probe;
    }
  }
}
 
bool carrier::Carrier::write_to_hardware() {
  int cluster_index = 1;
  for (auto &cluster : clusters) {
    auto result = cluster.write_to_hardware();
    if (!result) {
      return UnitResult::err("Cluster " + std::to_string(cluster_index) + " write failed.");
    }
    cluster_index++;
  }
 
  return write_adcs_to_hardware();
}
 
UnitResult carrier::Carrier::calibrate_offsets() {
  LOG(ANABRID_DEBUG_CALIBRATION, __PRETTY_FUNCTION__);
 
  for (auto &cluster : clusters)
    TRY(cluster.calibrate_offsets());
 
  LOG(ANABRID_DEBUG_CALIBRATION, __PRETTY_FUNCTION__);
  return UnitResult::ok();
}
 
UnitResult carrier::Carrier::calibrate_routes() {
  //entities::Setup setup;
  //entities::ExtractSettings settings{
  //  .include_configuration = true
  //};
  //setup.extract(this, settings);
  auto result = calibrate_routes_raw();
  //setup.apply(this, true);
  return result;
}
 
// This calibration function is working for a generic array of clusters that don't have any shared connections.
// LUCIDAC relies on this function, an mREDAC overwrites this function, as it can have cross cluster
// connections.
UnitResult carrier::Carrier::calibrate_routes_raw() {
  LOG(ANABRID_DEBUG_CALIBRATION, __PRETTY_FUNCTION__);
 
  bool gain_correction_exceeding = false;
  for (auto &cluster : clusters) {
    LOG_ANABRID_DEBUG_CALIBRATION(
        ("Calibrating routes in cluster " + std::to_string(cluster.get_cluster_idx())).c_str());
    // Save and change ADC bus selection
    auto old_adcbus = ctrl_block->get_adc_bus();
    auto old_adc_channels = get_adc_channels();
 
    reset_adc_channels();
 
    ctrl_block->set_adc_bus(blocks::CTRLBlock::ADCBus::ADC);
    TRY_TRUE(ctrl_block->write_to_hardware());
 
    // Save current U-block transmission modes and set them to zero
    LOG_ANABRID_DEBUG_CALIBRATION("Starting calibration");
    auto old_transmission_modes = cluster.ublock->get_all_transmission_modes();
    auto old_reference_magnitude = cluster.ublock->get_reference_magnitude();
 
    // Enable reference signal for calibration
    LOG_ANABRID_DEBUG_CALIBRATION("Enable u-block reference");
    cluster.ublock->change_all_transmission_modes(blocks::UBlock::Transmission_Mode::POS_REF);
    TRY_TRUE(cluster.ublock->write_to_hardware());
 
    // Save C-Block factors
    LOG_ANABRID_DEBUG_CALIBRATION("Reset c-block");
    auto old_c_block_factors = cluster.cblock->get_factors();
    cluster.cblock->set_factors({});
    TRY_TRUE (cluster.cblock->write_to_hardware());
 
    // Find an M block usable for its identity lanes
    blocks::MBlock *id_block = nullptr;
    if (cluster.m0block && cluster.m0block->has_id_lanes())
      id_block = cluster.m0block;
 
    if (!id_block && cluster.m1block && cluster.m1block->has_id_lanes())
      id_block = cluster.m1block;
 
    if (!id_block) {
      return UnitResult::err("No M Block with ID Lanes found, calibration impossible!");
    }
 
    uint8_t id_in_lane = 0, id_out_lane = 4;
    for (auto i = 0; i < id_block->ID_OUTPUT_CONNECTIONS().size(); i++) {
      if (id_block->ID_OUTPUT_CONNECTIONS()[i] != -1) {
        id_out_lane = id_block->slot_to_global_io_index(i);
        id_in_lane = id_block->slot_to_global_io_index(id_block->ID_OUTPUT_CONNECTIONS()[i]);
        break;
      }
    }
 
    std::array<std::vector<uint8_t>, blocks::IBlock::NUM_OUTPUTS> old_i_block_connections;
    for (auto i_out_idx : blocks::IBlock::OUTPUT_IDX_RANGE()) {
      for (auto i_in_idx : blocks::IBlock::INPUT_IDX_RANGE()) {
 
        // Only do something is this lane is used in the original I-block configuration
        if (!cluster.iblock->is_connected(i_in_idx, i_out_idx))
          continue;
 
        // If we don't have a complete connection through the u block, we don't need / we can't calibrate this
        // route from here
        if (!cluster.ublock->is_output_connected(i_in_idx))
          continue;
 
        // Store this i block input to output connection
        old_i_block_connections[i_out_idx].emplace_back(i_in_idx);
      }
    }
 
    LOG_ANABRID_DEBUG_CALIBRATION("Reset i-block");
    cluster.iblock->reset_outputs();
    TRY_TRUE(cluster.iblock->write_to_hardware());
 
    // Now we restore each summation isolated from the rest and route each summation output / i block output to
    // an M-Mul block
    for (auto i_out_idx : blocks::IBlock::OUTPUT_IDX_RANGE()) {
      for (auto i_in_idx : old_i_block_connections[i_out_idx])
        TRY(cluster.iblock->connect(i_in_idx, id_in_lane));
 
      TRY_TRUE(cluster.iblock->write_to_hardware());
 
      // Now switch through all relevant input signals and put one of them to 1.0
      for (auto i_in_idx : old_i_block_connections[i_out_idx]) {
        // Setup measure path
        TRY(set_adc_channel(0, id_out_lane));
        if (!hardware->write_adc_bus_mux(m_adc_channels))
          return UnitResult::err("Writing adcs failed!");
 
        // Depending on whether upscaling is enabled for this lane, we apply +1 or +0.1 reference
        // This is done on all lanes (but no other I-block connection exists, so no other current flows)
        bool upscaled_channel = cluster.iblock->get_upscaling(i_in_idx);
        cluster.ublock->change_reference_magnitude(upscaled_channel
                                                       ? blocks::UBlock::Reference_Magnitude::ONE_TENTH
                                                       : blocks::UBlock::Reference_Magnitude::ONE);
        TRY_TRUE(cluster.ublock->write_to_hardware());
 
        // First measure the offset of each measuring lane. The SH Block can not calibrate offsets that occur
        // after himself so we need to take care of that.
        TRY(cluster.cblock->set_factor(i_in_idx, 0.0f));
        TRY(cluster.cblock->set_gain_correction(i_in_idx, 1.0f));
        TRY_TRUE(cluster.cblock->write_to_hardware());
 
        // Calibrate offsets for this specific route
        TRY(calibrate_offsets());
 
        auto measured_offset = -daq::average(daq::sample, 4, 10)[0];
 
        // Allow this connection to go up to full scale. Those values are allways legal so we can ignore the
        // return value
        (void)cluster.cblock->set_factor(i_in_idx, 1.0f);
        TRY_TRUE(cluster.cblock->write_to_hardware());
 
        delay(10);
 
        // Measure gain output
        auto measured_gain = -daq::average(daq::sample, 4, 10)[0];
        LOG_ANABRID_DEBUG_CALIBRATION(measured_gain);
        // Calculate necessary gain correction
        auto gain_correction = (upscaled_channel ? 0.8 : 1.0) / (measured_gain - measured_offset);
        LOG_ANABRID_DEBUG_CALIBRATION(gain_correction);
        if (gain_correction > 1.1f) {
          gain_correction_exceeding = true;
          gain_correction = 1.1f;
        }
        // Set gain correction on C-block, which will automatically get applied when writing to hardware
        TRY(cluster.cblock->set_gain_correction(i_in_idx, gain_correction));
        // Deactivate this lane again
        TRY(cluster.cblock->set_factor(i_in_idx, 0.0f));
        LOG_ANABRID_DEBUG_CALIBRATION(" ");
      }
 
      cluster.iblock->reset_outputs();
      reset_adc_channels();
    }
 
    // Restore original U-block transmission modes and reference
    cluster.ublock->change_all_transmission_modes(old_transmission_modes);
    cluster.ublock->change_reference_magnitude(old_reference_magnitude);
    // Write them to hardware
    LOG_ANABRID_DEBUG_CALIBRATION("Restoring u-block");
    TRY_TRUE(cluster.ublock->write_to_hardware());
 
    // Restore C-block factors
    cluster.cblock->set_factors(old_c_block_factors);
    LOG_ANABRID_DEBUG_CALIBRATION("Restoring c-block");
    TRY_TRUE(cluster.cblock->write_to_hardware());
 
    // Restore I-block connections
    LOG_ANABRID_DEBUG_CALIBRATION("Restoring i-block");
    for (auto i_out_idx : blocks::IBlock::OUTPUT_IDX_RANGE())
      for (auto i_in_idx : old_i_block_connections[i_out_idx])
        TRY(cluster.iblock->connect(i_in_idx, i_out_idx));
 
    TRY_TRUE(cluster.iblock->write_to_hardware());
 
    // Restore ADC bus selection
    ctrl_block->set_adc_bus(old_adcbus);
    TRY_TRUE(ctrl_block->write_to_hardware());
 
    TRY(set_adc_channels(old_adc_channels));
    if (!hardware->write_adc_bus_mux(m_adc_channels))
      return UnitResult::err("Writing adcs failed");
  }
 
  if (gain_correction_exceeding)
    return UnitResult::err("Gain correction is too high, this is probably a problem with the hardware");
 
  // Calibrate offsets for complete system
  auto result = Carrier::calibrate_offsets();
  LOG(ANABRID_DEBUG_CALIBRATION, __PRETTY_FUNCTION__);
  return result;
}
 
UnitResult carrier::Carrier::calibrate_mblock(platform::Cluster &cluster, blocks::MBlock &mblock) {
  // CARE: This function does not preserve the currently configured routes
  LOG(ANABRID_DEBUG_CALIBRATION, __PRETTY_FUNCTION__);
 
  // The calibration for each M-Block is prepared by connecting all outputs
  // to the ADCs. This limits the calibration to one M-Block (and one cluster) at a time,
  // which is not a problem though.
  // Each M-Block must connect required reference signals by itself.
 
  LOG(ANABRID_DEBUG_CALIBRATION, "Connecting outputs to ADC...");
  for (auto output_idx : blocks::MBlock::SLOT_OUTPUT_IDX_RANGE()) {
    auto lane_idx = mblock.slot_to_global_io_index(output_idx);
    TRY(set_adc_channel(output_idx, lane_idx, cluster.get_cluster_idx()));
  }
  // Write to hardware
  TRY_TRUE(write_to_hardware());
 
  // Pass to calibration function
  LOG(ANABRID_DEBUG_CALIBRATION, "Passing control to M-block...");
  TRY(mblock.calibrate(&cluster, this));
 
  LOG(ANABRID_DEBUG_CALIBRATION, "Cleaning up calibration signals...");
  reset(entities::ResetAction::CIRCUIT_RESET);
 
  // Write final clean-up to hardware
  TRY_TRUE(write_to_hardware());
 
  LOG(ANABRID_DEBUG_CALIBRATION, "Calibration done.");
  LOG(ANABRID_DEBUG_CALIBRATION, __PRETTY_FUNCTION__);
 
  return UnitResult::ok();
}
 
UnitResult carrier::Carrier::calibrate_m_blocks() {
  for (auto &cluster : clusters) {
    for (auto mblock : {cluster.m0block, cluster.m1block}) {
      if (!mblock) continue;
      TRY(calibrate_mblock(cluster, *mblock));
    }
  }
 
  return UnitResult::ok();
}
 
void carrier::Carrier::reset(entities::ResetAction action) {
  for (auto &cluster : clusters) {
    cluster.reset(action);
  }
  if (ctrl_block)
    ctrl_block->reset(action);
  reset_adc_channels();
}
 
const std::array<carrier::ADCChannel, 8> &carrier::Carrier::get_adc_channels() const { return m_adc_channels; }
 
UnitResult carrier::Carrier::set_adc_channels(const std::array<carrier::ADCChannel, 8> &channels) {
  // Check that all inputs are in a valid range
  uint8_t channel_idx = 0;
  for (auto channel : channels) {
    TRY(set_adc_channel(channel_idx, channel));
    ++channel_idx;
  }
  return UnitResult::ok();
}
 
UnitResult carrier::Carrier::set_adc_channels(const std::array<int8_t, 8> &channels) {
  // Check that all inputs are in a valid range
  uint8_t channel_idx = 0;
  for (auto channel : channels) {
    TRY(set_adc_channel(channel_idx, channel));
    ++channel_idx;
  }
  return UnitResult::ok();
}
 
UnitResult carrier::Carrier::set_adc_channel(uint8_t adc_channel, ADCChannel src_channel) {
  if (adc_channel >= m_adc_channels.size())
    return UnitResult::err_fmt("Error carrier channel out of range: %d", adc_channel);
 
  m_adc_channels[adc_channel] = src_channel;
  return UnitResult::ok();
}
 
[[nodiscard]] UnitResult carrier::Carrier::set_adc_channel(uint8_t adc_channel, int8_t src_idx) {
  return set_adc_channel(adc_channel, ADCChannel{
    .src = src_idx,
  });
}
 
UnitResult carrier::Carrier::set_adc_channel(uint8_t adc_channel, int8_t src_idx, uint8_t cluster_idx) {
  return set_adc_channel(adc_channel, static_cast<int8_t>(src_idx + cluster_idx * 16));
}
 
void carrier::Carrier::reset_adc_channels() {
  m_adc_channels.fill(ADCChannel());
}
 
UnitResult carrier::Carrier::measure_all_signals(std::array<std::array<float, 8>, 6> &data) {
  auto old_adc_channels = get_adc_channels();
  reset_adc_channels();
  size_t idx = static_cast<size_t>(-1);
  for (const auto &cluster : clusters) {
    for (const auto mblock : {cluster.m0block, cluster.m1block}) {
      ++idx;
      if (!mblock) continue;
 
      for (auto slot : blocks::MBlock::SLOT_OUTPUT_IDX_RANGE())
        TRY(set_adc_channel(slot, mblock->slot_to_global_io_index(slot), cluster.get_cluster_idx()));
 
      TRY_TRUE(write_to_hardware());
      data[idx] = daq::average();
    }
  }
  TRY(set_adc_channels(old_adc_channels));
  return UnitResult::ok();
}
 
UnitResult carrier::Carrier::write_adcs_to_hardware(const std::array<ADCChannel, 8>& channels) {
  if (ctrl_block)
    TRY_TRUE(ctrl_block->write_to_hardware());
 
  if (!hardware->write_adc_bus_mux(channels))
    return UnitResult::err("ADC Bus write failed.");
 
  return UnitResult::ok();
}
 
UnitResult carrier::Carrier::calibrate(const pb_CalibrationConfig &item) {
#ifdef ANABRID_DEBUG_COMMS
  Serial.println(__PRETTY_FUNCTION__);
#endif
 
  if(item.math != pb_CalibrationConfig_Kind_Disabled) {
    //following calibrations are not configuration preserving
    entities::Setup setup;
    entities::ExtractSettings settings{
      .include_configuration = true
    };
    setup.extract(this, settings);
    reset(entities::ResetAction::CIRCUIT_RESET);
    TRY_TRUE(write_to_hardware());
    TRY(calibrate_m_blocks());
 
    TRY(setup.apply(this, true));
  }
 
  if (item.offset != pb_CalibrationConfig_Kind_Disabled)
    TRY(calibrate_offsets());
 
  return UnitResult::ok();
}
 
UnitResult carrier::Carrier::user_get_overload_status(pb_OverloadStatus &overload_status) {
  entities::OverloadVisitor visitor;
  visitor.visit(this, true);
  visitor.to(overload_status);
  return UnitResult::ok();
}
 
UnitResult carrier::Carrier::user_calibrate(const pb_CalibrationConfig &item) {
  return calibrate(item);
}
 
static Result<uint32_t> parse_uint(std::string_view view)
{
  char* eptr = nullptr;
  auto result = std::strtol(view.begin(), &eptr, 10);
  if(eptr - view.begin() != view.length())
    return Result<uint32_t>::err("Invalid path: " + std::string(view));
 
  return Result<uint32_t>::ok(result);
}
 
 
PathResult Routing::index2path(uint32_t node) const {
  if (m_idx2path.size() <= node)
    return PathResult::err_fmt("Unable to find path of entity idx: %d", node);
  return PathResult::ok(m_idx2path.at(node));
}
 
U32Result Routing::path2index(Path path) const {
  auto it = m_path2idx.find(path);
  if (it == m_path2idx.end())
    return LaneResult::err_fmt("Unable to find entity idx of path %s", std::string(path).c_str());
 
  return U32Result::ok(m_path2idx.at(path));
}
 
LaneResult Routing::cluster2lane(uint32_t cluster_idx, uint32_t lane_idx) const {
  if (!m_self_idx.has_value())
    return LaneResult::err_fmt("Invalid self index for %s", carrier::Carrier::get().get_entity_id().c_str());
  return LaneResult::ok(Lane(*m_self_idx, cluster_idx, lane_idx));
}
 
UnitResult Routing::config_entity_idx(const pb_EntityId* carrier_indices, uint32_t count) {
  m_idx2path.resize(count);
  m_self_idx = std::nullopt;
  for (auto carrier_idx = 0; carrier_idx < count; ++carrier_idx) {
    auto& carrier_path = carrier_indices[carrier_idx];
    Path path = std::string_view(carrier_path.path);
    if (path.size() != 1)
      return ConfigResult::err("Expected cluster path in trace config");
    if (path.segment(0) == m_self) {
      m_self_idx = carrier_idx;
    }
 
    m_path2idx.emplace(path, carrier_idx);
    m_idx2path[carrier_idx] = path;
  }
  return UnitResult::ok();
}
 
UnitResult Routing::config_trace_config(const pb_DependencyInfo& dep_info) {
  clear();
 
  TRY(config_entity_idx(dep_info.entity_ids, dep_info.entity_ids_count));
 
  for (auto idx = 0; idx < dep_info.traces_count; ++idx) {
    auto& trace = dep_info.traces[idx];
    Lane src_lane(trace.source.carrier, trace.source.cluster, trace.source.lane);
    Lane sink_lane(trace.sink.carrier, trace.sink.cluster, trace.sink.lane);
    m_src2uses[src_lane]++;
    if (trace.sink_upscaled) {
      m_src_is_upscaled.insert(src_lane);
      m_sink_is_upscaled.insert(sink_lane);
    }
    m_sink2src.emplace(sink_lane, src_lane);
    m_sink_is_present.insert(sink_lane);
  }
 
  return UnitResult::ok();
}
 
 
ConfigResult Routing::config(const pb_Item &item){
  if (item.which_kind == pb_Item_dependency_info_tag) {
    TRY(config_trace_config(item.kind.dependency_info));
    return ConfigResult::ok(true);
  }
 
  if (item.which_kind == pb_Item_ip_lookup_table_tag) {
    auto& ip_lookup_table = item.kind.ip_lookup_table;
    for (size_t idx = 0; idx < ip_lookup_table.entries_count; ++idx) {
      auto& entity = ip_lookup_table.entries[idx];
      if (!entity.has_address || !entity.has_entity_id) continue;
      auto& data = entity.address.data.bytes;
      IPAddress address(data[0], data[1], data[2], data[3]);
      set_path_address(std::string_view(entity.entity_id.path), address);
    }
  }
 
  return ConfigResult::ok(false);
}
 
bool Routing::is_sink_upscaled(Lane lane) const {
  auto it = m_sink_is_upscaled.find(lane);
  return it != m_sink_is_upscaled.end();
}
 
bool Routing::is_source_upscaled(Lane lane) const {
  auto it = m_src_is_upscaled.find(lane);
  return it != m_src_is_upscaled.end();
}
 
uint32_t Routing::use_count(Lane lane) const {
  auto it = m_src2uses.find(lane);
  if (it == m_src2uses.end())
    return 0;
  return it->second;
}
 
LaneResult Routing::source(Lane lane) const {
  auto it = m_sink2src.find(lane);
  if (it == m_sink2src.end())
    return LaneResult::err("Not found source");
  return LaneResult::ok(it->second);
}
 
bool Routing::is_source_used(Lane lane) const {
  return use_count(lane) > 0;
}
 
bool Routing::is_sink_present(Lane lane) const {
  auto it = m_sink_is_present.find(lane);
  return it != m_sink_is_present.end();
}
 
IPAddressResult Routing::ip_address(Path path) const {
  auto it = m_path2ip.find(path);
  if (it != m_path2ip.end())
    return IPAddressResult::ok(it->second);
  return UnitResult::err_fmt("Ip adress of %s not found", std::string(path).c_str());
}
 
 
LaneResult Routing::source(uint32_t cluster_idx, uint32_t lane) const {
  return source(TRY(cluster2lane(cluster_idx, lane)));
}
 
BoolResult Routing::is_source_upscaled(uint32_t cluster_idx, uint32_t lane) const {
  return BoolResult::ok(is_source_upscaled(TRY(cluster2lane(cluster_idx, lane))));
}
 
BoolResult Routing::is_sink_upscaled(uint32_t cluster_idx, uint32_t lane) const {
  return BoolResult::ok(is_sink_upscaled(TRY(cluster2lane(cluster_idx, lane))));
}
 
U32Result Routing::use_count(uint32_t cluster_idx, uint32_t lane) const {
  return U32Result::ok(use_count(TRY(cluster2lane(cluster_idx, lane))));
}
 
PathResult Routing::source_path(uint32_t cluster_idx, uint32_t lane) const {
  return index2path(TRY(source(TRY(cluster2lane(cluster_idx, lane)))).m_carrier);
}
 
BoolResult Routing::is_sink_present(uint32_t cluster_idx, uint32_t lane) const {
  return BoolResult::ok(is_sink_present(TRY(cluster2lane(cluster_idx, lane))));
}
 
BoolResult Routing::is_source_used(uint32_t cluster_idx, uint32_t lane) const {
  return BoolResult::ok(is_source_used(TRY(cluster2lane(cluster_idx, lane))));
}