[cru] Dynamically get FW SP FIFO size

Author: kostorr

src/Cru/Constants.h

@@ -31,7 +31,7 @@ namespace Cru
 static constexpr int MAX_LINKS = 16;
 
 /// Amount of available superpage descriptors per link
-static constexpr int MAX_SUPERPAGE_DESCRIPTORS = 128;
+static constexpr int MAX_SUPERPAGE_DESCRIPTORS_DEFAULT = 128;
 
 /// DMA page length in bytes
 /// Note: the CRU has a firmware defined fixed page size
@@ -111,6 +111,10 @@ static constexpr Register DEBUG(0x00000c00);
 /// 0x11111111 -> Endpoint #1
 static constexpr Register ENDPOINT_ID(0x00000500);
 
+/// Register to get the size of the internal CRU per-link Superpage FIFO
+/// If it returns 0, use the default of MAX_SUPERPAGE_DESCRIPTORS_DEFAULT
+static constexpr Register MAX_SUPERPAGE_DESCRIPTORS(0x00000c04);
+
 ///*** bar2 ***///
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////

src/Cru/CruBar.cxx

@@ -1256,5 +1256,10 @@ void CruBar::setTimeFrameLength(uint16_t timeFrameLength)
   bar0->modifyRegister(Cru::Registers::TIME_FRAME_LENGTH.index, 20, 12, timeFrameLength);
 }
 
+uint32_t CruBar::getMaxSuperpageDescriptors()
+{
+  return readRegister(Cru::Registers::MAX_SUPERPAGE_DESCRIPTORS.index);
+}
+
 } // namespace roc
 } // namespace o2

src/Cru/CruBar.h

@@ -113,6 +113,8 @@ class CruBar final : public BarInterfaceBase
 
   std::vector<int> getDataTakingLinks();
 
+  uint32_t getMaxSuperpageDescriptors();
+
   std::shared_ptr<Pda::PdaBar> getPdaBar()
   {
     return mPdaBar;

src/Cru/CruDmaChannel.cxx

@@ -70,6 +70,18 @@ CruDmaChannel::CruDmaChannel(const Parameters& parameters)
     log(stream.str(), LogDebugDevel);
   }
 
+  // Calculate link and ready queue capacities
+  {
+    uint32_t maxSuperpageDescriptors = getBar()->getMaxSuperpageDescriptors();
+    // If number of descriptors reported is 0, the feature is not supported by the firmware. Fall back to default value
+    if (maxSuperpageDescriptors == 0x0) {
+      maxSuperpageDescriptors = Cru::MAX_SUPERPAGE_DESCRIPTORS_DEFAULT;
+    }
+
+    mLinkQueueCapacity = maxSuperpageDescriptors;
+    mReadyQueueCapacity = maxSuperpageDescriptors * Cru::MAX_LINKS;
+  }
+
   // Insert links
   {
     std::stringstream stream;
@@ -79,7 +91,7 @@ CruDmaChannel::CruDmaChannel(const Parameters& parameters)
     for (auto const& link : links) {
       stream << link << " ";
       //Implicit constructors are deleted for the folly Queue. Workaround to keep the Link struct with a queue * field.
-      std::shared_ptr<SuperpageQueue> linkQueue = std::make_shared<SuperpageQueue>(LINK_QUEUE_CAPACITY_ALLOCATIONS);
+      std::shared_ptr<SuperpageQueue> linkQueue = std::make_shared<SuperpageQueue>(mLinkQueueCapacity + 1); // folly queue needs + 1
       Link newLink = { static_cast<LinkId>(link), 0, linkQueue };
       mLinks.push_back(newLink);
     }
@@ -89,6 +101,8 @@ CruDmaChannel::CruDmaChannel(const Parameters& parameters)
     if (mLinks.empty()) {
       BOOST_THROW_EXCEPTION(Exception() << ErrorInfo::Message("No links are enabled. Check with roc-status. Configure with roc-config."));
     }
+
+    mReadyQueue = std::make_unique<SuperpageQueue>(mReadyQueueCapacity + 1); // folly queue needs + 1
   }
 }
 
@@ -101,8 +115,8 @@ auto CruDmaChannel::allowedChannels() -> AllowedChannels
 CruDmaChannel::~CruDmaChannel()
 {
   setBufferNonReady();
-  if (mReadyQueue.sizeGuess() > 0) {
-    log((format("Remaining superpages in the ready queue: %1%") % mReadyQueue.sizeGuess()).str(), LogDebugDevel);
+  if (mReadyQueue->sizeGuess() > 0) {
+    log((format("Remaining superpages in the ready queue: %1%") % mReadyQueue->sizeGuess()).str(), LogDebugDevel);
   }
 
   if (mDataSource == DataSource::Internal) {
@@ -138,10 +152,10 @@ void CruDmaChannel::deviceStartDma()
     }
     link.superpageCounter = 0;
   }
-  while (!mReadyQueue.isEmpty()) {
-    mReadyQueue.popFront();
+  while (!mReadyQueue->isEmpty()) {
+    mReadyQueue->popFront();
   }
-  mLinkQueuesTotalAvailable = LINK_QUEUE_CAPACITY * mLinks.size();
+  mLinkQueuesTotalAvailable = mLinkQueueCapacity * mLinks.size();
 
   // Start DMA
   setBufferReady();
@@ -249,7 +263,7 @@ bool CruDmaChannel::pushSuperpage(Superpage superpage)
   // Get the next link to push
   auto& link = mLinks[getNextLinkIndex()];
 
-  if (link.queue->sizeGuess() >= LINK_QUEUE_CAPACITY) {
+  if (link.queue->sizeGuess() >= mLinkQueueCapacity) {
     // Is the link's FIFO out of space?
     // This should never happen
     BOOST_THROW_EXCEPTION(Exception() << ErrorInfo::Message("Could not push superpage, link queue was full"));
@@ -268,19 +282,19 @@ bool CruDmaChannel::pushSuperpage(Superpage superpage)
 
 auto CruDmaChannel::getSuperpage() -> Superpage
 {
-  if (mReadyQueue.isEmpty()) {
+  if (mReadyQueue->isEmpty()) {
     BOOST_THROW_EXCEPTION(Exception() << ErrorInfo::Message("Could not get superpage, ready queue was empty"));
   }
-  return *mReadyQueue.frontPtr();
+  return *mReadyQueue->frontPtr();
 }
 
 auto CruDmaChannel::popSuperpage() -> Superpage
 {
-  if (mReadyQueue.isEmpty()) {
+  if (mReadyQueue->isEmpty()) {
     BOOST_THROW_EXCEPTION(Exception() << ErrorInfo::Message("Could not pop superpage, ready queue was empty"));
   }
-  auto superpage = *mReadyQueue.frontPtr();
-  mReadyQueue.popFront();
+  auto superpage = *mReadyQueue->frontPtr();
+  mReadyQueue->popFront();
 
   return superpage;
 }
@@ -310,7 +324,7 @@ void CruDmaChannel::transferSuperpageFromLinkToReady(Link& link, bool reclaim)
     link.queue->frontPtr()->setReceived(0);
   }
 
-  mReadyQueue.write(*link.queue->frontPtr());
+  mReadyQueue->write(*link.queue->frontPtr());
   link.queue->popFront();
   link.superpageCounter++;
   mLinkQueuesTotalAvailable++;
@@ -339,7 +353,7 @@ void CruDmaChannel::fillSuperpages()
     }
 
     while (amountAvailable) {
-      if (mReadyQueue.sizeGuess() >= READY_QUEUE_CAPACITY) {
+      if (mReadyQueue->sizeGuess() >= mReadyQueueCapacity) {
         break;
       }
 
@@ -358,19 +372,19 @@ int CruDmaChannel::getTransferQueueAvailable()
 // The transfer queue is empty when all its slots are available
 bool CruDmaChannel::isTransferQueueEmpty()
 {
-  return mLinkQueuesTotalAvailable == (LINK_QUEUE_CAPACITY * mLinks.size());
+  return mLinkQueuesTotalAvailable == (mLinkQueueCapacity * mLinks.size());
 }
 
 int CruDmaChannel::getReadyQueueSize()
 {
-  return mReadyQueue.sizeGuess();
+  return mReadyQueue->sizeGuess();
 }
 
 // Return a boolean that denotes whether the ready queue is full
 // The ready queue is full when the CRU has filled it up
 bool CruDmaChannel::isReadyQueueFull()
 {
-  return mReadyQueue.isFull();
+  return mReadyQueue->isFull();
 }
 
 int32_t CruDmaChannel::getDroppedPackets()

src/Cru/CruDmaChannel.h

@@ -70,13 +70,11 @@ class CruDmaChannel final : public DmaChannelPdaBase
  private:
   /// Max amount of superpages per link.
   /// This may not exceed the limit determined by the firmware capabilities.
-  static constexpr size_t LINK_QUEUE_CAPACITY = Cru::MAX_SUPERPAGE_DESCRIPTORS;
-  static constexpr size_t LINK_QUEUE_CAPACITY_ALLOCATIONS = LINK_QUEUE_CAPACITY + 1; // folly Queue needs + 1
+  size_t mLinkQueueCapacity;
 
   /// Max amount of superpages in the ready queue.
   /// This is an arbitrary size, can easily be increased if more headroom is needed.
-  static constexpr size_t READY_QUEUE_CAPACITY = Cru::MAX_SUPERPAGE_DESCRIPTORS * Cru::MAX_LINKS;
-  static constexpr size_t READY_QUEUE_CAPACITY_ALLOCATIONS = READY_QUEUE_CAPACITY + 1; // folly Queue needs + 1
+  size_t mReadyQueueCapacity;
 
   /// Queue for one link
   using SuperpageQueue = folly::ProducerConsumerQueue<Superpage>;
@@ -147,7 +145,7 @@ class CruDmaChannel final : public DmaChannelPdaBase
   size_t mLinkQueuesTotalAvailable;
 
   /// Queue for superpages that have been transferred and are waiting for popping by the user
-  SuperpageQueue mReadyQueue{ READY_QUEUE_CAPACITY_ALLOCATIONS };
+  std::unique_ptr<SuperpageQueue> mReadyQueue;
 
   // These variables are configuration parameters