return utime_t(data.u64 / 1000000000ull, data.u64 % 1000000000ull);
}
+pair<uint64_t, uint64_t> PerfCounters::get_tavg_ms(int idx) const
+{
+ if (!m_cct->_conf->perf)
+ return make_pair(0, 0);
+
+ Mutex::Locker lck(m_lock);
+ 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 & PERFCOUNTER_TIME))
+ return make_pair(0, 0);
+ if (!(data.type & PERFCOUNTER_LONGRUNAVG))
+ return make_pair(0, 0);
+ return make_pair(data.avgcount, data.u64/1000000);
+}
+
void PerfCounters::dump_formatted(Formatter *f, bool schema)
{
Mutex::Locker lck(m_lock);
class PerfCounters
{
public:
+ template <typename T>
+ struct avg_tracker {
+ pair<uint64_t, T> last;
+ pair<uint64_t, T> cur;
+ avg_tracker() : last(0, 0), cur(0, 0) {}
+ T avg() const {
+ if (cur.first == last.first)
+ return cur.first ?
+ cur.second / cur.first :
+ 0; // no change, report avg over all time
+ return (cur.second - last.second) / (cur.first - last.first);
+ }
+ void consume_next(const pair<uint64_t, T> &next) {
+ last = cur;
+ cur = next;
+ }
+ };
+
~PerfCounters();
void inc(int idx, uint64_t v = 1);
void dump_formatted(ceph::Formatter *f, bool schema);
+ pair<uint64_t, uint64_t> get_tavg_ms(int idx) const;
+
const std::string& get_name() const;
void set_name(std::string s) {
m_name = s;
#define ALIGNED(x, by) (!((x) % (by)))
#define ALIGN_UP(x, by) (ALIGNED((x), (by)) ? (x) : (ALIGN_DOWN((x), (by)) + (by)))
+void FileStore::FSPerfTracker::update_from_perfcounters(
+ PerfCounters &logger)
+{
+ os_commit_latency.consume_next(
+ logger.get_tavg_ms(
+ l_os_commit_lat));
+ os_apply_latency.consume_next(
+ logger.get_tavg_ms(
+ l_os_apply_lat));
+}
+
ostream& operator<<(ostream& out, const FileStore::OpSequencer& s)
{
public md_config_obs_t
{
public:
+
+ struct FSPerfTracker {
+ PerfCounters::avg_tracker<uint64_t> os_commit_latency;
+ PerfCounters::avg_tracker<uint64_t> os_apply_latency;
+
+ filestore_perf_stat_t get_cur_stats() const {
+ filestore_perf_stat_t ret;
+ ret.filestore_commit_latency = os_commit_latency.avg();
+ ret.filestore_apply_latency = os_apply_latency.avg();
+ return ret;
+ }
+
+ void update_from_perfcounters(PerfCounters &logger);
+ } perf_tracker;
+ filestore_perf_stat_t get_cur_stats() {
+ perf_tracker.update_from_perfcounters(*logger);
+ return perf_tracker.get_cur_stats();
+ }
+
static const uint32_t on_disk_version = 3;
private:
string internal_name; ///< internal name, used to name the perfcounter instance
Logger *logger;
+ virtual filestore_perf_stat_t get_cur_stats() = 0;
+
/**
* a sequencer orders transactions
*
stat_lock.Lock();
osd_stat_t cur_stat = osd_stat;
stat_lock.Unlock();
+
+ osd_stat.fs_perf_stat = store->get_cur_stats();
pg_stat_queue_lock.Lock();