#include <string.h>
#include <string>
-#define COUNT_DISABLED ((uint64_t)(int64_t)-1)
-
using std::ostringstream;
-enum perf_counters_data_any_t {
- PERF_COUNTERS_DATA_ANY_NONE,
- PERF_COUNTERS_DATA_ANY_U64,
- PERF_COUNTERS_DATA_ANY_DOUBLE
-};
-
PerfCountersCollection::
PerfCountersCollection(CephContext *cct)
: m_cct(cct),
assert(idx > m_lower_bound);
assert(idx < m_upper_bound);
perf_counter_data_any_d& data(m_data[idx - m_lower_bound - 1]);
- if (data.type != PERF_COUNTERS_DATA_ANY_U64)
+ if (!(data.type & PERFCOUNTER_U64))
return;
data.u.u64 += amt;
- if (data.count != COUNT_DISABLED)
- data.count++;
+ if (data.type & PERFCOUNTER_LONGRUNAVG)
+ data.avgcount++;
}
void PerfCounters::
assert(idx > m_lower_bound);
assert(idx < m_upper_bound);
perf_counter_data_any_d& data(m_data[idx - m_lower_bound - 1]);
- if (data.type != PERF_COUNTERS_DATA_ANY_U64)
+ if (!(data.type & PERFCOUNTER_U64))
return;
data.u.u64 = amt;
- if (data.count != COUNT_DISABLED)
- data.count++;
+ if (data.type & PERFCOUNTER_LONGRUNAVG)
+ data.avgcount++;
}
uint64_t PerfCounters::
assert(idx > m_lower_bound);
assert(idx < m_upper_bound);
const perf_counter_data_any_d& data(m_data[idx - m_lower_bound - 1]);
- if (data.type != PERF_COUNTERS_DATA_ANY_DOUBLE)
+ if (!(data.type & PERFCOUNTER_U64))
return 0;
return data.u.u64;
}
assert(idx > m_lower_bound);
assert(idx < m_upper_bound);
perf_counter_data_any_d& data(m_data[idx - m_lower_bound - 1]);
- if (data.type != PERF_COUNTERS_DATA_ANY_DOUBLE)
+ if (!(data.type & PERFCOUNTER_FLOAT))
return;
data.u.dbl += amt;
- if (data.count != COUNT_DISABLED)
- data.count++;
+ if (data.type & PERFCOUNTER_LONGRUNAVG)
+ data.avgcount++;
}
void PerfCounters::
assert(idx > m_lower_bound);
assert(idx < m_upper_bound);
perf_counter_data_any_d& data(m_data[idx - m_lower_bound - 1]);
- if (data.type != PERF_COUNTERS_DATA_ANY_DOUBLE)
+ if (!(data.type & PERFCOUNTER_FLOAT))
return;
data.u.dbl = amt;
- if (data.count != COUNT_DISABLED)
- data.count++;
+ if (data.type & PERFCOUNTER_LONGRUNAVG)
+ data.avgcount++;
}
double PerfCounters::
assert(idx > m_lower_bound);
assert(idx < m_upper_bound);
const perf_counter_data_any_d& data(m_data[idx - m_lower_bound - 1]);
- if (data.type != PERF_COUNTERS_DATA_ANY_DOUBLE)
+ if (!(data.type & PERFCOUNTER_FLOAT))
return 0.0;
return data.u.dbl;
}
while (true) {
const perf_counter_data_any_d &data(*d);
buf[0] = '\0';
- if (d->count != COUNT_DISABLED) {
- switch (d->type) {
- case PERF_COUNTERS_DATA_ANY_U64:
- snprintf(buf, sizeof(buf), "\"%s\":{\"count\":%" PRId64 ","
- "\"sum\":%" PRId64 "}",
- data.name, data.count, data.u.u64);
- break;
- case PERF_COUNTERS_DATA_ANY_DOUBLE:
- snprintf(buf, sizeof(buf), "\"%s\":{\"count\":%" PRId64 ","
- "\"sum\":%g}",
- data.name, data.count, data.u.dbl);
- break;
- default:
- assert(0);
- break;
- }
- }
- else {
- switch (d->type) {
- case PERF_COUNTERS_DATA_ANY_U64:
- snprintf(buf, sizeof(buf), "\"%s\":%" PRId64,
- data.name, data.u.u64);
- break;
- case PERF_COUNTERS_DATA_ANY_DOUBLE:
- snprintf(buf, sizeof(buf), "\"%s\":%g", data.name, data.u.dbl);
- break;
- default:
- assert(0);
- break;
- }
- }
+ data.write_json(buf, sizeof(buf));
+
append_to_vector(buffer, buf);
if (++d == d_end)
break;
PerfCounters::perf_counter_data_any_d::
perf_counter_data_any_d()
: name(NULL),
- type(PERF_COUNTERS_DATA_ANY_NONE),
- count(COUNT_DISABLED)
+ type(PERFCOUNTER_NONE),
+ avgcount(0)
{
memset(&u, 0, sizeof(u));
}
+void PerfCounters::perf_counter_data_any_d::
+write_json(char *buf, size_t buf_sz) const
+{
+ if (type & PERFCOUNTER_LONGRUNAVG) {
+ if (type & PERFCOUNTER_U64) {
+ snprintf(buf, buf_sz, "\"%s\":{\"avgcount\":%" PRId64 ","
+ "\"sum\":%" PRId64 "}",
+ name, avgcount, u.u64);
+ }
+ else if (type & PERFCOUNTER_FLOAT) {
+ snprintf(buf, buf_sz, "\"%s\":{\"avgcount\":%" PRId64 ","
+ "\"sum\":%g}",
+ name, avgcount, u.dbl);
+ }
+ else {
+ assert(0);
+ }
+ }
+ else {
+ if (type & PERFCOUNTER_U64) {
+ snprintf(buf, buf_sz, "\"%s\":%" PRId64,
+ name, u.u64);
+ }
+ else if (type & PERFCOUNTER_FLOAT) {
+ snprintf(buf, buf_sz, "\"%s\":%g", name, u.dbl);
+ }
+ else {
+ assert(0);
+ }
+ }
+}
+
PerfCountersBuilder::
PerfCountersBuilder(CephContext *cct, const std::string &name,
int first, int last)
m_perf_counters = NULL;
}
+void PerfCountersBuilder::
+add_u64_counter(int idx, const char *name)
+{
+ add_impl(idx, name, PERFCOUNTER_U64 | PERFCOUNTER_COUNTER);
+}
+
void PerfCountersBuilder::
add_u64(int idx, const char *name)
{
- add_impl(idx, name, PERF_COUNTERS_DATA_ANY_U64, COUNT_DISABLED);
+ add_impl(idx, name, PERFCOUNTER_U64);
}
void PerfCountersBuilder::
add_fl(int idx, const char *name)
{
- add_impl(idx, name, PERF_COUNTERS_DATA_ANY_DOUBLE, COUNT_DISABLED);
+ add_impl(idx, name, PERFCOUNTER_FLOAT);
}
void PerfCountersBuilder::
add_fl_avg(int idx, const char *name)
{
- add_impl(idx, name, PERF_COUNTERS_DATA_ANY_DOUBLE, 0);
+ add_impl(idx, name, PERFCOUNTER_FLOAT | PERFCOUNTER_LONGRUNAVG);
}
void PerfCountersBuilder::
-add_impl(int idx, const char *name, int ty, uint64_t count)
+add_impl(int idx, const char *name, int ty)
{
assert(idx > m_perf_counters->m_lower_bound);
assert(idx < m_perf_counters->m_upper_bound);
PerfCounters::perf_counter_data_any_d
&data(vec[idx - m_perf_counters->m_lower_bound - 1]);
data.name = name;
- data.type = ty;
- data.count = count;
+ data.type = (enum perfcounter_type_d)ty;
+ data.avgcount = 0;
}
PerfCounters *PerfCountersBuilder::
PerfCounters::perf_counter_data_vec_t::const_iterator d = m_perf_counters->m_data.begin();
PerfCounters::perf_counter_data_vec_t::const_iterator d_end = m_perf_counters->m_data.end();
for (; d != d_end; ++d) {
- assert(d->type != PERF_COUNTERS_DATA_ANY_NONE);
+ assert(d->type != PERFCOUNTER_NONE);
}
PerfCounters *ret = m_perf_counters;
m_perf_counters = NULL;
class PerfCountersBuilder;
class PerfCountersCollectionTest;
+enum perfcounter_type_d
+{
+ PERFCOUNTER_NONE = 0,
+ PERFCOUNTER_FLOAT = 0x1,
+ PERFCOUNTER_U64 = 0x2,
+ PERFCOUNTER_LONGRUNAVG = 0x4,
+ PERFCOUNTER_COUNTER = 0x8,
+};
+
/*
* A PerfCounters object is usually associated with a single subsystem.
* It contains counters which we modify to track performance and throughput
/** Represents a PerfCounters data element. */
struct perf_counter_data_any_d {
perf_counter_data_any_d();
+ void write_json(char *buf, size_t buf_sz) const;
+
const char *name;
- int type;
+ enum perfcounter_type_d type;
union {
uint64_t u64;
double dbl;
} u;
- uint64_t count;
+ uint64_t avgcount;
};
typedef std::vector<perf_counter_data_any_d> perf_counter_data_vec_t;
int first, int last);
~PerfCountersBuilder();
void add_u64(int key, const char *name);
+ void add_u64_counter(int key, const char *name);
void add_fl(int key, const char *name);
void add_fl_avg(int key, const char *name);
PerfCounters* create_perf_counters();
private:
PerfCountersBuilder(const PerfCountersBuilder &rhs);
PerfCountersBuilder& operator=(const PerfCountersBuilder &rhs);
- void add_impl(int idx, const char *name, int ty, uint64_t count);
+ void add_impl(int idx, const char *name, int ty);
PerfCounters *m_perf_counters;
};
snprintf(name, sizeof(name), "mds.%s.log", g_conf->name.get_id().c_str());
PerfCountersBuilder plb(g_ceph_context, name, l_mdl_first, l_mdl_last);
- plb.add_u64(l_mdl_evadd, "evadd");
- plb.add_u64(l_mdl_evex, "evex");
- plb.add_u64(l_mdl_evtrm, "evtrm");
+ plb.add_u64_counter(l_mdl_evadd, "evadd");
+ plb.add_u64_counter(l_mdl_evex, "evex");
+ plb.add_u64_counter(l_mdl_evtrm, "evtrm");
plb.add_u64(l_mdl_ev, "ev");
plb.add_u64(l_mdl_evexg, "evexg");
plb.add_u64(l_mdl_evexd, "evexd");
- plb.add_u64(l_mdl_segadd, "segadd");
- plb.add_u64(l_mdl_segex, "segex");
- plb.add_u64(l_mdl_segtrm, "segtrm");
+ plb.add_u64_counter(l_mdl_segadd, "segadd");
+ plb.add_u64_counter(l_mdl_segex, "segex");
+ plb.add_u64_counter(l_mdl_segtrm, "segtrm");
plb.add_u64(l_mdl_seg, "seg");
plb.add_u64(l_mdl_segexg, "segexg");
plb.add_u64(l_mdl_segexd, "segexd");
PerfCountersBuilder mds_plb(g_ceph_context, name,
l_mds_first, l_mds_last);
- mds_plb.add_u64(l_mds_req, "req"); // FIXME: nobody is actually setting this
- mds_plb.add_u64(l_mds_reply, "reply");
+ mds_plb.add_u64_counter(l_mds_req, "req"); // FIXME: nobody is actually setting this
+ mds_plb.add_u64_counter(l_mds_reply, "reply");
mds_plb.add_fl_avg(l_mds_replyl, "replyl");
- mds_plb.add_u64(l_mds_fw, "fw");
+ mds_plb.add_u64_counter(l_mds_fw, "fw");
- mds_plb.add_u64(l_mds_dir_f, "dir_f");
- mds_plb.add_u64(l_mds_dir_c, "dir_c");
- mds_plb.add_u64(l_mds_dir_sp, "dir_sp");
- mds_plb.add_u64(l_mds_dir_ffc, "dir_ffc");
- //mds_plb.add_u64("mkdir");
+ mds_plb.add_u64_counter(l_mds_dir_f, "dir_f");
+ mds_plb.add_u64_counter(l_mds_dir_c, "dir_c");
+ mds_plb.add_u64_counter(l_mds_dir_sp, "dir_sp");
+ mds_plb.add_u64_counter(l_mds_dir_ffc, "dir_ffc");
+ //mds_plb.add_u64_counter("mkdir");
/*
- mds_plb.add_u64("newin"); // new inodes (pre)loaded
- mds_plb.add_u64("newt"); // inodes first touched/used
- mds_plb.add_u64("outt"); // trimmed touched
- mds_plb.add_u64("outut"); // trimmed untouched (wasted effort)
+ mds_plb.add_u64_counter("newin"); // new inodes (pre)loaded
+ mds_plb.add_u64_counter("newt"); // inodes first touched/used
+ mds_plb.add_u64_counter("outt"); // trimmed touched
+ mds_plb.add_u64_counter("outut"); // trimmed untouched (wasted effort)
mds_plb.add_fl_avg("oututl"); // avg trim latency for untouched
- mds_plb.add_u64("dirt1");
- mds_plb.add_u64("dirt2");
- mds_plb.add_u64("dirt3");
- mds_plb.add_u64("dirt4");
- mds_plb.add_u64("dirt5");
+ mds_plb.add_u64_counter("dirt1");
+ mds_plb.add_u64_counter("dirt2");
+ mds_plb.add_u64_counter("dirt3");
+ mds_plb.add_u64_counter("dirt4");
+ mds_plb.add_u64_counter("dirt5");
*/
mds_plb.add_u64(l_mds_imax, "imax");
mds_plb.add_u64(l_mds_ibot, "ibot");
mds_plb.add_u64(l_mds_iptail, "iptail");
mds_plb.add_u64(l_mds_ipin, "ipin");
- mds_plb.add_u64(l_mds_iex, "iex");
- mds_plb.add_u64(l_mds_icap, "icap");
- mds_plb.add_u64(l_mds_cap, "cap");
+ mds_plb.add_u64_counter(l_mds_iex, "iex");
+ mds_plb.add_u64_counter(l_mds_icap, "icap");
+ mds_plb.add_u64_counter(l_mds_cap, "cap");
- mds_plb.add_u64(l_mds_dis, "dis"); // FIXME: unused
-
- mds_plb.add_u64(l_mds_t, "t");
- mds_plb.add_u64(l_mds_thit, "thit");
- mds_plb.add_u64(l_mds_tfw, "tfw");
- mds_plb.add_u64(l_mds_tdis, "tdis");
- mds_plb.add_u64(l_mds_tdirf, "tdirf");
- mds_plb.add_u64(l_mds_trino, "trino");
- mds_plb.add_u64(l_mds_tlock, "tlock");
+ mds_plb.add_u64_counter(l_mds_dis, "dis"); // FIXME: unused
+
+ mds_plb.add_u64_counter(l_mds_t, "t");
+ mds_plb.add_u64_counter(l_mds_thit, "thit");
+ mds_plb.add_u64_counter(l_mds_tfw, "tfw");
+ mds_plb.add_u64_counter(l_mds_tdis, "tdis");
+ mds_plb.add_u64_counter(l_mds_tdirf, "tdirf");
+ mds_plb.add_u64_counter(l_mds_trino, "trino");
+ mds_plb.add_u64_counter(l_mds_tlock, "tlock");
mds_plb.add_fl(l_mds_l, "l");
mds_plb.add_u64(l_mds_q, "q");
mds_plb.add_u64(l_mds_popnest, "popnest");
mds_plb.add_u64(l_mds_sm, "sm");
- mds_plb.add_u64(l_mds_ex, "ex");
- mds_plb.add_u64(l_mds_iexp, "iexp");
- mds_plb.add_u64(l_mds_im, "im");
- mds_plb.add_u64(l_mds_iim, "iim");
+ mds_plb.add_u64_counter(l_mds_ex, "ex");
+ mds_plb.add_u64_counter(l_mds_iexp, "iexp");
+ mds_plb.add_u64_counter(l_mds_im, "im");
+ mds_plb.add_u64_counter(l_mds_iim, "iim");
logger = mds_plb.create_perf_counters();
g_ceph_context->GetPerfCountersCollection()->logger_add(logger);
}
PerfCountersBuilder mdm_plb(g_ceph_context, name,
l_mdm_first, l_mdm_last);
mdm_plb.add_u64(l_mdm_ino, "ino");
- mdm_plb.add_u64(l_mdm_inoa, "ino+");
- mdm_plb.add_u64(l_mdm_inos, "ino-");
+ mdm_plb.add_u64_counter(l_mdm_inoa, "ino+");
+ mdm_plb.add_u64_counter(l_mdm_inos, "ino-");
mdm_plb.add_u64(l_mdm_dir, "dir");
- mdm_plb.add_u64(l_mdm_dira, "dir+");
- mdm_plb.add_u64(l_mdm_dirs, "dir-");
+ mdm_plb.add_u64_counter(l_mdm_dira, "dir+");
+ mdm_plb.add_u64_counter(l_mdm_dirs, "dir-");
mdm_plb.add_u64(l_mdm_dn, "dn");
- mdm_plb.add_u64(l_mdm_dna, "dn+");
- mdm_plb.add_u64(l_mdm_dns, "dn-");
+ mdm_plb.add_u64_counter(l_mdm_dna, "dn+");
+ mdm_plb.add_u64_counter(l_mdm_dns, "dn-");
mdm_plb.add_u64(l_mdm_cap, "cap");
- mdm_plb.add_u64(l_mdm_capa, "cap+");
- mdm_plb.add_u64(l_mdm_caps, "cap-");
+ mdm_plb.add_u64_counter(l_mdm_capa, "cap+");
+ mdm_plb.add_u64_counter(l_mdm_caps, "cap-");
mdm_plb.add_u64(l_mdm_rss, "rss");
mdm_plb.add_u64(l_mdm_heap, "heap");
mdm_plb.add_u64(l_mdm_malloc, "malloc");
char name[80];
snprintf(name, sizeof(name), "mds.%s.server.log", g_conf->name.get_id().c_str());
PerfCountersBuilder plb(g_ceph_context, name, l_mdss_first, l_mdss_last);
- plb.add_u64(l_mdss_hcreq,"hcreq"); // handle client req
- plb.add_u64(l_mdss_hsreq, "hsreq"); // slave
- plb.add_u64(l_mdss_hcsess, "hcsess"); // client session
- plb.add_u64(l_mdss_dcreq, "dcreq"); // dispatch client req
- plb.add_u64(l_mdss_dsreq, "dsreq"); // slave
+ plb.add_u64_counter(l_mdss_hcreq,"hcreq"); // handle client req
+ plb.add_u64_counter(l_mdss_hsreq, "hsreq"); // slave
+ plb.add_u64_counter(l_mdss_hcsess, "hcsess"); // client session
+ plb.add_u64_counter(l_mdss_dcreq, "dcreq"); // dispatch client req
+ plb.add_u64_counter(l_mdss_dsreq, "dsreq"); // slave
logger = plb.create_perf_counters();
g_ceph_context->GetPerfCountersCollection()->logger_add(logger);
}
snprintf(name, sizeof(name), "osd.%d.fs.log", whoami);
PerfCountersBuilder plb(g_ceph_context, name, l_os_first, l_os_last);
- plb.add_u64(l_os_in_ops, "in_o");
- //plb.add_u64(l_os_in_bytes, "in_b");
- plb.add_u64(l_os_readable_ops, "or_o");
- plb.add_u64(l_os_readable_bytes, "or_b");
- //plb.add_u64(l_os_commit_bytes, "com_o");
- //plb.add_u64(l_os_commit_bytes, "com_b");
+ plb.add_u64_counter(l_os_in_ops, "in_o");
+ //plb.add_u64_counter(l_os_in_bytes, "in_b");
+ plb.add_u64_counter(l_os_readable_ops, "or_o");
+ plb.add_u64_counter(l_os_readable_bytes, "or_b");
+ //plb.add_u64_counter(l_os_commit_bytes, "com_o");
+ //plb.add_u64_counter(l_os_commit_bytes, "com_b");
plb.add_u64(l_os_jq_max_ops, "jq_mo");
plb.add_u64(l_os_jq_ops, "jq_o");
- plb.add_u64(l_os_j_ops, "j_o");
+ plb.add_u64_counter(l_os_j_ops, "j_o");
plb.add_u64(l_os_jq_max_bytes, "jq_mb");
plb.add_u64(l_os_jq_bytes, "jq_b");
- plb.add_u64(l_os_j_bytes, "j_b");
+ plb.add_u64_counter(l_os_j_bytes, "j_b");
plb.add_u64(l_os_oq_max_ops, "oq_mo");
plb.add_u64(l_os_oq_ops, "oq_o");
- plb.add_u64(l_os_ops, "o");
+ plb.add_u64_counter(l_os_ops, "o");
plb.add_u64(l_os_oq_max_bytes, "oq_mb");
plb.add_u64(l_os_oq_bytes, "oq_b");
- plb.add_u64(l_os_bytes, "b");
+ plb.add_u64_counter(l_os_bytes, "b");
plb.add_u64(l_os_committing, "comitng");
logger = plb.create_perf_counters();
osd_plb.add_u64(l_osd_opq, "opq"); // op queue length (waiting to be processed yet)
osd_plb.add_u64(l_osd_op_wip, "op_wip"); // rep ops currently being processed (primary)
- osd_plb.add_u64(l_osd_op, "op"); // client ops
- osd_plb.add_u64(l_osd_op_inb, "op_inb"); // client op in bytes (writes)
- osd_plb.add_u64(l_osd_op_outb, "op_outb"); // client op out bytes (reads)
+ osd_plb.add_u64_counter(l_osd_op, "op"); // client ops
+ osd_plb.add_u64_counter(l_osd_op_inb, "op_inb"); // client op in bytes (writes)
+ osd_plb.add_u64_counter(l_osd_op_outb, "op_outb"); // client op out bytes (reads)
osd_plb.add_fl_avg(l_osd_op_lat, "op_lat"); // client op latency
- osd_plb.add_u64(l_osd_op_r, "op_r"); // client reads
- osd_plb.add_u64(l_osd_op_r_outb, "op_r_outb"); // client read out bytes
+ osd_plb.add_u64_counter(l_osd_op_r, "op_r"); // client reads
+ osd_plb.add_u64_counter(l_osd_op_r_outb, "op_r_outb"); // client read out bytes
osd_plb.add_fl_avg(l_osd_op_r_lat, "op_r_lat"); // client read latency
- osd_plb.add_u64(l_osd_op_w, "op_w"); // client writes
- osd_plb.add_u64(l_osd_op_w_inb, "op_w_inb"); // client write in bytes
+ osd_plb.add_u64_counter(l_osd_op_w, "op_w"); // client writes
+ osd_plb.add_u64_counter(l_osd_op_w_inb, "op_w_inb"); // client write in bytes
osd_plb.add_fl_avg(l_osd_op_w_rlat, "op_w_rlat"); // client write readable/applied latency
osd_plb.add_fl_avg(l_osd_op_w_lat, "op_w_lat"); // client write latency
- osd_plb.add_u64(l_osd_op_rw, "op_rw"); // client rmw
- osd_plb.add_u64(l_osd_op_rw_inb, "op_rw_inb"); // client rmw in bytes
- osd_plb.add_u64(l_osd_op_rw_outb,"op_rw_outb"); // client rmw out bytes
+ osd_plb.add_u64_counter(l_osd_op_rw, "op_rw"); // client rmw
+ osd_plb.add_u64_counter(l_osd_op_rw_inb, "op_rw_inb"); // client rmw in bytes
+ osd_plb.add_u64_counter(l_osd_op_rw_outb,"op_rw_outb"); // client rmw out bytes
osd_plb.add_fl_avg(l_osd_op_rw_rlat,"op_rw_rlat"); // client rmw readable/applied latency
osd_plb.add_fl_avg(l_osd_op_rw_lat, "op_rw_lat"); // client rmw latency
- osd_plb.add_u64(l_osd_sop, "sop"); // subops
- osd_plb.add_u64(l_osd_sop_inb, "sop_inb"); // subop in bytes
+ osd_plb.add_u64_counter(l_osd_sop, "sop"); // subops
+ osd_plb.add_u64_counter(l_osd_sop_inb, "sop_inb"); // subop in bytes
osd_plb.add_fl_avg(l_osd_sop_lat, "sop_lat"); // subop latency
- osd_plb.add_u64(l_osd_sop_w, "sop_w"); // replicated (client) writes
- osd_plb.add_u64(l_osd_sop_w_inb, "sop_w_inb"); // replicated write in bytes
+ osd_plb.add_u64_counter(l_osd_sop_w, "sop_w"); // replicated (client) writes
+ osd_plb.add_u64_counter(l_osd_sop_w_inb, "sop_w_inb"); // replicated write in bytes
osd_plb.add_fl_avg(l_osd_sop_w_lat, "sop_w_lat"); // replicated write latency
- osd_plb.add_u64(l_osd_sop_pull, "sop_pull"); // pull request
+ osd_plb.add_u64_counter(l_osd_sop_pull, "sop_pull"); // pull request
osd_plb.add_fl_avg(l_osd_sop_pull_lat, "sop_pull_lat");
- osd_plb.add_u64(l_osd_sop_push, "sop_push"); // push (write)
- osd_plb.add_u64(l_osd_sop_push_inb, "sop_push_inb");
+ osd_plb.add_u64_counter(l_osd_sop_push, "sop_push"); // push (write)
+ osd_plb.add_u64_counter(l_osd_sop_push_inb, "sop_push_inb");
osd_plb.add_fl_avg(l_osd_sop_push_lat, "sop_push_lat");
- osd_plb.add_u64(l_osd_pull, "pull"); // pull requests sent
- osd_plb.add_u64(l_osd_push, "push"); // push messages
- osd_plb.add_u64(l_osd_push_outb, "push_outb"); // pushed bytes
+ osd_plb.add_u64_counter(l_osd_pull, "pull"); // pull requests sent
+ osd_plb.add_u64_counter(l_osd_push, "push"); // push messages
+ osd_plb.add_u64_counter(l_osd_push_outb, "push_outb"); // pushed bytes
- osd_plb.add_u64(l_osd_rop, "rop"); // recovery ops (started)
+ osd_plb.add_u64_counter(l_osd_rop, "rop"); // recovery ops (started)
osd_plb.add_fl(l_osd_loadavg, "loadavg");
osd_plb.add_u64(l_osd_buf, "buf"); // total ceph::buffer bytes
osd_plb.add_u64(l_osd_pg_stray, "numpg_stray"); // num stray pgs
osd_plb.add_u64(l_osd_hb_to, "hbto"); // heartbeat peers we send to
osd_plb.add_u64(l_osd_hb_from, "hbfrom"); // heartbeat peers we recv from
- osd_plb.add_u64(l_osd_map, "map"); // osdmap messages
- osd_plb.add_u64(l_osd_mape, "mape"); // osdmap epochs
- osd_plb.add_u64(l_osd_mape_dup, "mape_dup"); // dup osdmap epochs
+ osd_plb.add_u64_counter(l_osd_map, "map"); // osdmap messages
+ osd_plb.add_u64_counter(l_osd_mape, "mape"); // osdmap epochs
+ osd_plb.add_u64_counter(l_osd_mape_dup, "mape_dup"); // dup osdmap epochs
logger = osd_plb.create_perf_counters();
g_ceph_context->GetPerfCountersCollection()->logger_add(logger);
std::string msg;
ASSERT_EQ("", client.get_message(&msg));
ASSERT_EQ(sd("{'test_perfcounter_1':{'element1':0,"
- "'element2':0,'element3':{'count':0,'sum':0}}}"), msg);
+ "'element2':0,'element3':{'avgcount':0,'sum':0}}}"), msg);
fake_pf->inc(TEST_PERFCOUNTERS1_ELEMENT_1);
fake_pf->fset(TEST_PERFCOUNTERS1_ELEMENT_2, 0.5);
fake_pf->finc(TEST_PERFCOUNTERS1_ELEMENT_3, 100.0);
ASSERT_EQ("", client.get_message(&msg));
ASSERT_EQ(sd("{'test_perfcounter_1':{'element1':1,"
- "'element2':0.5,'element3':{'count':1,'sum':100}}}"), msg);
+ "'element2':0.5,'element3':{'avgcount':1,'sum':100}}}"), msg);
fake_pf->finc(TEST_PERFCOUNTERS1_ELEMENT_3, 0.0);
fake_pf->finc(TEST_PERFCOUNTERS1_ELEMENT_3, 25.0);
ASSERT_EQ("", client.get_message(&msg));
ASSERT_EQ(sd("{'test_perfcounter_1':{'element1':1,'element2':0.5,"
- "'element3':{'count':3,'sum':125}}}"), msg);
+ "'element3':{'avgcount':3,'sum':125}}}"), msg);
}
enum {
ASSERT_EQ("", client.get_message(&msg));
ASSERT_EQ(sd("{'test_perfcounter_1':{'element1':0,'element2':0,'element3':"
- "{'count':0,'sum':0}},'test_perfcounter_2':{'foo':0,'bar':0}}"), msg);
+ "{'avgcount':0,'sum':0}},'test_perfcounter_2':{'foo':0,'bar':0}}"), msg);
fake_pf1->inc(TEST_PERFCOUNTERS1_ELEMENT_1);
fake_pf1->inc(TEST_PERFCOUNTERS1_ELEMENT_1, 5);
ASSERT_EQ("", client.get_message(&msg));
ASSERT_EQ(sd("{'test_perfcounter_1':{'element1':6,'element2':0,'element3':"
- "{'count':0,'sum':0}},'test_perfcounter_2':{'foo':0,'bar':0}}"), msg);
+ "{'avgcount':0,'sum':0}},'test_perfcounter_2':{'foo':0,'bar':0}}"), msg);
coll->logger_remove(fake_pf2);
ASSERT_EQ("", client.get_message(&msg));
ASSERT_EQ(sd("{'test_perfcounter_1':{'element1':6,'element2':0,"
- "'element3':{'count':0,'sum':0}}}"), msg);
+ "'element3':{'avgcount':0,'sum':0}}}"), msg);
coll->logger_clear();
ASSERT_EQ("", client.get_message(&msg));
projects / ceph.git / commitdiff