DebugStreamer.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
 
#ifndef ALICEO2_TPC_DEBUGSTREAMER_H_
#define ALICEO2_TPC_DEBUGSTREAMER_H_
 
#include "GPUCommonDef.h"
#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
#include "CommonUtils/ConfigurableParamHelper.h"
#include <boost/property_tree/ptree.hpp>
#if defined(DEBUG_STREAMER)
#include "CommonUtils/TreeStreamRedirector.h"
#include <tbb/concurrent_unordered_map.h>
#endif
#endif
 
namespace o2::utils
{
 
enum StreamFlags {
  streamdEdx = 1 << 0,                  
  streamDigitFolding = 1 << 1,          
  streamDigits = 1 << 2,                
  streamFastTransform = 1 << 3,         
  streamITCorr = 1 << 4,                
  streamDistortionsSC = 1 << 5,         
  streamUpdateTrack = 1 << 6,           
  streamRejectCluster = 1 << 7,         
  streamMergeBorderTracksBest = 1 << 8, 
  streamMergeBorderTracksAll = 1 << 9,  
  streamFlagsCount = 10                 
};
 
enum SamplingTypes {
  sampleAll = 0,      
  sampleRandom = 1,   
  sampleID = 2,       
  sampleIDGlobal = 3, 
  sampleWeights = 4,  
  sampleTsallis = 5,  
};
 
#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
 
inline StreamFlags operator|(StreamFlags a, StreamFlags b)
{
  return static_cast<StreamFlags>(static_cast<int>(a) | static_cast<int>(b));
}
inline StreamFlags operator&(StreamFlags a, StreamFlags b) { return static_cast<StreamFlags>(static_cast<int>(a) & static_cast<int>(b)); }
inline StreamFlags operator~(StreamFlags a) { return static_cast<StreamFlags>(~static_cast<int>(a)); }
 
struct ParameterDebugStreamer : public o2::conf::ConfigurableParamHelper<ParameterDebugStreamer> {
  int streamLevel{};                                                                              
  SamplingTypes samplingType[StreamFlags::streamFlagsCount]{};                                    
  float samplingFrequency[StreamFlags::streamFlagsCount]{0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1}; 
  int sampleIDGlobal[StreamFlags::streamFlagsCount]{};                                            
  O2ParamDef(ParameterDebugStreamer, "DebugStreamerParam");
};
 
#endif
 
class DebugStreamer
{
 
// CPU implementation of the class
#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE) && defined(DEBUG_STREAMER)
 public:
  DebugStreamer();
 
  static DebugStreamer* instance()
  {
    static DebugStreamer streamer;
    return &streamer;
  }
 
  void setStreamer(const char* outFile, const char* option, const size_t id = getCPUID());
 
  bool isStreamerSet(const size_t id = getCPUID()) const { return getStreamerPtr(id); }
 
  void flush(const size_t id);
 
  void flush();
 
  o2::utils::TreeStreamRedirector& getStreamer(const size_t id = getCPUID()) { return *(mTreeStreamer[id]); }
 
  o2::utils::TreeStreamRedirector& getStreamer(const char* outFile, const char* option, const size_t id = getCPUID());
 
  o2::utils::TreeStreamRedirector* getStreamerPtr(const size_t id = getCPUID()) const;
 
  static StreamFlags getStreamFlags() { return static_cast<StreamFlags>(ParameterDebugStreamer::Instance().streamLevel); }
 
  static std::pair<SamplingTypes, float> getSamplingTypeFrequency(const StreamFlags streamFlag);
 
  static float getSamplingFrequency(const StreamFlags streamFlag) { return getSamplingTypeFrequency(streamFlag).second; }
 
  static size_t getCPUID();
 
  int getNTrees(const size_t id = getCPUID()) const;
 
  std::string getUniqueTreeName(const char* tree, const size_t id = getCPUID()) const;
 
  static void setStreamFlags(const StreamFlags streamFlags) { o2::conf::ConfigurableParam::setValue<int>("DebugStreamerParam", "streamLevel", static_cast<int>(streamFlags)); }
 
  static void enableStream(const StreamFlags streamFlag);
 
  static void disableStream(const StreamFlags streamFlag);
 
  static bool checkStream(const StreamFlags streamFlag, const size_t samplingID = -1, const float weight = 1);
 
  static void mergeTrees(const char* inpFile, const char* outFile, const char* option = "fast");
 
  static int getIndex(const StreamFlags streamFlag);
 
  static float getRandom(float min = 0, float max = 1);
 
 private:
  using StreamersPerFlag = tbb::concurrent_unordered_map<size_t, std::unique_ptr<o2::utils::TreeStreamRedirector>>;
  StreamersPerFlag mTreeStreamer; 
#else
 
  // empty implementation of the class for GPU or when the debug streamer is not build for CPU
 public:
  template <typename... Args>
  GPUd() void setStreamer(Args... args){};
 
  GPUd() static bool checkStream(const StreamFlags, const int samplingID = 0) { return false; }
 
  GPUd() static DebugStreamer* instance() { return nullptr; }
 
  class StreamerDummy
  {
   public:
    GPUd() int data() const { return 0; };
 
    template <typename Type>
    GPUd() StreamerDummy& operator<<(Type)
    {
      return *this;
    }
  };
 
  GPUd() StreamerDummy getStreamer(const int id = 0) const { return StreamerDummy{}; };
 
  template <typename... Args>
  GPUd() StreamerDummy getStreamer(Args... args) const
  {
    return StreamerDummy{};
  };
 
  template <typename Type>
  GPUd() StreamerDummy getUniqueTreeName(Type, const int id = 0) const
  {
    return StreamerDummy{};
  }
 
  GPUd() void flush() const {};
 
#endif
};
 
} // namespace o2::utils
 
#endif