[alf] Transition to Serial-Endpoint ID scheme for services

Author: kostorr

README.md

@@ -20,25 +20,25 @@ DIM_DNS_NODE=thedimdns.cern.ch
 `
 
 ### o2-alf-client
-o2-alf-client is the binary of an ALF client used solely for testing purposes. On top of the DIM Nameserver it expects the hostname of the node hosting the ALF server, the card's sequence number and the link number as command-line arguments. Different arguments to test different types of services are available (run with `--help`).
+o2-alf-client is the binary of an ALF client used solely for testing purposes. On top of the DIM Nameserver it expects the hostname of the node hosting the ALF server, the card's serial and endpoint, and the link number as command-line arguments. Different arguments to test different types of services are available (run with `--help`).
 
 `
-o2-alf-client --dim-dns-node thedimdns.cern.ch --alf-id thealfserver --card-sequence 0 --link 4
+o2-alf-client --dim-dns-node thedimdns.cern.ch --alf-id thealfserver --serial 1041 --endpoint 1 --link 4
 `
 
 ### o2-alf-lib-client
 o2-alf-lib-client is the binary of an ALF SC library client used solely for testing purposes. It expects parameters for the SC modules to test, the card and link ID (run with `--help` for the different options).
 
 `
-o2-alf-lib-client --card-id=#1 --link-id=0 --swt
+o2-alf-lib-client --card-id=#1 --serial=1041 --endpoint=1 --swt
 `
 
 ## DIM Services
 
-Service names are identified by the server's hostname, the card's sequence number (as reported during ALF's startup) and the link, as follows:
+Service names are identified by the server's hostname, the card's serial and endpoint pair and the link, as follows:
 
 `
-ALF_[hostname]/SERIAL_[card_sequence_number]/LINK_[link]/[service_name]
+ALF_[hostname]/SERIAL_[serial]/ENDPOINT_[endpoint]/LINK_[link]/[service_name]
 `
 
 ### DIM RPC services

apps/Alf.cxx

@@ -85,7 +85,6 @@ class Alf : public AliceO2::Common::Program
     AlfServer alfServer = AlfServer();
 
     std::vector<roc::CardDescriptor> cardsFound = roc::findCards();
-    int cardSequence = -1;
     for (auto const& card : cardsFound) {
       std::vector<AlfLink> links;
 
@@ -101,32 +100,29 @@ class Alf : public AliceO2::Common::Program
         }
       }
 
-      cardSequence++;
-
       if (card.cardType == roc::CardType::Cru) {
 
-        Logger::get().log() << "CRU #" << cardSequence << " : " << card.pciAddress << endm;
-        bar = roc::ChannelFactory().getBar(card.pciAddress, 2);
+        Logger::get().log() << "CRU " << card.serialId << endm;
+        bar = roc::ChannelFactory().getBar(card.serialId, 2);
         for (int linkId = 0; linkId < CRU_NUM_LINKS; linkId++) {
-          links.push_back({ alfId, cardSequence, linkId, bar, roc::CardType::Cru });
+          links.push_back({ alfId, card.serialId, linkId, card.serialId.getEndpoint() * 12 + linkId, bar, roc::CardType::Cru });
         }
 
       } else if (card.cardType == roc::CardType::Crorc) {
-        Logger::get().log() << "CRORC #" << cardSequence << " : " << card.pciAddress << endm;
+        Logger::get().log() << "CRORC " << card.serialId << endm;
         for (int linkId = 0; linkId < CRORC_NUM_LINKS; linkId++) {
-          bar = roc::ChannelFactory().getBar(card.pciAddress, linkId);
-          links.push_back({ alfId, cardSequence, linkId, bar, roc::CardType::Crorc });
+          bar = roc::ChannelFactory().getBar(card.serialId, linkId);
+          links.push_back({ alfId, card.serialId, linkId, -1, bar, roc::CardType::Crorc });
         }
       } else {
-        Logger::get().log() << AliceO2::InfoLogger::InfoLogger::Severity::Warning << card.pciAddress << " is not a CRU or a CRORC. Skipping..." << endm;
+        Logger::get().log() << AliceO2::InfoLogger::InfoLogger::Severity::Warning << card.serialId << " is not a CRU or a CRORC. Skipping..." << endm;
       }
 
       if (isVerbose()) {
         for (auto const& link : links) {
-          Logger::get().log() << link.alfId << " " << link.cardSequence << " " << link.linkId << endm;
+          Logger::get().log() << link.alfId << " " << link.serialId << " " << link.linkId << endm;
         }
       }
-
       alfServer.makeRpcServers(links);
     }
 

apps/AlfClient.cxx

@@ -50,9 +50,12 @@ class AlfClient : public AliceO2::Common::Program
     options.add_options()("dim-dns-node",
                           po::value<std::string>(&mOptions.dimDnsNode)->default_value(""),
                           "The DIM DNS node to connect to if the env var is not set");
-    options.add_options()("card-sequence",
-                          po::value<int>(&mOptions.cardSequence),
-                          "Card sequence number");
+    options.add_options()("serial",
+                          po::value<int>(&mOptions.serial),
+                          "Card serial number");
+    options.add_options()("endpoint",
+                          po::value<int>(&mOptions.endpoint),
+                          "Card endpoint");
     options.add_options()("link",
                           po::value<int>(&mOptions.link),
                           "Link number");
@@ -112,9 +115,9 @@ class AlfClient : public AliceO2::Common::Program
     std::string alfId = mOptions.alfId;
     boost::to_upper(alfId);
 
-    Logger::get().log() << "Starting the DIM Client using ALF ID=" << alfId << ", card #=" << mOptions.cardSequence << " and link=" << mOptions.link << endm;
+    Logger::get().log() << "Starting the DIM Client using ALF ID=" << alfId << ", card=" << mOptions.serial << ":" << mOptions.endpoint << " and link=" << mOptions.link << endm;
 
-    AlfLink link = AlfLink{ alfId, mOptions.cardSequence, mOptions.link, nullptr, roc::CardType::Cru };
+    AlfLink link = AlfLink{ alfId, roc::SerialId(mOptions.serial, mOptions.endpoint), mOptions.link, mOptions.endpoint * 12 + mOptions.link, nullptr, roc::CardType::Cru };
 
     ServiceNames names(link);
 
@@ -254,7 +257,8 @@ class AlfClient : public AliceO2::Common::Program
  private:
   struct OptionsStruct {
     std::string dimDnsNode = "";
-    int cardSequence = -1;
+    int serial = -1;
+    int endpoint = 0;
     int link = -1;
     std::string alfId = "";
     bool crorc = false;

apps/AlfLibClient.cxx

@@ -53,16 +53,19 @@ class AlfLibClient : public AliceO2::Common::Program
     options.add_options()("swt",
                           po::bool_switch(&mOptions.swt)->default_value(false),
                           "Flag enabling the swt tests");
-    options.add_options()("id",
-                          po::value<std::string>(&mOptions.cardId)->default_value("-1"),
-                          "Card ID to use");
+    options.add_options()("serial",
+                          po::value<int>(&mOptions.serial)->default_value(-1),
+                          "Serial to use");
+    options.add_options()("endpoint",
+                          po::value<int>(&mOptions.endpoint)->default_value(0),
+                          "Endpoint to use");
   }
 
   virtual void run(const po::variables_map&) override
   {
     if (mOptions.sca) {
       std::cout << "Running SCA test" << std::endl;
-      auto sca = Sca(mOptions.cardId, mOptions.link);
+      auto sca = Sca(roc::SerialId{ mOptions.serial, mOptions.endpoint }, mOptions.link);
       sca.reset();
 
       std::cout << "Running simple SCA operation" << std::endl;
@@ -96,7 +99,7 @@ class AlfLibClient : public AliceO2::Common::Program
 
     if (mOptions.swt) {
       std::cout << "Running SWT test" << std::endl;
-      auto swt = Swt(mOptions.cardId, mOptions.link);
+      auto swt = Swt(roc::SerialId{ mOptions.serial, mOptions.endpoint }, mOptions.link);
 
       std::cout << "Running simple SWT operations" << std::endl;
       try {
@@ -116,7 +119,7 @@ class AlfLibClient : public AliceO2::Common::Program
 
       std::cout << "Running an SWT sequence" << std::endl;
       std::vector<std::pair<Swt::Operation, Swt::Data>> ops;
-      swt = Swt(mOptions.cardId);
+      swt = Swt(roc::SerialId{ mOptions.serial, mOptions.endpoint });
       swt.setChannel(1);
       ops.push_back({ Swt::Operation::Reset, {} });
       ops.push_back({ Swt::Operation::Write, SwtWord{ 0xcafe, 0x41d, 0x0 } });
@@ -150,7 +153,7 @@ class AlfLibClient : public AliceO2::Common::Program
 
     if (mOptions.ic) {
       std::cout << "Running IC test" << std::endl;
-      auto ic = Ic(mOptions.cardId, mOptions.link);
+      auto ic = Ic(roc::SerialId{ mOptions.serial, mOptions.endpoint }, mOptions.link);
       ic.reset();
 
       std::cout << "Running Simple IC operations" << std::endl;
@@ -197,7 +200,8 @@ class AlfLibClient : public AliceO2::Common::Program
     bool lla = false;
     bool sca = false;
     bool swt = false;
-    std::string cardId = "-1";
+    int serial = -1;
+    int endpoint = 0;
   } mOptions;
 };
 

include/Alf/Common.h

@@ -28,16 +28,17 @@ namespace alf
 
 namespace roc = AliceO2::roc;
 
-static constexpr int CRU_NUM_LINKS(24);
+static constexpr int CRU_NUM_LINKS(12);
 static constexpr int CRORC_NUM_LINKS(6);
 
 static constexpr auto BUSY_TIMEOUT = std::chrono::milliseconds(10);
 static constexpr auto CHANNEL_BUSY_TIMEOUT = std::chrono::milliseconds(10);
 
 struct AlfLink {
   std::string alfId;
-  int cardSequence;
+  roc::SerialId serialId = { -1, 0 };
   int linkId;
+  int rawLinkId;
   std::shared_ptr<roc::BarInterface> bar;
   roc::CardType::type cardType;
 };

include/Alf/Lla.h

@@ -28,15 +28,15 @@ namespace alf
 class LlaSession
 {
  public:
-  LlaSession(std::string sessionName, int cardId);
+  LlaSession(std::string sessionName, roc::SerialId serialId);
   void start();
   void stop();
 
  private:
   lla::SessionParameters mParams;
   std::unique_ptr<lla::Session> mSession;
   std::string mSessionName;
-  int mCardId;
+  roc::SerialId mSerialId;
 };
 
 } // namespace alf

src/AlfClient.h

@@ -158,7 +158,6 @@ class RegisterSequenceRpc : DimRpcInfoWrapper
 
   std::string write(const std::string& buffer)
   {
-    std::cout << "Setting: " << buffer << std::endl;
     setString(buffer);
     std::string ret;
     try {

src/AlfServer.cxx

@@ -155,41 +155,41 @@ std::string AlfServer::patternPlayer(const std::string& parameter, std::shared_p
   return "";
 }
 
-std::string AlfServer::llaSessionStart(const std::string& parameter, int cardId)
+std::string AlfServer::llaSessionStart(const std::string& parameter, roc::SerialId serialId)
 {
   std::vector<std::string> parameters = Util::split(parameter, pairSeparator());
   if (parameters.size() < 1 || parameters.size() > 2) {
     BOOST_THROW_EXCEPTION(AlfException() << ErrorInfo::Message("Wrong number of parameters for the LLA Session Start RPC call: " + std::to_string(parameters.size())));
   }
 
-  if (mSessions.find(cardId) == mSessions.end()) {
+  if (mSessions.find(serialId) == mSessions.end()) {
     lla::SessionParameters params = lla::SessionParameters::makeParameters()
                                       .setSessionName(parameters[0])
-                                      .setCardId(roc::PciSequenceNumber(cardId));
-    mSessions[cardId] = std::make_unique<lla::Session>(params);
+                                      .setCardId(serialId);
+    mSessions[serialId] = std::make_unique<lla::Session>(params);
   } /*else {
     // TODO: Update session name?
   }*/
 
   if (parameters.size() == 2) {
-    if (!mSessions[cardId]->timedStart(std::stoi(parameters[1]))) {
-      BOOST_THROW_EXCEPTION(AlfException() << ErrorInfo::Message("Could not start session for serial " + std::to_string(cardId)));
+    if (!mSessions[serialId]->timedStart(std::stoi(parameters[1]))) {
+      BOOST_THROW_EXCEPTION(AlfException() << ErrorInfo::Message("Could not start session for serial " + serialId.toString()));
     }
   } else {
-    if (!mSessions[cardId]->start()) {
-      BOOST_THROW_EXCEPTION(AlfException() << ErrorInfo::Message("Could not start session for serial " + std::to_string(cardId)));
+    if (!mSessions[serialId]->start()) {
+      BOOST_THROW_EXCEPTION(AlfException() << ErrorInfo::Message("Could not start session for serial " + serialId.toString()));
     }
   }
   return "";
 }
 
-std::string AlfServer::llaSessionStop(const std::string& /*parameter*/, int cardId)
+std::string AlfServer::llaSessionStop(const std::string& /*parameter*/, roc::SerialId serialId)
 {
-  if (mSessions.find(cardId) == mSessions.end()) {
-    BOOST_THROW_EXCEPTION(AlfException() << ErrorInfo::Message("Session was not started for serial  " + std::to_string(cardId)));
+  if (mSessions.find(serialId) == mSessions.end()) {
+    BOOST_THROW_EXCEPTION(AlfException() << ErrorInfo::Message("Session was not started for serial  " + serialId.toString()));
   }
 
-  mSessions[cardId]->stop();
+  mSessions[serialId]->stop();
   return "";
 }
 
@@ -510,7 +510,7 @@ std::vector<std::pair<Ic::Operation, Ic::Data>> AlfServer::parseStringToIcPairs(
 
 void AlfServer::makeRpcServers(std::vector<AlfLink> links)
 {
-  for (const auto& link : links) {
+  for (auto& link : links) {
 
     // Function to create RPC server
     auto makeServer = [&](std::string name, auto callback) {
@@ -521,7 +521,7 @@ void AlfServer::makeRpcServers(std::vector<AlfLink> links)
     ServiceNames names(link);
 
     // Start the RPC Servers
-    auto& servers = mRpcServers[link.cardSequence][link.linkId];
+    auto& servers = mRpcServers[link.serialId][link.linkId];
     std::shared_ptr<roc::BarInterface> bar = link.bar;
 
     if (link.cardType == roc::CardType::Cru) {
@@ -539,11 +539,11 @@ void AlfServer::makeRpcServers(std::vector<AlfLink> links)
 
         // LLA Session Start
         servers.push_back(makeServer(names.llaSessionStart(),
-                                     [link, this](auto parameter) { return llaSessionStart(parameter, link.cardSequence); }));
+                                     [link, this](auto parameter) { return llaSessionStart(parameter, link.serialId); }));
 
         // LLA Session Stop
         servers.push_back(makeServer(names.llaSessionStop(),
-                                     [link, this](auto parameter) { return llaSessionStop(parameter, link.cardSequence); }));
+                                     [link, this](auto parameter) { return llaSessionStop(parameter, link.serialId); }));
       }
 
       // SCA Sequence

src/AlfServer.h

@@ -55,8 +55,8 @@ class AlfServer
   static std::string icGbtI2cWrite(const std::string& parameter, AlfLink link);
   static std::string patternPlayer(const std::string& parameter, std::shared_ptr<roc::BarInterface>);
   static std::string registerBlobWrite(const std::string& parameter, AlfLink link);
-  std::string llaSessionStart(const std::string& parameter, int cardSequence);
-  std::string llaSessionStop(const std::string& parameter, int cardSequence);
+  std::string llaSessionStart(const std::string& parameter, roc::SerialId serialId);
+  std::string llaSessionStop(const std::string& parameter, roc::SerialId serialId);
 
   static std::vector<uint32_t> stringToRegisterPair(const std::string stringPair);
   static std::pair<Sca::Operation, Sca::Data> stringToScaPair(const std::string stringPair);
@@ -68,10 +68,14 @@ class AlfServer
   static std::vector<std::pair<Ic::Operation, Ic::Data>> parseStringToIcPairs(std::vector<std::string> stringPairs);
   static roc::PatternPlayer::Info parseStringToPatternPlayerInfo(const std::vector<std::string> sringsPairs);
 
-  /// cardSequence -> link -> vector of RPC servers
-  std::map<int, std::map<int, std::vector<std::unique_ptr<StringRpcServer>>>> mRpcServers;
+  // custom comparator for the SerialId keys of the maps
+  struct serialIdComparator {
+    bool operator()(const roc::SerialId& a, const roc::SerialId& b) { return a.toString() < b.toString(); };
+  };
 
-  std::map<int, std::unique_ptr<lla::Session>> mSessions;
+  /// serialId -> link -> vector of RPC servers
+  std::map<roc::SerialId, std::map<int, std::vector<std::unique_ptr<StringRpcServer>>>, serialIdComparator> mRpcServers;
+  std::map<roc::SerialId, std::unique_ptr<lla::Session>, serialIdComparator> mSessions;
 };
 
 } // namespace alf

src/DimServices/ServiceNames.cxx

@@ -48,12 +48,12 @@ DEFLINKSERVICENAME(icGbtI2cWrite, "IC_GBT_I2C_WRITE")
 
 std::string ServiceNames::formatLink(std::string name) const
 {
-  return ((boost::format("ALF_%1%/SERIAL_%2%/LINK_%3%/%4%") % mAlfId % mCardSequence % mLink % name)).str();
+  return ((boost::format("ALF_%1%/SERIAL_%2%/ENDPOINT_%3%/LINK_%4%/%5%") % mAlfId % mSerialId.getSerial() % mSerialId.getEndpoint() % mLink % name)).str();
 }
 
 std::string ServiceNames::format(std::string name) const
 {
-  return ((boost::format("ALF_%1%/SERIAL_%2%/%3%") % mAlfId % mCardSequence % name)).str();
+  return ((boost::format("ALF_%1%/SERIAL_%2%/ENDPOINT_%3%/%4%") % mAlfId % mSerialId.getSerial() % mSerialId.getEndpoint() % name)).str();
 }
 
 } // namespace alf