CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
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) {
219  JobReport::InputFile inpFile = inputFilesSecSource_.at(token);
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)) {
240  writeInputFile(inputFile);
241  }
242  }
243  for (auto const& inputFile : inputFilesSecSource_) {
244  if (!(inputFile.fileHasBeenClosed)) {
245  writeInputFile(inputFile);
246  }
247  }
248  for (auto const& outputFile : outputFiles_) {
249  if (!(outputFile.fileHasBeenClosed)) {
250  writeOutputFile(outputFile);
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;
405  r.moduleLabel = moduleLabel;
406  r.guid = guid;
407  r.dataType = dataType;
408  r.branchHash = branchHash;
409  r.numEventsWritten = 0;
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 (oneapi::tbb::concurrent_vector<Token>::size_type i = 0, iEnd = impl_->inputFilesSecSource_.size(); i < iEnd;
421  ++i) {
422  if (!impl_->inputFilesSecSource_[i].fileHasBeenClosed) {
423  r.contributingInputsSecSource.push_back(i);
424  }
425  }
426  return itr - impl_->outputFiles_.begin();
427  }
428 
430  JobReport::OutputFile& f = impl_->getOutputFileForToken(fileToken);
431  ++f.numEventsWritten;
432  }
433 
435  JobReport::OutputFile& f = impl_->getOutputFileForToken(fileToken);
436  f.fileHasBeenClosed = true;
437  impl_->writeOutputFile(f);
438  }
439 
441  if (impl_->ost_) {
442  std::ostream& msg = *(impl_->ost_);
443  {
444  std::lock_guard<std::mutex> lock(write_mutex);
445  msg << "<SkippedEvent Run=\"" << run << "\"";
446  msg << " Event=\"" << event << "\" />\n";
447  msg << std::flush;
448  }
449  }
450  }
451 
453  std::string const& inputFileName,
454  bool fastCopying) {
455  JobReport::OutputFile& f = impl_->getOutputFileForToken(fileToken);
456  f.fastCopyingInputs.insert(std::make_pair(inputFileName, fastCopying));
457  }
458 
460  unsigned int run,
461  unsigned int lumiSectId,
462  unsigned long nEvents) {
463  impl_->associateLumiSection(token, run, lumiSectId, nEvents);
464  }
465 
466  void JobReport::reportInputLumiSection(unsigned int run, unsigned int lumiSectId) {
467  impl_->associateInputLumiSection(run, lumiSectId);
468  }
469 
470  void JobReport::reportRunNumber(JobReport::Token token, unsigned int run) { impl_->associateRun(token, run); }
471 
472  void JobReport::reportInputRunNumber(unsigned int run) { impl_->associateInputRun(run); }
473 
474  void JobReport::reportAnalysisFile(std::string const& fileName, std::map<std::string, std::string> const& fileData) {
475  tinyxml2::XMLDocument doc;
476  if (impl_->ost_) {
477  std::ostream& msg = *(impl_->ost_);
478  {
479  std::lock_guard<std::mutex> lock(write_mutex);
480  msg << "<AnalysisFile>\n"
481  << " <FileName>" << doc.NewText(fileName.c_str())->Value() << "</FileName>\n";
482 
483  typedef std::map<std::string, std::string>::const_iterator const_iterator;
484  for (const_iterator pos = fileData.begin(), posEnd = fileData.end(); pos != posEnd; ++pos) {
485  msg << " <" << pos->first << " Value=\"" << pos->second << "\" />"
486  << "\n";
487  }
488  msg << "</AnalysisFile>\n";
489  msg << std::flush;
490  }
491  }
492  }
493 
494  void JobReport::reportError(std::string const& shortDesc, std::string const& longDesc, int const& exitCode) {
495  if (impl_->ost_) {
496  {
497  std::lock_guard<std::mutex> lock(write_mutex);
498  std::ostream& msg = *(impl_->ost_);
499  msg << "<FrameworkError ExitStatus=\"" << exitCode << "\" Type=\"" << shortDesc << "\" >\n";
500  msg << "<![CDATA[\n" << longDesc << "\n]]>\n";
501  msg << "</FrameworkError>\n";
502  msg << std::flush;
503  }
504  }
505  }
506 
507  void JobReport::reportSkippedFile(std::string const& pfn, std::string const& lfn) {
508  if (impl_->ost_) {
509  std::ostream& msg = *(impl_->ost_);
510  tinyxml2::XMLDocument doc;
511  tinyxml2::XMLPrinter printer;
512  tinyxml2::XMLElement* skipped = doc.NewElement("SkippedFile");
513  skipped->SetAttribute("Pfn", pfn.c_str());
514  skipped->SetAttribute("Lfn", lfn.c_str());
515  {
516  std::lock_guard<std::mutex> lock(write_mutex);
517  skipped->Accept(&printer);
518  msg << printer.CStr();
519  msg << std::flush;
520  }
521  }
522  }
523 
525  if (impl_->ost_) {
526  std::ostream& msg = *(impl_->ost_);
527  tinyxml2::XMLDocument doc;
528  tinyxml2::XMLPrinter printer;
529  tinyxml2::XMLElement* fallback = doc.NewElement("FallbackAttempt");
530  fallback->SetAttribute("Pfn", pfn.c_str());
531  fallback->SetAttribute("Lfn", lfn.c_str());
532  {
533  std::lock_guard<std::mutex> lock(write_mutex);
534  fallback->Accept(&printer);
535  msg << printer.CStr();
536  msg << "<![CDATA[\n" << err << "\n]]>\n";
537  msg << std::flush;
538  }
539  }
540  }
541 
542  void JobReport::reportMemoryInfo(std::vector<std::string> const& memoryData) {
543  if (impl_->ost_) {
544  std::ostream& msg = *(impl_->ost_);
545  msg << "<MemoryService>\n";
546 
547  typedef std::vector<std::string>::const_iterator const_iterator;
548  for (const_iterator pos = memoryData.begin(), posEnd = memoryData.end(); pos != posEnd; ++pos) {
549  msg << *pos << "\n";
550  }
551  msg << "</MemoryService>\n";
552  msg << std::flush;
553  }
554  }
555 
556  void JobReport::reportMessageInfo(std::map<std::string, double> const& messageData) {
557  if (impl_->ost_) {
558  std::ostream& msg = *(impl_->ost_);
559  msg << "<MessageSummary>\n";
560  typedef std::map<std::string, double>::const_iterator const_iterator;
561  for (const_iterator pos = messageData.begin(), posEnd = messageData.end(); pos != posEnd; ++pos) {
562  msg << " <" << pos->first << " Value=\"" << pos->second << "\" />"
563  << "\n";
564  }
565  msg << "</MessageSummary>\n";
566  msg << std::flush;
567  }
568  }
569 
571  bool expected = false;
572  if (not impl_->printedReadBranches_.compare_exchange_strong(expected, true))
573  return;
574  if (impl_->ost_) {
575  std::ostream& ost = *(impl_->ost_);
576  ost << "<ReadBranches>\n";
577  tinyxml2::XMLDocument doc;
578  tinyxml2::XMLPrinter printer;
579  for (auto const& iBranch : impl_->readBranches_) {
580  tinyxml2::XMLElement* branch = doc.NewElement("Branch");
581  branch->SetAttribute("Name", iBranch.first.c_str());
582  branch->SetAttribute("ReadCount", int64_t(iBranch.second));
583  branch->Accept(&printer);
584  ost << printer.CStr();
585  printer.ClearBuffer();
586  }
587  for (auto const& iBranch : impl_->readBranchesSecFile_) {
588  tinyxml2::XMLElement* branch = doc.NewElement("Branch");
589  branch->SetAttribute("Name", iBranch.first.c_str());
590  branch->SetAttribute("ReadCount", int64_t(iBranch.second));
591  branch->Accept(&printer);
592  ost << printer.CStr();
593  printer.ClearBuffer();
594  }
595  ost << "</ReadBranches>\n";
596  if (!impl_->readBranchesSecSource_.empty()) {
597  ost << "<SecondarySourceReadBranches>\n";
598  for (auto const& iBranch : impl_->readBranchesSecSource_) {
599  tinyxml2::XMLElement* branch = doc.NewElement("Branch");
600  branch->SetAttribute("Name", iBranch.first.c_str());
601  branch->SetAttribute("ReadCount", int64_t(iBranch.second.value().load()));
602  branch->Accept(&printer);
603  ost << printer.CStr();
604  printer.ClearBuffer();
605  }
606  ost << "</SecondarySourceReadBranches>\n";
607  }
608  ost << std::flush;
609  }
610  }
611 
612  void JobReport::reportReadBranch(InputType inputType, std::string const& branchName) {
613  if (inputType == InputType::Primary) {
614  // Fast cloned branches have already been reported.
615  std::set<std::string> const& clonedBranches =
616  impl_->inputFiles_.at(impl_->lastOpenedPrimaryInputFile_).fastClonedBranches;
617  if (clonedBranches.find(branchName) == clonedBranches.end()) {
618  ++impl_->readBranches_[branchName];
619  }
620  } else if (inputType == InputType::SecondaryFile) {
621  ++impl_->readBranchesSecFile_[branchName];
622  } else if (inputType == InputType::SecondarySource) {
623  ++impl_->readBranchesSecSource_[branchName].value();
624  }
625  }
626 
627  void JobReport::reportFastClonedBranches(std::set<std::string> const& fastClonedBranches, long long nEvents) {
628  std::set<std::string>& clonedBranches =
629  impl_->inputFiles_.at(impl_->lastOpenedPrimaryInputFile_).fastClonedBranches;
630  for (std::set<std::string>::const_iterator it = fastClonedBranches.begin(), itEnd = fastClonedBranches.end();
631  it != itEnd;
632  ++it) {
633  if (clonedBranches.insert(*it).second) {
634  impl_->readBranches_[*it] += nEvents;
635  }
636  }
637  }
638 
640  tinyxml2::XMLDocument doc;
641  if (impl_->ost_) {
642  std::ostream& msg = *(impl_->ost_);
643  {
644  std::lock_guard<std::mutex> lock(write_mutex);
645  msg << "<RandomServiceStateFile>\n"
646  << doc.NewText(name.c_str())->Value() << "\n"
647  << "</RandomServiceStateFile>\n";
648  msg << std::flush;
649  }
650  }
651  }
652 
654  std::map<std::string, std::string> const& metrics) {
655  if (impl_->ost_) {
656  std::ostream& msg = *(impl_->ost_);
657  msg << "<PerformanceReport>\n"
658  << " <PerformanceSummary Metric=\"" << metricClass << "\">\n";
659 
660  typedef std::map<std::string, std::string>::const_iterator const_iterator;
661  for (const_iterator iter = metrics.begin(), iterEnd = metrics.end(); iter != iterEnd; ++iter) {
662  msg << " <Metric Name=\"" << iter->first << "\" "
663  << "Value=\"" << iter->second << "\"/>\n";
664  }
665 
666  msg << " </PerformanceSummary>\n"
667  << "</PerformanceReport>\n";
668  msg << std::flush;
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  }
691  }
692 
694  std::ostringstream msg;
695 
696  tinyxml2::XMLDocument doc;
697  for (auto const& f : impl_->outputFiles_) {
698  msg << "\n<File>";
699  msg << f;
700 
701  msg << "\n<LumiSections>";
702  msg << "\n<Inputs>";
703  typedef std::vector<JobReport::Token>::iterator iterator;
704  for (auto const& iInput : f.contributingInputs) {
705  auto const& inpFile = impl_->inputFiles_[iInput];
706  msg << "\n<Input>";
707  msg << "\n <LFN>" << doc.NewText(inpFile.logicalFileName.c_str())->Value() << "</LFN>";
708  msg << "\n <PFN>" << doc.NewText(inpFile.physicalFileName.c_str())->Value() << "</PFN>";
709  msg << "\n <FastCopying>" << findOrDefault(f.fastCopyingInputs, inpFile.physicalFileName) << "</FastCopying>";
710  msg << "\n</Input>";
711  doc.DeleteChildren();
712  }
713  msg << "\n</Inputs>";
714  msg << "\n</File>";
715  }
716  return msg.str();
717  }
718 
719 } // namespace edm
string rep
Definition: cuy.py:1189
InputType
Definition: InputType.h:5
void reportSkippedFile(std::string const &pfn, std::string const &lfn)
Definition: JobReport.cc:507
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:542
void reportInputRunNumber(unsigned int run)
Definition: JobReport.cc:472
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:524
std::string logicalFileName
Definition: JobReport.h:125
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:452
void reportRunNumber(JobReport::Token token, unsigned int run)
Definition: JobReport.cc:470
void reportRandomStateFile(std::string const &name)
Definition: JobReport.cc:639
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
tuple InputFile
Open Root file and provide MEs ############.
std::string physicalFileName
Definition: JobReport.h:126
void reportSkippedEvent(RunNumber_t run, EventNumber_t event)
Definition: JobReport.cc:440
void insertInputForOutputs(InputType inputType, Token t)
Definition: JobReport.cc:151
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:466
void reportPerformanceSummary(std::string const &metricClass, std::map< std::string, std::string > const &metrics)
Definition: JobReport.cc:653
reco::JetExtendedAssociation::JetExtendedData Value
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
void reportError(std::string const &shortDesc, std::string const &longDesc, int const &exitCode)
Definition: JobReport.cc:494
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:612
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:627
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:429
void reportMessageInfo(std::map< std::string, double > const &messageData)
Definition: JobReport.cc:556
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:693
std::string moduleName(StableProvenance const &provenance, ProcessHistory const &history)
Definition: Provenance.cc:27
void reportAnalysisFile(std::string const &fileName, std::map< std::string, std::string > const &fileData)
Definition: JobReport.cc:474
void outputFileClosed(Token fileToken)
Definition: JobReport.cc:434
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
void reportDataType(Token fileToken, std::string const &dataType)
Definition: JobReport.cc:371
tuple branchNames
Definition: haddnano.py:54
oneapi::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
void reportReadBranches()
Definition: JobReport.cc:570
OutputFile & getOutputFileForToken(Token t)
Definition: JobReport.cc:131
oneapi::tbb::concurrent_vector< InputFile > inputFilesSecSource_
Definition: JobReport.h:253
void reportLumiSection(JobReport::Token token, unsigned int run, unsigned int lumiSectId, unsigned long nEvents=0)
Definition: JobReport.cc:459