CMS 3D CMS Logo

JobReport.cc
Go to the documentation of this file.
1 
2 // -*- C++ -*-
3 //
4 //
5 // 10/23/07 mf In an attempt to get clues about (or ene) the
6 // does-not-output-branches behavior, changed the
7 // generic os<< lines in JobReport::JobReportImpl::writeOutputFile
8 // to direct use of LogInfo.
9 //
10 // 4/8/08 mf Encase the logdesc for in <CDATA> ... </CDATA>
11 //
12 // 6/19/08 mf reportMessageInfo()
13 //
14 // 24 June 2008 ewv Correct format for CDATA and for second instance of reportError
15 
16 //
17 // Original Author: Marc Paterno
18 //
19 
23 
24 // The part of tinyxml used in JobReport was reviewed and
25 // determined to be threadsafe.
26 #include "tinyxml2.h"
27 #include <fstream>
28 #include <iomanip>
29 #include <ostream>
30 #include <sstream>
31 
32 namespace edm {
33  /*
34  * Note that output formatting is spattered across these classes
35  * If something outside these classes requires access to the
36  * same formatting then we need to refactor it into a common library
37  */
38 
39  template <typename S, typename T>
40  S& formatFile(T const& f, S& os) {
41  tinyxml2::XMLDocument doc;
42  if (f.fileHasBeenClosed) {
43  os << "\n<State Value=\"closed\"/>";
44  } else {
45  os << "\n<State Value=\"open\"/>";
46  }
47  os << "\n<LFN>" << doc.NewText(f.logicalFileName.c_str())->Value() << "</LFN>";
48  os << "\n<PFN>" << doc.NewText(f.physicalFileName.c_str())->Value() << "</PFN>";
49  os << "\n<Catalog>" << doc.NewText(f.catalog.c_str())->Value() << "</Catalog>";
50  os << "\n<ModuleLabel>" << doc.NewText(f.moduleLabel.c_str())->Value() << "</ModuleLabel>";
51  os << "\n<GUID>" << f.guid << "</GUID>";
52  os << "\n<Branches>";
53  for (auto const& branch : f.branchNames) {
54  os << "\n <Branch>" << doc.NewText(branch.c_str())->Value() << "</Branch>";
55  doc.DeleteChildren();
56  }
57  os << "\n</Branches>";
58  return os;
59  }
60  /*
61  * Note that output formatting is spattered across these classes
62  * If something outside these classes requires access to the
63  * same formatting then we need to refactor it into a common library
64  */
65  template <typename S>
66  S& print(S& os, JobReport::InputFile const& f) {
67  tinyxml2::XMLDocument doc;
68  os << "\n<InputFile>";
69  formatFile(f, os);
70  os << "\n<InputType>" << f.inputType << "</InputType>";
71  os << "\n<InputSourceClass>" << doc.NewText(f.inputSourceClassName.c_str())->Value() << "</InputSourceClass>";
72  os << "\n<EventsRead>" << f.numEventsRead << "</EventsRead>";
73  return os;
74  }
75 
76  template <typename S>
77  S& print(S& os, JobReport::OutputFile const& f) {
78  tinyxml2::XMLDocument doc;
79  formatFile(f, os);
80  os << "\n<OutputModuleClass>" << doc.NewText(f.outputModuleClassName.c_str())->Value() << "</OutputModuleClass>";
81  os << "\n<TotalEvents>" << f.numEventsWritten << "</TotalEvents>\n";
82  os << "\n<DataType>" << doc.NewText(f.dataType.c_str())->Value() << "</DataType>\n";
83  os << "\n<BranchHash>" << doc.NewText(f.branchHash.c_str())->Value() << "</BranchHash>\n";
84  return os;
85  }
86 
87  template <typename S>
88  S& print(S& os, JobReport::RunReport const& rep) {
89  os << "\n<Run ID=\"" << rep.runNumber << "\">\n";
90 
91  for (auto const& il : rep.lumiSectionsToNEvents) {
92  if (std::numeric_limits<unsigned long>::max() == il.second) {
93  os << " <LumiSection ID=\"" << il.first << "\"/>\n";
94 
95  } else {
96  os << " <LumiSection ID=\"" << il.first << "\" NEvents=\"" << il.second << "\"/>\n";
97  }
98  }
99  os << "</Run>\n";
100  return os;
101  }
102 
103  std::ostream& operator<<(std::ostream& os, JobReport::InputFile const& f) { return print(os, f); }
104  std::ostream& operator<<(std::ostream& os, JobReport::OutputFile const& f) { return print(os, f); }
105  std::ostream& operator<<(std::ostream& os, JobReport::RunReport const& f) { return print(os, f); }
106 
108  InputFile* inputFile = nullptr;
109  if (inputType == InputType::SecondarySource) {
110  if (t >= inputFilesSecSource_.size()) {
111  throw edm::Exception(edm::errors::LogicError) << "Access reported for secondary source input file with token "
112  << t << " but no matching input file is found\n";
113  }
114  inputFile = &inputFilesSecSource_[t];
115  } else {
116  if (t >= inputFiles_.size()) {
118  << "Access reported for input file with token " << t << " but no matching input file is found\n";
119  }
120  inputFile = &inputFiles_[t];
121  }
122  if (inputFile->fileHasBeenClosed) {
124  << "Access reported for input file with token " << t << " after this file has been closed.\n"
125  << "File record follows:\n"
126  << *inputFile << '\n';
127  }
128  return *inputFile;
129  }
130 
132  if (t >= outputFiles_.size()) {
134  << "Access reported for output file with token " << t << " but no matching output file is found\n";
135  }
136  if (outputFiles_[t].fileHasBeenClosed) {
138  << "Access reported for output file with token " << t << " after this file has been closed.\n"
139  << "File record follows:\n"
140  << outputFiles_[t] << '\n';
141  }
142  return outputFiles_[t];
143  }
144 
145  /*
146  * Add the input file token provided to every output
147  * file currently available.
148  * Used whenever a new input file is opened, it's token
149  * is added to all open output files as a contributor
150  */
152  for (auto& outputFile : outputFiles_) {
153  if (!outputFile.fileHasBeenClosed) {
154  if (inputType == InputType::SecondarySource) {
155  outputFile.contributingInputsSecSource.push_back(t);
156  } else {
157  outputFile.contributingInputs.push_back(t);
158  }
159  }
160  }
161  }
162 
163  /*
164  * Write anJobReport::InputFile object to the Logger
165  * Generate XML string forJobReport::InputFile instance and dispatch to
166  * job report via MessageLogger
167  */
169  if (ost_) {
170  *ost_ << f;
171  *ost_ << "\n<Runs>";
172  for (auto const& runReport : f.runReports) {
173  *ost_ << runReport.second;
174  }
175  *ost_ << "\n</Runs>\n";
176  *ost_ << "</InputFile>\n";
177  *ost_ << std::flush;
178  }
179  }
180 
181  /*
182  * Write an OutputFile object to the Logger
183  * Generate an XML string for the OutputFile provided and
184  * dispatch it to the logger
185  * Contributing input tokens are resolved to the input LFN and PFN
186  *
187  * TODO: We have not yet addressed the issue where we cleanup not
188  * contributing input files.
189  * Also, it is possible to get fake input to output file mappings
190  * if an input file is open already when a new output file is opened
191  * but the input gets closed without contributing events to the
192  * output file due to filtering etc.
193  *
194  */
196  tinyxml2::XMLDocument doc;
197  if (ost_) {
198  *ost_ << "\n<File>";
199  *ost_ << f;
200 
201  *ost_ << "\n<Runs>";
202  for (auto const& runReport : f.runReports) {
203  *ost_ << runReport.second;
204  }
205  *ost_ << "\n</Runs>\n";
206 
207  *ost_ << "\n<Inputs>";
208  for (auto token : f.contributingInputs) {
209  JobReport::InputFile inpFile = inputFiles_.at(token);
210  *ost_ << "\n<Input>";
211  *ost_ << "\n <LFN>" << doc.NewText(inpFile.logicalFileName.c_str())->Value() << "</LFN>";
212  *ost_ << "\n <PFN>" << doc.NewText(inpFile.physicalFileName.c_str())->Value() << "</PFN>";
213  *ost_ << "\n <FastCopying>" << findOrDefault(f.fastCopyingInputs, inpFile.physicalFileName)
214  << "</FastCopying>";
215  *ost_ << "\n</Input>";
216  doc.DeleteChildren();
217  }
218  for (auto token : f.contributingInputsSecSource) {
220  *ost_ << "\n<Input>";
221  *ost_ << "\n <LFN>" << doc.NewText(inpFile.logicalFileName.c_str())->Value() << "</LFN>";
222  *ost_ << "\n <PFN>" << doc.NewText(inpFile.physicalFileName.c_str())->Value() << "</PFN>";
223  *ost_ << "\n <FastCopying>" << findOrDefault(f.fastCopyingInputs, inpFile.physicalFileName)
224  << "</FastCopying>";
225  *ost_ << "\n</Input>";
226  doc.DeleteChildren();
227  }
228  *ost_ << "\n</Inputs>";
229  *ost_ << "\n</File>\n";
230  }
231  }
232 
233  /*
234  * Flush all open files to logger in event of a problem.
235  * Called from JobReport dtor to flush any remaining open files
236  */
238  for (auto const& inputFile : inputFiles_) {
239  if (!(inputFile.fileHasBeenClosed)) {
241  }
242  }
243  for (auto const& inputFile : inputFilesSecSource_) {
244  if (!(inputFile.fileHasBeenClosed)) {
246  }
247  }
248  for (auto const& outputFile : outputFiles_) {
249  if (!(outputFile.fileHasBeenClosed)) {
251  }
252  }
253  }
254 
256  auto& theMap = outputFiles_.at(token).runReports;
257  std::map<RunNumber, RunReport>::iterator iter(theMap.lower_bound(runNumber));
258  if (iter == theMap.end() || runNumber < iter->first) { // not found
259  theMap.emplace_hint(iter, runNumber, JobReport::RunReport{runNumber, {}}); // insert it
260  }
261  }
262 
264  for (auto& inputFile : inputFiles_) {
265  if (!inputFile.fileHasBeenClosed) {
266  std::map<RunNumber, RunReport>& theMap = inputFile.runReports;
267  std::map<RunNumber, RunReport>::iterator iter(theMap.lower_bound(runNumber));
268  if (iter == theMap.end() || runNumber < iter->first) { // not found
269  theMap.emplace_hint(iter, runNumber, JobReport::RunReport{runNumber, {}}); // insert it
270  }
271  }
272  }
273  }
274 
276  unsigned int runNumber,
277  unsigned int lumiSect,
278  unsigned long nEvents) {
279  auto& theMap = outputFiles_.at(token).runReports;
280  std::map<RunNumber, RunReport>::iterator iter(theMap.lower_bound(runNumber));
281  if (iter == theMap.end() || runNumber < iter->first) { // not found
282  theMap.emplace_hint(iter, runNumber, JobReport::RunReport{runNumber, {{{lumiSect, nEvents}}}}); // insert it
283  } else {
284  iter->second.lumiSectionsToNEvents[lumiSect] += nEvents;
285  }
286  }
287 
288  void JobReport::JobReportImpl::associateInputLumiSection(unsigned int runNumber, unsigned int lumiSect) {
289  for (auto& inputFile : inputFiles_) {
290  if (!inputFile.fileHasBeenClosed) {
291  std::map<RunNumber, RunReport>& theMap = inputFile.runReports;
292  std::map<RunNumber, RunReport>::iterator iter(theMap.lower_bound(runNumber));
293  if (iter == theMap.end() || runNumber < iter->first) { // not found
294  theMap.emplace_hint(
295  iter,
296  runNumber,
298  } else {
299  iter->second.lumiSectionsToNEvents[lumiSect] = std::numeric_limits<unsigned long>::max();
300  }
301  }
302  }
303  }
304 
306  impl_->flushFiles();
307  if (impl_->ost_) {
308  *(impl_->ost_) << "</FrameworkJobReport>\n" << std::flush;
309  }
310  }
311 
313 
314  JobReport::JobReport(std::ostream* iOstream) : impl_(new JobReportImpl(iOstream)) {
315  if (impl_->ost_) {
316  *(impl_->ost_) << "<FrameworkJobReport>\n";
317  }
318  }
319 
321  std::string const& logicalFileName,
322  std::string const& catalog,
323  std::string const& inputType,
324  std::string const& inputSourceClassName,
325  std::string const& moduleLabel,
326  std::string const& guid,
327  std::vector<std::string> const& branchNames) {
328  InputType theInputType = InputType::Primary;
329  InputFile* newFile = nullptr;
330  JobReport::Token newToken = 0;
331 
332  if (inputType == "mixingFiles") {
333  theInputType = InputType::SecondarySource;
334  auto itr = impl_->inputFilesSecSource_.push_back(InputFile());
335  newFile = &(*itr);
336  newToken = itr - impl_->inputFilesSecSource_.begin();
337  } else {
338  if (inputType == "secondaryFiles") {
339  theInputType = InputType::SecondaryFile;
340  }
341  impl_->inputFiles_.emplace_back();
342  newFile = &impl_->inputFiles_.back();
343  newToken = impl_->inputFiles_.size() - 1;
344  }
345 
346  if (theInputType == InputType::Primary) {
347  impl_->lastOpenedPrimaryInputFile_ = impl_->inputFiles_.size() - 1;
348  }
349  newFile->logicalFileName = logicalFileName;
350  newFile->physicalFileName = physicalFileName;
351  newFile->catalog = catalog;
352  newFile->inputType = inputType;
353  newFile->inputSourceClassName = inputSourceClassName;
354  newFile->moduleLabel = moduleLabel;
355  newFile->guid = guid;
356  newFile->numEventsRead = 0;
357  newFile->branchNames = branchNames;
358  newFile->fileHasBeenClosed = false;
359 
360  // Add the new input file token to all output files
361  // currently open.
362  impl_->insertInputForOutputs(theInputType, newToken);
363  return newToken;
364  }
365 
367  JobReport::InputFile& f = impl_->getInputFileForToken(inputType, fileToken);
368  ++f.numEventsRead;
369  }
370 
372  JobReport::OutputFile& f = impl_->getOutputFileForToken(fileToken);
373  f.dataType = dataType;
374  }
375 
377  JobReport::InputFile& f = impl_->getInputFileForToken(inputType, fileToken);
378  f.fileHasBeenClosed = true;
379  if (inputType == InputType::Primary) {
380  impl_->writeInputFile(f);
381  } else {
382  {
383  std::lock_guard<std::mutex> lock(write_mutex);
384  impl_->writeInputFile(f);
385  }
386  }
387  }
388 
390  std::string const& logicalFileName,
391  std::string const& catalog,
392  std::string const& outputModuleClassName,
393  std::string const& moduleLabel,
394  std::string const& guid,
395  std::string const& dataType,
396  std::string const& branchHash,
397  std::vector<std::string> const& branchNames) {
398  auto itr = impl_->outputFiles_.emplace_back();
399  JobReport::OutputFile& r = *itr;
400 
401  r.logicalFileName = logicalFileName;
402  r.physicalFileName = physicalFileName;
403  r.catalog = catalog;
404  r.outputModuleClassName = outputModuleClassName;
406  r.guid = guid;
407  r.dataType = dataType;
408  r.branchHash = branchHash;
409  r.numEventsWritten = 0;
410  r.branchNames = branchNames;
411  r.fileHasBeenClosed = false;
412  //
413  // Init list of contributors to list of open input file Tokens
414  //
415  for (std::vector<Token>::size_type i = 0, iEnd = impl_->inputFiles_.size(); i < iEnd; ++i) {
416  if (!impl_->inputFiles_[i].fileHasBeenClosed) {
417  r.contributingInputs.push_back(i);
418  }
419  }
420  for (tbb::concurrent_vector<Token>::size_type i = 0, iEnd = impl_->inputFilesSecSource_.size(); i < iEnd; ++i) {
421  if (!impl_->inputFilesSecSource_[i].fileHasBeenClosed) {
422  r.contributingInputsSecSource.push_back(i);
423  }
424  }
425  return itr - impl_->outputFiles_.begin();
426  }
427 
429  JobReport::OutputFile& f = impl_->getOutputFileForToken(fileToken);
430  ++f.numEventsWritten;
431  }
432 
434  JobReport::OutputFile& f = impl_->getOutputFileForToken(fileToken);
435  f.fileHasBeenClosed = true;
436  impl_->writeOutputFile(f);
437  }
438 
440  if (impl_->ost_) {
441  std::ostream& msg = *(impl_->ost_);
442  {
443  std::lock_guard<std::mutex> lock(write_mutex);
444  msg << "<SkippedEvent Run=\"" << run << "\"";
445  msg << " Event=\"" << event << "\" />\n";
446  msg << std::flush;
447  }
448  }
449  }
450 
452  std::string const& inputFileName,
453  bool fastCopying) {
454  JobReport::OutputFile& f = impl_->getOutputFileForToken(fileToken);
455  f.fastCopyingInputs.insert(std::make_pair(inputFileName, fastCopying));
456  }
457 
459  unsigned int run,
460  unsigned int lumiSectId,
461  unsigned long nEvents) {
462  impl_->associateLumiSection(token, run, lumiSectId, nEvents);
463  }
464 
465  void JobReport::reportInputLumiSection(unsigned int run, unsigned int lumiSectId) {
466  impl_->associateInputLumiSection(run, lumiSectId);
467  }
468 
469  void JobReport::reportRunNumber(JobReport::Token token, unsigned int run) { impl_->associateRun(token, run); }
470 
471  void JobReport::reportInputRunNumber(unsigned int run) { impl_->associateInputRun(run); }
472 
473  void JobReport::reportAnalysisFile(std::string const& fileName, std::map<std::string, std::string> const& fileData) {
474  tinyxml2::XMLDocument doc;
475  if (impl_->ost_) {
476  std::ostream& msg = *(impl_->ost_);
477  {
478  std::lock_guard<std::mutex> lock(write_mutex);
479  msg << "<AnalysisFile>\n"
480  << " <FileName>" << doc.NewText(fileName.c_str())->Value() << "</FileName>\n";
481 
482  typedef std::map<std::string, std::string>::const_iterator const_iterator;
483  for (const_iterator pos = fileData.begin(), posEnd = fileData.end(); pos != posEnd; ++pos) {
484  msg << " <" << pos->first << " Value=\"" << pos->second << "\" />"
485  << "\n";
486  }
487  msg << "</AnalysisFile>\n";
488  msg << std::flush;
489  }
490  }
491  }
492 
493  void JobReport::reportError(std::string const& shortDesc, std::string const& longDesc, int const& exitCode) {
494  if (impl_->ost_) {
495  {
496  std::lock_guard<std::mutex> lock(write_mutex);
497  std::ostream& msg = *(impl_->ost_);
498  msg << "<FrameworkError ExitStatus=\"" << exitCode << "\" Type=\"" << shortDesc << "\" >\n";
499  msg << "<![CDATA[\n" << longDesc << "\n]]>\n";
500  msg << "</FrameworkError>\n";
501  msg << std::flush;
502  }
503  }
504  }
505 
506  void JobReport::reportSkippedFile(std::string const& pfn, std::string const& lfn) {
507  if (impl_->ost_) {
508  std::ostream& msg = *(impl_->ost_);
509  tinyxml2::XMLDocument doc;
510  tinyxml2::XMLPrinter printer;
511  tinyxml2::XMLElement* skipped = doc.NewElement("SkippedFile");
512  skipped->SetAttribute("Pfn", pfn.c_str());
513  skipped->SetAttribute("Lfn", lfn.c_str());
514  {
515  std::lock_guard<std::mutex> lock(write_mutex);
516  skipped->Accept(&printer);
517  msg << printer.CStr();
518  msg << std::flush;
519  }
520  }
521  }
522 
524  if (impl_->ost_) {
525  std::ostream& msg = *(impl_->ost_);
526  tinyxml2::XMLDocument doc;
527  tinyxml2::XMLPrinter printer;
528  tinyxml2::XMLElement* fallback = doc.NewElement("FallbackAttempt");
529  fallback->SetAttribute("Pfn", pfn.c_str());
530  fallback->SetAttribute("Lfn", lfn.c_str());
531  {
532  std::lock_guard<std::mutex> lock(write_mutex);
533  fallback->Accept(&printer);
534  msg << printer.CStr();
535  msg << "<![CDATA[\n" << err << "\n]]>\n";
536  msg << std::flush;
537  }
538  }
539  }
540 
541  void JobReport::reportMemoryInfo(std::vector<std::string> const& memoryData) {
542  if (impl_->ost_) {
543  std::ostream& msg = *(impl_->ost_);
544  msg << "<MemoryService>\n";
545 
546  typedef std::vector<std::string>::const_iterator const_iterator;
547  for (const_iterator pos = memoryData.begin(), posEnd = memoryData.end(); pos != posEnd; ++pos) {
548  msg << *pos << "\n";
549  }
550  msg << "</MemoryService>\n";
551  msg << std::flush;
552  }
553  }
554 
555  void JobReport::reportMessageInfo(std::map<std::string, double> const& messageData) {
556  if (impl_->ost_) {
557  std::ostream& msg = *(impl_->ost_);
558  msg << "<MessageSummary>\n";
559  typedef std::map<std::string, double>::const_iterator const_iterator;
560  for (const_iterator pos = messageData.begin(), posEnd = messageData.end(); pos != posEnd; ++pos) {
561  msg << " <" << pos->first << " Value=\"" << pos->second << "\" />"
562  << "\n";
563  }
564  msg << "</MessageSummary>\n";
565  msg << std::flush;
566  }
567  }
568 
570  if (impl_->printedReadBranches_)
571  return;
572  impl_->printedReadBranches_ = true;
573  if (impl_->ost_) {
574  std::ostream& ost = *(impl_->ost_);
575  ost << "<ReadBranches>\n";
576  tinyxml2::XMLDocument doc;
577  tinyxml2::XMLPrinter printer;
578  for (auto const& iBranch : impl_->readBranches_) {
579  tinyxml2::XMLElement* branch = doc.NewElement("Branch");
580  branch->SetAttribute("Name", iBranch.first.c_str());
581  branch->SetAttribute("ReadCount", int64_t(iBranch.second));
582  branch->Accept(&printer);
583  ost << printer.CStr();
584  printer.ClearBuffer();
585  }
586  for (auto const& iBranch : impl_->readBranchesSecFile_) {
587  tinyxml2::XMLElement* branch = doc.NewElement("Branch");
588  branch->SetAttribute("Name", iBranch.first.c_str());
589  branch->SetAttribute("ReadCount", int64_t(iBranch.second));
590  branch->Accept(&printer);
591  ost << printer.CStr();
592  printer.ClearBuffer();
593  }
594  ost << "</ReadBranches>\n";
595  if (!impl_->readBranchesSecSource_.empty()) {
596  ost << "<SecondarySourceReadBranches>\n";
597  for (auto const& iBranch : impl_->readBranchesSecSource_) {
598  tinyxml2::XMLElement* branch = doc.NewElement("Branch");
599  branch->SetAttribute("Name", iBranch.first.c_str());
600  branch->SetAttribute("ReadCount", int64_t(iBranch.second.value().load()));
601  branch->Accept(&printer);
602  ost << printer.CStr();
603  printer.ClearBuffer();
604  }
605  ost << "</SecondarySourceReadBranches>\n";
606  }
607  ost << std::flush;
608  }
609  }
610 
612  if (inputType == InputType::Primary) {
613  // Fast cloned branches have already been reported.
614  std::set<std::string> const& clonedBranches =
615  impl_->inputFiles_.at(impl_->lastOpenedPrimaryInputFile_).fastClonedBranches;
616  if (clonedBranches.find(branchName) == clonedBranches.end()) {
617  ++impl_->readBranches_[branchName];
618  }
619  } else if (inputType == InputType::SecondaryFile) {
620  ++impl_->readBranchesSecFile_[branchName];
621  } else if (inputType == InputType::SecondarySource) {
622  ++impl_->readBranchesSecSource_[branchName].value();
623  }
624  }
625 
626  void JobReport::reportFastClonedBranches(std::set<std::string> const& fastClonedBranches, long long nEvents) {
627  std::set<std::string>& clonedBranches =
628  impl_->inputFiles_.at(impl_->lastOpenedPrimaryInputFile_).fastClonedBranches;
629  for (std::set<std::string>::const_iterator it = fastClonedBranches.begin(), itEnd = fastClonedBranches.end();
630  it != itEnd;
631  ++it) {
632  if (clonedBranches.insert(*it).second) {
633  impl_->readBranches_[*it] += nEvents;
634  }
635  }
636  }
637 
639  tinyxml2::XMLDocument doc;
640  if (impl_->ost_) {
641  std::ostream& msg = *(impl_->ost_);
642  {
643  std::lock_guard<std::mutex> lock(write_mutex);
644  msg << "<RandomServiceStateFile>\n"
645  << doc.NewText(name.c_str())->Value() << "\n"
646  << "</RandomServiceStateFile>\n";
647  msg << std::flush;
648  }
649  }
650  }
651 
653  std::map<std::string, std::string> const& metrics) {
654  if (impl_->ost_) {
655  std::ostream& msg = *(impl_->ost_);
656  msg << "<PerformanceReport>\n"
657  << " <PerformanceSummary Metric=\"" << metricClass << "\">\n";
658 
659  typedef std::map<std::string, std::string>::const_iterator const_iterator;
660  for (const_iterator iter = metrics.begin(), iterEnd = metrics.end(); iter != iterEnd; ++iter) {
661  msg << " <Metric Name=\"" << iter->first << "\" "
662  << "Value=\"" << iter->second << "\"/>\n";
663  }
664 
665  msg << " </PerformanceSummary>\n"
666  << "</PerformanceReport>\n";
667  msg << std::flush;
668  //LogInfo("FwkJob") << msg.str();
669  }
670  }
671 
673  std::string const& moduleName,
674  std::map<std::string, std::string> const& metrics) {
675  if (impl_->ost_) {
676  std::ostream& msg = *(impl_->ost_);
677  msg << "<PerformanceReport>\n"
678  << " <PerformanceModule Metric=\"" << metricClass << "\" "
679  << " Module=\"" << moduleName << "\" >\n";
680 
681  typedef std::map<std::string, std::string>::const_iterator const_iterator;
682  for (const_iterator iter = metrics.begin(), iterEnd = metrics.end(); iter != iterEnd; ++iter) {
683  msg << " <Metric Name=\"" << iter->first << "\" "
684  << "Value=\"" << iter->second << "\"/>\n";
685  }
686 
687  msg << " </PerformanceModule>\n"
688  << "</PerformanceReport>\n";
689  msg << std::flush;
690  //LogInfo("FwkJob") << msg.str();
691  }
692  }
693 
695  std::ostringstream msg;
696 
697  tinyxml2::XMLDocument doc;
698  for (auto const& f : impl_->outputFiles_) {
699  msg << "\n<File>";
700  msg << f;
701 
702  msg << "\n<LumiSections>";
703  msg << "\n<Inputs>";
704  typedef std::vector<JobReport::Token>::iterator iterator;
705  for (auto const& iInput : f.contributingInputs) {
706  auto const& inpFile = impl_->inputFiles_[iInput];
707  msg << "\n<Input>";
708  msg << "\n <LFN>" << doc.NewText(inpFile.logicalFileName.c_str())->Value() << "</LFN>";
709  msg << "\n <PFN>" << doc.NewText(inpFile.physicalFileName.c_str())->Value() << "</PFN>";
710  msg << "\n <FastCopying>" << findOrDefault(f.fastCopyingInputs, inpFile.physicalFileName) << "</FastCopying>";
711  msg << "\n</Input>";
712  doc.DeleteChildren();
713  }
714  msg << "\n</Inputs>";
715  msg << "\n</File>";
716  }
717  return msg.str();
718  }
719 
720 } // namespace edm
InputType
Definition: InputType.h:5
void reportSkippedFile(std::string const &pfn, std::string const &lfn)
Definition: JobReport.cc:506
std::string inputSourceClassName
Definition: JobReport.h:129
std::string outputModuleClassName
Definition: JobReport.h:154
std::string physicalFileName
Definition: JobReport.h:152
void associateRun(JobReport::Token token, unsigned int runNumber)
Definition: JobReport.cc:255
void reportMemoryInfo(std::vector< std::string > const &memoryData)
Definition: JobReport.cc:541
void reportInputRunNumber(unsigned int run)
Definition: JobReport.cc:471
void eventReadFromFile(InputType inputType, Token fileToken)
Definition: JobReport.cc:366
std::mutex write_mutex
Definition: JobReport.h:431
void reportFallbackAttempt(std::string const &pfn, std::string const &lfn, std::string const &err)
Definition: JobReport.cc:523
std::string logicalFileName
Definition: JobReport.h:125
#define nullptr
unsigned long long EventNumber_t
std::map< std::string, bool > fastCopyingInputs
Definition: JobReport.h:163
std::string logicalFileName
Definition: JobReport.h:151
void reportFastCopyingStatus(Token t, std::string const &inputFileName, bool fastCopying)
Definition: JobReport.cc:451
void reportRunNumber(JobReport::Token token, unsigned int run)
Definition: JobReport.cc:469
void reportRandomStateFile(std::string const &name)
Definition: JobReport.cc:638
S & print(S &os, JobReport::InputFile const &f)
Definition: JobReport.cc:66
uint16_t size_type
edm::propagate_const< std::unique_ptr< JobReportImpl > > impl_
Definition: JobReport.h:430
Token inputFileOpened(std::string const &physicalFileName, std::string const &logicalFileName, std::string const &catalog, std::string const &inputType, std::string const &inputSourceClassName, std::string const &moduleLabel, std::string const &guid, std::vector< std::string > const &branchNames)
Definition: JobReport.cc:320
std::vector< InputFile > inputFiles_
Definition: JobReport.h:252
void reportPerformanceForModule(std::string const &metricClass, std::string const &moduleName, std::map< std::string, std::string > const &metrics)
Definition: JobReport.cc:672
std::vector< Token > contributingInputs
Definition: JobReport.h:161
std::string physicalFileName
Definition: JobReport.h:126
void reportSkippedEvent(RunNumber_t run, EventNumber_t event)
Definition: JobReport.cc:439
void insertInputForOutputs(InputType inputType, Token t)
Definition: JobReport.cc:151
std::string moduleName(Provenance const &provenance)
Definition: Provenance.cc:27
std::size_t numEventsRead
Definition: JobReport.h:132
void writeInputFile(InputFile const &f)
Definition: JobReport.cc:168
StringVector branchNames
Definition: JobReport.h:160
void reportInputLumiSection(unsigned int run, unsigned int lumiSectId)
Definition: JobReport.cc:465
void reportPerformanceSummary(std::string const &metricClass, std::map< std::string, std::string > const &metrics)
Definition: JobReport.cc:652
reco::JetExtendedAssociation::JetExtendedData Value
double f[11][100]
Token outputFileOpened(std::string const &physicalFileName, std::string const &logicalFileName, std::string const &catalog, std::string const &outputModuleClassName, std::string const &moduleLabel, std::string const &guid, std::string const &dataType, std::string const &branchHash, std::vector< std::string > const &branchNames)
Definition: JobReport.cc:389
edm::propagate_const< std::ostream * > ost_
Definition: JobReport.h:260
rep
Definition: cuy.py:1190
void reportError(std::string const &shortDesc, std::string const &longDesc, int const &exitCode)
Definition: JobReport.cc:493
std::size_t Token
Definition: JobReport.h:106
void associateInputRun(unsigned int runNumber)
Definition: JobReport.cc:263
S & formatFile(T const &f, S &os)
Definition: JobReport.cc:40
void reportReadBranch(InputType inputType, std::string const &branchName)
Inform the job report that a branch has been read.
Definition: JobReport.cc:611
std::size_t numEventsWritten
Definition: JobReport.h:159
void reportFastClonedBranches(std::set< std::string > const &fastClonedBranches, long long nEvents)
Inform the job report that branches have been fast Cloned.
Definition: JobReport.cc:626
Value const & findOrDefault(std::map< Key, Value > const &m, Key const &k, Value const &defaultValue)
Definition: Map.h:24
void eventWrittenToFile(Token fileToken, RunNumber_t run, EventNumber_t event)
Definition: JobReport.cc:428
tbb::concurrent_vector< InputFile > inputFilesSecSource_
Definition: JobReport.h:253
void reportMessageInfo(std::map< std::string, double > const &messageData)
Definition: JobReport.cc:555
tuple msg
Definition: mps_check.py:285
void associateLumiSection(JobReport::Token token, unsigned int runNumber, unsigned int lumiSection, unsigned long nEvents)
Definition: JobReport.cc:275
std::string dumpFiles(void)
debug/test util
Definition: JobReport.cc:694
HLT enums.
void reportAnalysisFile(std::string const &fileName, std::map< std::string, std::string > const &fileData)
Definition: JobReport.cc:473
void outputFileClosed(Token fileToken)
Definition: JobReport.cc:433
std::map< unsigned int, unsigned long > lumiSectionsToNEvents
Definition: JobReport.h:110
void writeOutputFile(OutputFile const &f)
Definition: JobReport.cc:195
unsigned int RunNumber_t
InputFile & getInputFileForToken(InputType inputType, Token t)
Definition: JobReport.cc:107
tbb::concurrent_vector< OutputFile > outputFiles_
Definition: JobReport.h:254
void reportDataType(Token fileToken, std::string const &dataType)
Definition: JobReport.cc:371
UInt_t nEvents
Definition: hcalCalib.cc:41
tbb::concurrent_vector< Token > contributingInputsSecSource
Definition: JobReport.h:162
StringVector branchNames
Definition: JobReport.h:133
std::ostream & operator<<(std::ostream &ost, const HLTGlobalStatus &hlt)
Formatted printout of trigger tbale.
long double T
void inputFileClosed(InputType inputType, Token fileToken)
Definition: JobReport.cc:376
void associateInputLumiSection(unsigned int runNumber, unsigned int lumiSection)
Definition: JobReport.cc:288
Definition: event.py:1
void reportReadBranches()
Definition: JobReport.cc:569
OutputFile & getOutputFileForToken(Token t)
Definition: JobReport.cc:131
void reportLumiSection(JobReport::Token token, unsigned int run, unsigned int lumiSectId, unsigned long nEvents=0)
Definition: JobReport.cc:458