on_xition_cnt++;
}
- statHistCount(&statCounter.cd.on_xition_count, on_xition_cnt);
+ statCounter.cd.on_xition_count.count(on_xition_cnt);
}
#endif
cd->count++;
for (c = CC_PUBLIC; c < CC_ENUM_END; ++c)
if (cc->isSet(c))
- statHistCount(hist, c);
+ hist->count(c);
}
void
for (c = SC_NO_STORE; c < SC_ENUM_END; ++c)
if (isSet(c))
- statHistCount(hist, c);
+ hist->count(c);
}
if (owner <= hoReply) {
if (0 != entries.count)
- statHistCount(&HttpHeaderStats[owner].hdrUCountDistr, entries.count);
+ HttpHeaderStats[owner].hdrUCountDistr.count(entries.count);
HttpHeaderStats[owner].destroyedCount++;
if (e->id < 0 || e->id >= HDR_ENUM_END) {
debugs(55, 0, "HttpHeader::clean BUG: entry[" << pos << "] is invalid (" << e->id << "). Ignored.");
} else {
- statHistCount(&HttpHeaderStats[owner].fieldTypeDistr, e->id);
+ HttpHeaderStats[owner].fieldTypeDistr.count(e->id);
/* yes, this deletion leaves us in an inconsistent state */
delete e;
}
return *this;
}
-/*
- * same as statHistCopy but will do nothing if capacities do not match; the
- * latter happens, for example, when #peers changes during reconfiguration;
- * if it happens too often we should think about more general solution..
- */
-void
-statHistSafeCopy(StatHist * Dest, const StatHist * Orig)
-{
- assert(Dest && Orig);
- assert(Dest->bins);
-
- if (Dest->capacity == Orig->capacity)
- *Dest=*Orig;
-}
-
void
-statHistCount(StatHist * H, double val)
+StatHist::count(double val)
{
- const int bin = statHistBin(H, val);
- assert(H->bins); /* make sure it got initialized */
- assert(0 <= bin && bin < H->capacity);
- H->bins[bin]++;
+ const int bin = statHistBin(this, val);
+ assert(bins); /* make sure it got initialized */
+ assert(0 <= bin && bin < capacity);
+ ++bins[bin];
}
static int
hbase_f *val_out; /* e.g., exp() for log based histogram */
double deltaPctile(const StatHist &B, double pctile) const;
double val(int bin) const; //todo: make private
- void count(double val) const;
+ void count(double val);
StatHist &operator=(const StatHist &);
StatHist() : bins(NULL), capacity(0), min(0), max(0), scale(1.0),
val_in(NULL), val_out(NULL) {};
/* StatHist */
SQUIDCEXTERN void statHistCount(StatHist * H, double val);
-SQUIDCEXTERN void statHistCopy(StatHist * Dest, const StatHist * Orig);
-SQUIDCEXTERN void statHistSafeCopy(StatHist * Dest, const StatHist * Orig);
SQUIDCEXTERN double statHistDeltaMedian(const StatHist * A, const StatHist * B);
SQUIDCEXTERN double statHistDeltaPctile(const StatHist * A, const StatHist * B, double pctile);
SQUIDCEXTERN void statHistDump(const StatHist * H, StoreEntry * sentry, StatHistBinDumper * bd);
void
clientUpdateStatHistCounters(log_type logType, int svc_time)
{
- statHistCount(&statCounter.client_http.all_svc_time, svc_time);
+ statCounter.client_http.all_svc_time.count(svc_time);
/**
* The idea here is not to be complete, but to get service times
* for only well-defined types. For example, we don't include
switch (logType) {
case LOG_TCP_REFRESH_UNMODIFIED:
- statHistCount(&statCounter.client_http.nh_svc_time, svc_time);
+ statCounter.client_http.nh_svc_time.count(svc_time);
break;
case LOG_TCP_IMS_HIT:
- statHistCount(&statCounter.client_http.nm_svc_time, svc_time);
+ statCounter.client_http.nm_svc_time.count(svc_time);
break;
case LOG_TCP_HIT:
case LOG_TCP_MEM_HIT:
case LOG_TCP_OFFLINE_HIT:
- statHistCount(&statCounter.client_http.hit_svc_time, svc_time);
+ statCounter.client_http.hit_svc_time.count(svc_time);
break;
case LOG_TCP_MISS:
case LOG_TCP_CLIENT_REFRESH_MISS:
- statHistCount(&statCounter.client_http.miss_svc_time, svc_time);
+ statCounter.client_http.miss_svc_time.count(svc_time);
break;
default:
i = &someEntry->ping;
if (clientPingHasFinished(i))
- statHistCount(&statCounter.icp.query_svc_time,
- tvSubUsec(i->start, i->stop));
+ statCounter.icp.query_svc_time.count(tvSubUsec(i->start, i->stop));
if (i->timeout)
statCounter.icp.query_timeouts++;
PROF_stop(comm_check_incoming);
getCurrentTime();
- statHistCount(&statCounter.select_fds_hist, num);
+ statCounter.select_fds_hist.count(num);
if (num == 0)
return COMM_TIMEOUT; /* no error */
PROF_stop(comm_check_incoming);
getCurrentTime();
- statHistCount(&statCounter.select_fds_hist, num);
+ statCounter.select_fds_hist.count(num);
if (num == 0)
return COMM_TIMEOUT; /* No error.. */
if (nevents > INCOMING_ICP_MAX)
nevents = INCOMING_ICP_MAX;
- statHistCount(&statCounter.comm_icp_incoming, nevents);
+ statCounter.comm_icp_incoming.count(nevents);
}
static void
if (nevents > INCOMING_HTTP_MAX)
nevents = INCOMING_HTTP_MAX;
- statHistCount(&statCounter.comm_http_incoming, nevents);
+ statCounter.comm_http_incoming.count(nevents);
}
/* poll all sockets; call handlers for those that are ready. */
getCurrentTime();
debugs(5, num ? 5 : 8, "comm_poll: " << num << "+" << npending << " FDs ready");
- statHistCount(&statCounter.select_fds_hist, num);
+ statCounter.select_fds_hist.count(num);
if (num == 0 && npending == 0)
continue;
if (nevents > INCOMING_DNS_MAX)
nevents = INCOMING_DNS_MAX;
- statHistCount(&statCounter.comm_dns_incoming, nevents);
+ statCounter.comm_dns_incoming.count(nevents);
}
if (nevents > INCOMING_ICP_MAX)
nevents = INCOMING_ICP_MAX;
- statHistCount(&statCounter.comm_icp_incoming, nevents);
+ statCounter.comm_icp_incoming.count(nevents);
}
static void
if (nevents > INCOMING_HTTP_MAX)
nevents = INCOMING_HTTP_MAX;
- statHistCount(&statCounter.comm_http_incoming, nevents);
+ statCounter.comm_http_incoming.count(nevents);
}
#define DEBUG_FDBITS 0
debugs(5, num ? 5 : 8, "comm_select: " << num << "+" << pending << " FDs ready");
- statHistCount(&statCounter.select_fds_hist, num);
+ statCounter.select_fds_hist.count(num);
if (num == 0 && pending == 0)
continue;
if (nevents > INCOMING_DNS_MAX)
nevents = INCOMING_DNS_MAX;
- statHistCount(&statCounter.comm_dns_incoming, nevents);
+ statCounter.comm_dns_incoming.count(nevents);
}
void
if (nevents > INCOMING_ICP_MAX)
nevents = INCOMING_ICP_MAX;
- statHistCount(&statCounter.comm_icp_incoming, nevents);
+ statCounter.comm_icp_incoming.count(nevents);
}
static void
if (nevents > INCOMING_HTTP_MAX)
nevents = INCOMING_HTTP_MAX;
- statHistCount(&statCounter.comm_http_incoming, nevents);
+ statCounter.comm_http_incoming.count(nevents);
}
#define DEBUG_FDBITS 0
debugs(5, num ? 5 : 8, "comm_select: " << num << "+" << pending << " FDs ready");
- statHistCount(&statCounter.select_fds_hist, num);
+ statCounter.select_fds_hist.count(num);
if (num == 0 && pending == 0)
continue;
if (nevents > INCOMING_DNS_MAX)
nevents = INCOMING_DNS_MAX;
- statHistCount(&statCounter.comm_dns_incoming, nevents);
+ statCounter.comm_dns_incoming.count(nevents);
}
void
static_cast<generic_cbdata *>(data)->unwrap(&f);
++FqdncacheStats.replies;
const int age = f->age();
- statHistCount(&statCounter.dns.svc_time, age);
+ statCounter.dns.svc_time.count(age);
#if USE_DNSSERVERS
fqdncacheParse(f, reply);
statCounter.icp.replies_sent++;
kb_incr(&statCounter.icp.r_kbytes_sent, len);
/* this is the sent-reply service time */
- statHistCount(&statCounter.icp.reply_svc_time, delay);
+ statCounter.icp.reply_svc_time.count(delay);
}
if (ICP_HIT == icp->opcode)
static_cast<generic_cbdata *>(data)->unwrap(&i);
IpcacheStats.replies++;
const int age = i->age();
- statHistCount(&statCounter.dns.svc_time, age);
+ statCounter.dns.svc_time.count(age);
#if USE_DNSSERVERS
ipcacheParse(i, reply);
}
void
-statHistCount(StatHist * H, double val)
+StatHist::count(double val)
{
fatal("statHistCount: Not implemented");
}