Possibility to limit raw data dumps from ITS/MFT decoder

1) If argument of --raw-data-dumps is negative, the dumps will be allowed only from 1st decoded pipeline
   (as before, 1 corresponds to dumping only the links with detected errors, 2 - to whole TF).
2) New option --stop-raw-data-dumps-after-size <size_in_MB> sets max allowed total size in MB for
   dumps (of given pipeline), dumping will be disabled once this size is exceeded.

Author: shahor02

Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/RawPixelDecoder.h

@@ -95,7 +95,7 @@ class RawPixelDecoder final : public PixelReader
   bool getAlwaysParseTrigger() const { return mAlwaysParseTrigger; }
 
   void printReport(bool decstat = true, bool skipNoErr = true) const;
-  void produceRawDataDumps(int dump, const o2::framework::TimingInfo& tinfo);
+  size_t produceRawDataDumps(int dump, const o2::framework::TimingInfo& tinfo);
 
   void clearStat(bool resetRaw = false);
 

Detectors/ITSMFT/common/reconstruction/src/RawPixelDecoder.cxx

@@ -515,8 +515,9 @@ void RawPixelDecoder<Mapping>::clearStat(bool resetRaw)
 
 ///______________________________________________________________________
 template <class Mapping>
-void RawPixelDecoder<Mapping>::produceRawDataDumps(int dump, const o2::framework::TimingInfo& tinfo)
+size_t RawPixelDecoder<Mapping>::produceRawDataDumps(int dump, const o2::framework::TimingInfo& tinfo)
 {
+  size_t outSize = 0;
   bool dumpFullTF = false;
   for (auto& ru : mRUDecodeVec) {
     if (ru.linkHBFToDump.size()) {
@@ -550,6 +551,7 @@ void RawPixelDecoder<Mapping>::produceRawDataDumps(int dump, const o2::framework
               break;
             }
             ostrm.write(reinterpret_cast<const char*>(piece->data), piece->size);
+            outSize += piece->size;
             entry++;
           }
           LOG(info) << "produced " << std::filesystem::current_path().c_str() << '/' << fnm;
@@ -569,11 +571,13 @@ void RawPixelDecoder<Mapping>::produceRawDataDumps(int dump, const o2::framework
       for (size_t i = 0; i < lnk.rawData.getNPieces(); i++) {
         const auto* piece = lnk.rawData.getPiece(i);
         ostrm.write(reinterpret_cast<const char*>(piece->data), piece->size);
+        outSize += piece->size;
       }
     }
     LOG(info) << "produced " << std::filesystem::current_path().c_str() << '/' << fnm;
     break;
   }
+  return outSize;
 }
 
 ///______________________________________________________________________

Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/STFDecoderSpec.h

@@ -81,6 +81,7 @@ class STFDecoder : public Task
   bool mApplyNoiseMap = true;
   bool mUseClusterDictionary = true;
   bool mVerifyDecoder = false;
+  bool mDumpFrom1stPipeline = false;
   int mDumpOnError = 0;
   int mNThreads = 1;
   int mVerbosity = 0;
@@ -91,6 +92,8 @@ class STFDecoder : public Task
   size_t mEstNClusPatt = 0;
   size_t mEstNCalib = 0;
   size_t mEstNROF = 0;
+  size_t mMaxRawDumpsSize = 0;
+  size_t mRawDumpedSize = 0;
   std::string mInputSpec;
   std::string mSelfName;
   std::unique_ptr<RawPixelDecoder<Mapping>> mDecoder;

Detectors/ITSMFT/common/workflow/src/STFDecoderSpec.cxx

@@ -87,8 +87,16 @@ void STFDecoder<Mapping>::init(InitContext& ic)
     mDecoder->setNThreads(mNThreads);
     mUnmutExtraLanes = ic.options().get<bool>("unmute-extra-lanes");
     mVerbosity = ic.options().get<int>("decoder-verbosity");
+    auto dmpSz = ic.options().get<int>("stop-raw-data-dumps-after-size");
+    if (dmpSz > 0) {
+      mMaxRawDumpsSize = size_t(dmpSz) * 1024 * 1024;
+    }
     mDumpOnError = ic.options().get<int>("raw-data-dumps");
-    if (mDumpOnError < 0 || mDumpOnError >= int(GBTLink::RawDataDumps::DUMP_NTYPES)) {
+    if (mDumpOnError < 0) {
+      mDumpOnError = -mDumpOnError;
+      mDumpFrom1stPipeline = true;
+    }
+    if (mDumpOnError >= int(GBTLink::RawDataDumps::DUMP_NTYPES)) {
       throw std::runtime_error(fmt::format("unknown raw data dump level {} requested", mDumpOnError));
     }
     auto dumpDir = ic.options().get<std::string>("raw-data-dumps-directory");
@@ -243,8 +251,13 @@ void STFDecoder<Mapping>::run(ProcessingContext& pc)
 
   pc.outputs().snapshot(Output{orig, "PHYSTRIG", 0}, mDecoder->getExternalTriggers());
 
-  if (mDumpOnError != int(GBTLink::RawDataDumps::DUMP_NONE)) {
-    mDecoder->produceRawDataDumps(mDumpOnError, pc.services().get<o2::framework::TimingInfo>());
+  if (mDumpOnError != int(GBTLink::RawDataDumps::DUMP_NONE) &&
+      (!mDumpFrom1stPipeline || pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0)) {
+    mRawDumpedSize += mDecoder->produceRawDataDumps(mDumpOnError, pc.services().get<o2::framework::TimingInfo>());
+    if (mRawDumpedSize > mMaxRawDumpsSize && mMaxRawDumpsSize > 0) {
+      LOGP(info, "Max total dumped size {} MB exceeded allowed limit, disabling further dumping", mRawDumpedSize / (1024 * 1024));
+      mDumpOnError = int(GBTLink::RawDataDumps::DUMP_NONE);
+    }
   }
 
   if (mDoClusters) {
@@ -417,8 +430,9 @@ DataProcessorSpec getSTFDecoderSpec(const STFDecoderInp& inp)
       {"nthreads", VariantType::Int, 1, {"Number of decoding/clustering threads"}},
       {"decoder-verbosity", VariantType::Int, 0, {"Verbosity level (-1: silent, 0: errors, 1: headers, 2: data, 3: raw data dump) of 1st lane"}},
       {"always-parse-trigger", VariantType::Bool, false, {"parse trigger word even if flags continuation of old trigger"}},
-      {"raw-data-dumps", VariantType::Int, int(GBTLink::RawDataDumps::DUMP_NONE), {"Raw data dumps on error (0: none, 1: HBF for link, 2: whole TF for all links"}},
+      {"raw-data-dumps", VariantType::Int, int(GBTLink::RawDataDumps::DUMP_NONE), {"Raw data dumps on error (0: none, 1: HBF for link, 2: whole TF for all links. If negative, dump only on from 1st pipeline."}},
       {"raw-data-dumps-directory", VariantType::String, "", {"Destination directory for the raw data dumps"}},
+      {"stop-raw-data-dumps-after-size", VariantType::Int, 1024, {"Stop dumping once this size in MB is accumulated. 0: no limit"}},
       {"unmute-extra-lanes", VariantType::Bool, false, {"allow extra lanes to be as verbose as 1st one"}},
       {"allow-empty-rofs", VariantType::Bool, false, {"record ROFs w/o any hit"}},
       {"ignore-noise-map", VariantType::Bool, false, {"do not mask pixels flagged in the noise map"}},