File indexing completed on 2023-03-17 11:03:10
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018
0019
0020
0021
0022
0023 #include "FWCore/MessageService/src/ELlimitsTable.h"
0024
0025
0026
0027
0028
0029
0030
0031 namespace edm {
0032 namespace service {
0033
0034
0035
0036
0037
0038 ELlimitsTable::ELlimitsTable()
0039 : wildcardLimit(-1), wildcardInterval(-1), wildcardTimespan(-1), tableLimit(-1), limits(), counts() {
0040 #ifdef ELlimitsTableCONSTRUCTOR_TRACE
0041 std::cerr << "Constructor for ELlimitsTable\n";
0042 #endif
0043
0044 for (int k = 0; k < messagelogger::ELseverityLevel::nLevels; ++k) {
0045 severityLimits[k] = -1;
0046 severityIntervals[k] = -1;
0047 severityTimespans[k] = -1;
0048 }
0049
0050 }
0051
0052 ELlimitsTable::~ELlimitsTable() {
0053 #ifdef ELlimitsTableCONSTRUCTOR_TRACE
0054 std::cerr << "Destructor for ELlimitsTable\n";
0055 #endif
0056
0057 }
0058
0059
0060
0061
0062
0063 void ELlimitsTable::setTableLimit(int n) { tableLimit = n; }
0064
0065 bool ELlimitsTable::add(const ELextendedID& xid) {
0066 #ifdef ELlimitsTableATRACE
0067 std::cerr << "&&&--- adding to limits table: " << xid.id << '\n';
0068 #endif
0069
0070 ELmap_counts::iterator c = counts.find(xid);
0071
0072 if (c == counts.end()) {
0073
0074 #ifdef ELlimitsTableATRACE
0075 std::cerr << "&&& no such entry yet in counts \n";
0076 #endif
0077
0078
0079
0080 if (tableLimit > 0 && static_cast<int>(counts.size()) >= tableLimit) {
0081 return true;
0082 }
0083 int lim;
0084 int ivl;
0085 int ts;
0086 ELmap_limits::iterator l = limits.find(xid.id);
0087
0088 if (l != limits.end()) {
0089 lim = (*l).second.limit;
0090 ivl = (*l).second.interval;
0091 ts = (*l).second.timespan;
0092 if (lim < 0) {
0093 lim = severityLimits[xid.severity.getLevel()];
0094 if (lim < 0) {
0095 lim = wildcardLimit;
0096 }
0097 }
0098 if (ivl < 0) {
0099 ivl = severityIntervals[xid.severity.getLevel()];
0100 if (ivl < 0) {
0101 ivl = wildcardInterval;
0102 }
0103 }
0104 if (ts < 0) {
0105 ts = severityTimespans[xid.severity.getLevel()];
0106 if (ts < 0) {
0107 ts = wildcardTimespan;
0108 }
0109 limits[xid.id] = LimitAndTimespan(lim, ts);
0110 }
0111 #ifdef ELlimitsTableATRACE
0112 std::cerr << "&&& Entry found in limits: limit = " << lim << " interval = " << ivl << " timespan = " << ts
0113 << '\n';
0114 #endif
0115
0116 } else {
0117 lim = severityLimits[xid.severity.getLevel()];
0118 ivl = severityIntervals[xid.severity.getLevel()];
0119 ts = severityTimespans[xid.severity.getLevel()];
0120 #ifdef ELlimitsTableATRACE
0121 std::cerr << "&&& Limit taken from severityLimits: " << lim << '\n'
0122 << "&&& Interval taken from severityLimits: " << ivl << '\n';
0123 #endif
0124 if (lim < 0) {
0125 lim = wildcardLimit;
0126 #ifdef ELlimitsTableATRACE
0127 std::cerr << "&&& Limit reset to wildcard limit: " << lim << '\n';
0128 #endif
0129 }
0130 if (ivl < 0) {
0131 ivl = wildcardInterval;
0132 #ifdef ELlimitsTableATRACE
0133 std::cerr << "&&& Interval reset to wildcard interval: " << ivl << '\n';
0134 #endif
0135 }
0136 #ifdef ELlimitsTableATRACE
0137 std::cerr << "&&& Timespan taken from severityTimespans: " << ts << '\n';
0138 #endif
0139 if (ts < 0) {
0140 ts = wildcardTimespan;
0141 #ifdef ELlimitsTableATRACE
0142 std::cerr << "&&& timespan reset to wildcard timespan: " << ts << '\n';
0143 #endif
0144 }
0145
0146
0147 }
0148
0149
0150 if (tableLimit < 0 || static_cast<int>(counts.size()) < tableLimit)
0151 counts[xid] = CountAndLimit(lim, ts, ivl);
0152 c = counts.find(xid);
0153 }
0154
0155 return (c == counts.end()) ? true
0156 : (*c).second.add()
0157 ;
0158
0159 }
0160
0161
0162
0163
0164
0165 void ELlimitsTable::wipe() {
0166
0167
0168
0169
0170
0171 limits.erase(limits.begin(), limits.end());
0172 ELmap_counts::iterator i;
0173 for (i = counts.begin(); i != counts.end(); ++i) {
0174 (*i).second.limit = -1;
0175 (*i).second.n = (*i).second.aggregateN = 0;
0176 }
0177
0178 wildcardLimit = -1;
0179 wildcardTimespan = -1;
0180 for (int lev = 0; lev < messagelogger::ELseverityLevel::nLevels; ++lev) {
0181 severityLimits[lev] = -1;
0182 severityIntervals[lev] = -1;
0183 severityTimespans[lev] = -1;
0184 }
0185 }
0186
0187 void ELlimitsTable::zero() {
0188
0189
0190
0191 ELmap_counts::iterator i;
0192 for (i = counts.begin(); i != counts.end(); ++i)
0193 (*i).second.n = 0;
0194 }
0195
0196 void ELlimitsTable::setLimit(const std::string& id, int n) {
0197 if (id[0] == '*')
0198 wildcardLimit = n;
0199 else
0200 limits[id].limit = n;
0201 }
0202
0203 void ELlimitsTable::setLimit(const messagelogger::ELseverityLevel& sev, int n) {
0204 severityLimits[sev.getLevel()] = n;
0205 }
0206
0207 void ELlimitsTable::setInterval(const std::string& id, int interval) {
0208 if (id[0] == '*')
0209 wildcardInterval = interval;
0210 else
0211 limits[id].interval = interval;
0212 }
0213
0214 void ELlimitsTable::setInterval(const messagelogger::ELseverityLevel& sev, int interval) {
0215 severityIntervals[sev.getLevel()] = interval;
0216 }
0217
0218 void ELlimitsTable::setTimespan(const std::string& id, int n) {
0219 if (id[0] == '*')
0220 wildcardTimespan = n;
0221 else
0222 limits[id].timespan = n;
0223 }
0224
0225 void ELlimitsTable::setTimespan(const messagelogger::ELseverityLevel& sev, int n) {
0226 severityTimespans[sev.getLevel()] = n;
0227 }
0228
0229
0230
0231
0232
0233 ELlimitsTable& ELlimitsTable::operator=(const ELlimitsTable& t) {
0234 if (this == &t) {
0235 return *this;
0236 }
0237 limits = t.limits;
0238
0239 for (int lev = 0; lev < messagelogger::ELseverityLevel::nLevels; ++lev) {
0240 severityTimespans[lev] = t.severityTimespans[lev];
0241 severityTimespans[lev] = t.severityTimespans[lev];
0242 }
0243
0244 wildcardLimit = t.wildcardLimit;
0245 wildcardTimespan = t.wildcardTimespan;
0246
0247 return *this;
0248
0249 }
0250
0251
0252
0253 }
0254 }