ELmap.cc

Go to the documentation of this file.

// ----------------------------------------------------------------------
//
// ELmap.cc
//
// Change History:
//   99-06-10   mf      correction in sense of comparison between timespan
//                      and diff (now, lastTime)
//              mf      ELcountTRACE made available
//   99-06-11   mf      Corrected logic for suppressing output when n > limit
//                      but not but a factor of 2**K
//   06-05-16   mf      Added code to establish interval and to use skipped
//          and interval when determinine in add() whehter to react
//   06-05-19   wmtan   Bug fix.  skipped = 0, not skipped == 0.
//          and interval when determinine in add() whehter to react
//   09-04-15   wmtan   Use smart pointers with new, not bare pointers
//
// ----------------------------------------------------------------------
 
#include "FWCore/MessageLogger/interface/ELmap.h"
 
// Possible traces
//#include <iostream>
//#define ELcountTRACE
// #define ELmapDumpTRACE
 
namespace edm {
 
  // ----------------------------------------------------------------------
  // LimitAndTimespan:
  // ----------------------------------------------------------------------
 
  LimitAndTimespan::LimitAndTimespan(int lim, int ts, int ivl) : limit(lim), timespan(ts), interval(ivl) {}
 
  // ----------------------------------------------------------------------
  // CountAndLimit:
  // ----------------------------------------------------------------------
 
  CountAndLimit::CountAndLimit(int lim, int ts, int ivl)
      : n(0),
        aggregateN(0),
        lastTime(time(nullptr)),
        limit(lim),
        timespan(ts),
        interval(ivl),
        skipped(ivl - 1)  // So that the FIRST of the prescaled messages emerges
  {}
 
  bool CountAndLimit::add() {
    time_t now = time(nullptr);
 
#ifdef ELcountTRACE
    std::cerr << "&&&--- CountAndLimit::add \n";
    std::cerr << "&&&    Time now  is " << now << "\n";
    std::cerr << "&&&    Last time is " << lastTime << "\n";
    std::cerr << "&&&    timespan  is " << timespan << "\n";
    std::cerr << "&&&    difftime  is " << difftime(now, lastTime) << "\n" << std::flush;
#endif
 
    // Has it been so long that we should restart counting toward the limit?
    if ((timespan >= 0) && (difftime(now, lastTime) >= timespan)) {
      n = 0;
      if (interval > 0) {
        skipped = interval - 1;  // So this message will be reacted to
      } else {
        skipped = 0;
      }
    }
 
    lastTime = now;
 
    ++n;
    ++aggregateN;
    ++skipped;
 
#ifdef ELcountTRACE
    std::cerr << "&&&       n is " << n << "-- limit is    " << limit << "\n";
    std::cerr << "&&& skipped is " << skipped << "-- interval is " << interval << "\n";
#endif
 
    if (skipped < interval)
      return false;
 
    if (limit == 0)
      return false;  // Zero limit - never react to this
    if ((limit < 0) || (n <= limit)) {
      skipped = 0;
      return true;
    }
 
    // Now we are over the limit - have we exceeded limit by 2^N * limit?
    long diff = n - limit;
    long r = diff / limit;
    if (r * limit != diff) {  // Not a multiple of limit - don't react
      return false;
    }
    if (r == 1) {  // Exactly twice limit - react
      skipped = 0;
      return true;
    }
 
    while (r > 1) {
      if ((r & 1) != 0)
        return false;  // Not 2**n times limit - don't react
      r >>= 1;
    }
    // If you never get an odd number till one, r is 2**n so react
 
    skipped = 0;
    return true;
 
  }  // add()
 
  // ----------------------------------------------------------------------
  // StatsCount:
  // ----------------------------------------------------------------------
 
  StatsCount::StatsCount() : n(0), aggregateN(0), ignoredFlag(false), context1(""), context2(""), contextLast("") {}
 
  void StatsCount::add(const ELstring& context, bool reactedTo) {
    ++n;
    ++aggregateN;
 
    ((1 == n) ? context1 : (2 == n) ? context2 : contextLast) = ELstring(context, 0, 16);
 
    if (!reactedTo)
      ignoredFlag = true;
 
  }  // add()
 
  // ----------------------------------------------------------------------
 
#ifdef ELmapDumpTRACE
  // ----------------------------------------------------------------------
  // Global Dump methods (useful for debugging)
  // ----------------------------------------------------------------------
 
#include <sstream>
#include <string.h>
 
  boost::shared_array<char> ELmapDump(ELmap_limits m) {
    std::ostringstream s;
    s << "**** ELmap_limits Dump **** \n";
 
    ELmap_limits::const_iterator i;
    for (i = m.begin(); i != m.end(); ++i) {
      LimitAndTimespan lt = (*i).second;
      s << "     " << (*i).first << ":  " << lt.limit << ", " << lt.timespan << "\n";
    }
    s << "--------------------------------------------\n";
 
    boost::shared_array<char> dump(new char[s.str().size() + 1]);
    strcpy(dump.get(), s.str().c_str());
 
    return dump;
  }
#endif
 
}  // end of namespace edm  */