FastMonitor.h

Go to the documentation of this file.

/*
 * FastMonitor.h
 *
 *  Created on: Nov 27, 2012
 *      Author: aspataru
 */

#ifndef FASTMONITOR_H_
#define FASTMONITOR_H_

#include "EventFilter/Utilities/interface/JsonMonitorable.h"
#include "EventFilter/Utilities/interface/DataPointDefinition.h"
#include "EventFilter/Utilities/interface/DataPoint.h"

#include <unordered_set>

namespace jsoncollector {

  class FastMonitor {
  public:
    FastMonitor(std::string const& defPath,
                std::string const defGroup,
                bool strictChecking,
                bool useSource = true,
                bool useDefinition = true);
    FastMonitor(DataPointDefinition const* dpd, bool strictChecking, bool useSource = true, bool useDefinition = true);

    virtual ~FastMonitor();

    void addFastPathDefinition(std::string const& defPathFast, std::string const defGroupFast, bool strict);

    void setDefPath(std::string const& dpath) {
      defPath_ = dpath;
      for (auto dp : dataPoints_)
        dp->updateDefinition(dpath);
    }

    void setNStreams(unsigned int nStreams) { nStreams_ = nStreams; }

    //register global monitorable
    void registerGlobalMonitorable(JsonMonitorable* newMonitorable,
                                   bool NAifZeroUpdates,
                                   unsigned int* nBins = nullptr);

    //register fastPath global monitorable
    void registerFastGlobalMonitorable(JsonMonitorable* newMonitorable);

    //register per-stream monitores vector (unsigned int)
    void registerStreamMonitorableUIntVec(std::string const& name,
                                          std::vector<unsigned int>* inputs,
                                          bool NAifZeroUpdates,
                                          unsigned int* nBins = nullptr);

    //NOT implemented yet
    //void registerStreamMonitorableIntVec(std::string &name, std::vector<unsigned int>,true,0);
    //void registerStreamMonitorableDoubleVec(std::string &name, std::vector<unsigned int>,true,0);
    //void registerStreamMonitorableStringVec(std::string &name, std::vector<std::string>,true,0);

    void registerStreamMonitorableUIntVecAtomic(std::string const& name,
                                                std::vector<AtomicMonUInt*>* inputs,
                                                bool NAifZeroUpdates,
                                                unsigned int* nBins = nullptr);

    //take vector used to track stream lumis and finish initialization
    void commit(std::vector<unsigned int>* streamLumisPtr);

    // fetches new snapshot and outputs one-line CSV if set (timer based)
    void snap(unsigned int ls);

    //only update global variables (invoked at global EOL)
    void snapGlobal(unsigned int ls);

    //only updates atomic vectors (for certain stream - at stream EOL)
    void snapStreamAtomic(unsigned int ls, unsigned int streamID);

    //fastpath CSV string
    std::string getCSVString(int sid = -1);

    //fastpath file output
    void outputCSV(std::string const& path, std::string const& csvString);

    //provide merged variable back to user
    JsonMonitorable* getMergedIntJForLumi(std::string const& name, unsigned int forLumi);

    // merges and outputs everything collected for the given stream to JSON file
    bool outputFullJSONs(std::string const& pathstem, std::string const& ext, unsigned int lumi, bool output = true);
    bool outputFullJSON(std::string const& path, unsigned int lumi, bool output = true);

    //discard what was collected for a lumisection
    void discardCollected(unsigned int forLumi);

    //this is added to the JSON file
    void getHostAndPID(std::string& sHPid);

  private:
    std::string defPath_;
    std::string defPathFast_;
    bool strictChecking_;
    bool fastPathStrictChecking_;
    bool useSource_;
    bool useDefinition_;
    bool haveFastPath_ = false;

    unsigned int nStreams_;

    std::string sourceInfo_;
    DataPointDefinition const* dpd_;
    DataPointDefinition const* dpdFast_;
    bool deleteDef_ = false;
    bool deleteDefFast_ = false;

    std::vector<DataPoint*> dataPoints_;
    std::vector<DataPoint*> dataPointsFastOnly_;
    std::vector<unsigned int> jsonDpIndex_;
    std::vector<DataPoint*> jsonDpIndexFast_;
    std::vector<DataPoint*> orphanedDps_;
    std::map<std::string, unsigned int> dpNameMap_;

    unsigned int recentSnaps_ = 0;
    unsigned int recentSnapsTimer_ = 0;
    unsigned int regDpCount_ = 0;
    unsigned int fregDpCount_ = 0;

    std::unordered_set<std::string> uids_;
  };

}  // namespace jsoncollector

#endif /* FASTMONITOR_H_ */