ExceptionGenerator.cc

Go to the documentation of this file.

#include "ExceptionGenerator.h"

#include <iostream>
#include <typeinfo>
#include <map>
#include <sstream>
#include <sys/time.h>

#include "TRandom3.h"

#include "FWCore/Utilities/interface/Exception.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

#include "boost/tokenizer.hpp"

#include <cstdio>
#include <sys/types.h>
#include <csignal>

using namespace std;

namespace evf {

  ExceptionGenerator::ExceptionGenerator(const edm::ParameterSet &pset)
      : actionId_(pset.getUntrackedParameter<int>("defaultAction", -1)),
        intqualifier_(pset.getUntrackedParameter<int>("defaultQualifier", 0)),
        qualifier2_(pset.getUntrackedParameter<double>("secondQualifier", 1)),
        actionRequired_(actionId_ != -1) {
    // timing destribution from (https://twiki.cern.ch/twiki/bin/viewauth/CMS/HLTCpuTimingFAQ#2011_Most_Recent_Data)
    // /castor/cern.ch/user/d/dsperka/HLT/triggerSkim_HLTPhysics_run178479_68_188.root
    // Baseline result with CMSSW_4_2_9_HLT3_hltpatch3 and /online/collisions/2011/5e33/v2.1/HLT/V9 :
    // vocms110:/store/timing_178479/outfile-178479-col1.root

    timingHisto_ = new TH1D("timingHisto_", "Total time for all modules per event", 100, 0, 1000);
    timingHisto_->SetBinContent(1, 5016);
    timingHisto_->SetBinContent(2, 4563);
    timingHisto_->SetBinContent(3, 3298);
    timingHisto_->SetBinContent(4, 1995);
    timingHisto_->SetBinContent(5, 1708);
    timingHisto_->SetBinContent(6, 1167);
    timingHisto_->SetBinContent(7, 928);
    timingHisto_->SetBinContent(8, 785);
    timingHisto_->SetBinContent(9, 643);
    timingHisto_->SetBinContent(10, 486);
    timingHisto_->SetBinContent(11, 427);
    timingHisto_->SetBinContent(12, 335);
    timingHisto_->SetBinContent(13, 332);
    timingHisto_->SetBinContent(14, 327);
    timingHisto_->SetBinContent(15, 258);
    timingHisto_->SetBinContent(16, 257);
    timingHisto_->SetBinContent(17, 222);
    timingHisto_->SetBinContent(18, 253);
    timingHisto_->SetBinContent(19, 223);
    timingHisto_->SetBinContent(20, 177);
    timingHisto_->SetBinContent(21, 148);
    timingHisto_->SetBinContent(22, 148);
    timingHisto_->SetBinContent(23, 113);
    timingHisto_->SetBinContent(24, 83);
    timingHisto_->SetBinContent(25, 84);
    timingHisto_->SetBinContent(26, 75);
    timingHisto_->SetBinContent(27, 61);
    timingHisto_->SetBinContent(28, 66);
    timingHisto_->SetBinContent(29, 51);
    timingHisto_->SetBinContent(30, 43);
    timingHisto_->SetBinContent(31, 38);
    timingHisto_->SetBinContent(32, 27);
    timingHisto_->SetBinContent(33, 34);
    timingHisto_->SetBinContent(34, 28);
    timingHisto_->SetBinContent(35, 18);
    timingHisto_->SetBinContent(36, 26);
    timingHisto_->SetBinContent(37, 18);
    timingHisto_->SetBinContent(38, 11);
    timingHisto_->SetBinContent(39, 11);
    timingHisto_->SetBinContent(40, 12);
    timingHisto_->SetBinContent(41, 14);
    timingHisto_->SetBinContent(42, 11);
    timingHisto_->SetBinContent(43, 8);
    timingHisto_->SetBinContent(44, 4);
    timingHisto_->SetBinContent(45, 2);
    timingHisto_->SetBinContent(46, 5);
    timingHisto_->SetBinContent(47, 3);
    timingHisto_->SetBinContent(48, 4);
    timingHisto_->SetBinContent(49, 6);
    timingHisto_->SetBinContent(50, 6);
    timingHisto_->SetBinContent(51, 3);
    timingHisto_->SetBinContent(52, 5);
    timingHisto_->SetBinContent(53, 6);
    timingHisto_->SetBinContent(54, 6);
    timingHisto_->SetBinContent(55, 6);
    timingHisto_->SetBinContent(56, 4);
    timingHisto_->SetBinContent(57, 5);
    timingHisto_->SetBinContent(58, 9);
    timingHisto_->SetBinContent(59, 3);
    timingHisto_->SetBinContent(60, 3);
    timingHisto_->SetBinContent(61, 8);
    timingHisto_->SetBinContent(62, 7);
    timingHisto_->SetBinContent(63, 5);
    timingHisto_->SetBinContent(64, 7);
    timingHisto_->SetBinContent(65, 5);
    timingHisto_->SetBinContent(66, 5);
    timingHisto_->SetBinContent(67, 4);
    timingHisto_->SetBinContent(68, 2);
    timingHisto_->SetBinContent(69, 2);
    timingHisto_->SetBinContent(70, 4);
    timingHisto_->SetBinContent(71, 5);
    timingHisto_->SetBinContent(72, 4);
    timingHisto_->SetBinContent(73, 5);
    timingHisto_->SetBinContent(74, 3);
    timingHisto_->SetBinContent(75, 5);
    timingHisto_->SetBinContent(76, 3);
    timingHisto_->SetBinContent(77, 9);
    timingHisto_->SetBinContent(78, 2);
    timingHisto_->SetBinContent(79, 2);
    timingHisto_->SetBinContent(80, 5);
    timingHisto_->SetBinContent(81, 5);
    timingHisto_->SetBinContent(82, 5);
    timingHisto_->SetBinContent(83, 5);
    timingHisto_->SetBinContent(84, 4);
    timingHisto_->SetBinContent(85, 4);
    timingHisto_->SetBinContent(86, 9);
    timingHisto_->SetBinContent(87, 5);
    timingHisto_->SetBinContent(88, 4);
    timingHisto_->SetBinContent(89, 4);
    timingHisto_->SetBinContent(90, 5);
    timingHisto_->SetBinContent(91, 3);
    timingHisto_->SetBinContent(92, 3);
    timingHisto_->SetBinContent(93, 3);
    timingHisto_->SetBinContent(94, 7);
    timingHisto_->SetBinContent(95, 5);
    timingHisto_->SetBinContent(96, 6);
    timingHisto_->SetBinContent(97, 2);
    timingHisto_->SetBinContent(98, 3);
    timingHisto_->SetBinContent(99, 5);
    timingHisto_->SetBinContent(101, 147);
    timingHisto_->SetEntries(24934);
  }

  void ExceptionGenerator::beginRun(const edm::Run &r, const edm::EventSetup &iSetup) {
    gettimeofday(&tv_start_, nullptr);
  }

  void __attribute__((optimize("O0"))) ExceptionGenerator::analyze(const edm::Event &e, const edm::EventSetup &c) {
    float dummy = 0.;
    unsigned int iterations = 0;
    if (actionRequired_) {
      int *pi = nullptr;  //null-pointer used with actionId_ 8 and 12 to intentionally cause segfault
      int ind = 0;
      int step = 1;
      switch (actionId_) {
        case 0:
          ::usleep(intqualifier_ * 1000);
          break;
        case 1:
          ::sleep(0xFFFFFFF);
          break;
        case 2:
          throw cms::Exception(qualifier_) << "This exception was generated by the ExceptionGenerator";
          break;
        case 3:
          exit(-1);
          break;
        case 4:
          abort();
          break;
        case 5:
          throw qualifier_;
          break;
        case 6:
          while (true) {
            ind += step;
            if (ind > 1000000)
              step = -1;
            if (ind == 0)
              step = 1;
          }
          break;
        case 7:
          edm::LogError("TestErrorMessage") << qualifier_;
          break;
        case 8:
          *pi = 0;  //intentionally caused segfault by assigning null pointer (this produces static-checker warning)
          break;
        case 9:
          for (unsigned int j = 0; j < intqualifier_ * 1000 * 100; j++) {
            dummy += sqrt(log(float(j + 1))) / float(j * j);
          }
          break;
        case 10:
          iterations = 100 * static_cast<unsigned int>(timingHisto_->GetRandom() * intqualifier_ * 17. + 0.5);
          for (unsigned int j = 0; j < iterations; j++) {
            dummy += sqrt(log(float(j + 1))) / float(j * j);
          }
          break;
        case 11: {
          iterations = static_cast<unsigned int>(timingHisto_->GetRandom() * intqualifier_ * 12. + 0.5);
          TRandom3 random(iterations);
          const size_t dataSize = 32 * 500;  // 124kB
          std::vector<double> data(dataSize);
          random.RndmArray(dataSize, &data[0]);

          for (unsigned int j = 0; j < iterations; j++) {
            const size_t index = static_cast<size_t>(random.Rndm() * dataSize + 0.5);
            const double value = data[index];
            dummy += sqrt(log(value + 1)) / (value * value);
            if (random.Rndm() < 0.1)
              data[index] = dummy;
          }
        } break;
        case 12: {
          timeval tv_now;
          gettimeofday(&tv_now, nullptr);
          if ((unsigned)(tv_now.tv_sec - tv_start_.tv_sec) > intqualifier_)
            *pi = 0;  //intentionally caused segfault by assigning null pointer (this produces static-checker warning)
        } break;
        case 13: {
          void *vp = malloc(1024);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstringop-overflow"
          memset((char *)vp - 32 + intqualifier_, 0, 1024);
#pragma GCC diagnostic pop
          free(vp);
        } break;
        case 14: {
          float mean = 60.;  // timingHisto_->GetMean();
          float scale = intqualifier_ / mean;
          float off = intqualifier_ * (1. - qualifier2_);
          scale = scale * qualifier2_;  // scale factor (1 default)
          iterations = static_cast<unsigned int>(max(1., off + timingHisto_->GetRandom() * scale));
          //std::cout << " off " << off << " scale " << scale << " " << iterations << std::endl;
          ::usleep(iterations * 1000);
        } break;
        case 15: {
          float mean = 60.;  // timingHisto_->GetMean();
          float scale = intqualifier_ / mean;
          float off = intqualifier_ * (1. - qualifier2_);
          scale = scale * qualifier2_;  // scale factor (1 default)
          iterations = static_cast<unsigned int>(max(1., off + timingHisto_->GetRandom() * scale));
          iterations *= 100000;
          for (unsigned int j = 0; j < iterations; j++) {
            dummy += sqrt(log(float(j + 1))) / float(j * j);
          }
        } break;
        case 16: {
          throw cms::Exception("FastMonitoringService") << "Random exception!";
        } break;

        default:
          break;
      }
    }
  }

  void ExceptionGenerator::endLuminosityBlock(edm::LuminosityBlock const &lb, edm::EventSetup const &es) {}

}  // end namespace evf