sm::description("number of ool-records from committed transactions"),
{src_label}
),
- sm::make_counter(
- "committed_ool_record_padding_bytes",
- efforts.ool_record_padding_bytes,
- sm::description("bytes of ool-record padding from committed transactions"),
- {src_label}
- ),
sm::make_counter(
"committed_ool_record_metadata_bytes",
efforts.ool_record_metadata_bytes,
auto& ool_stats = t.get_ool_write_stats();
efforts.fresh_ool_written.increment_stat(ool_stats.extents);
efforts.num_ool_records += ool_stats.num_records;
- auto ool_record_bytes = (ool_stats.header_bytes + ool_stats.data_bytes);
+ auto ool_record_bytes = (ool_stats.md_bytes + ool_stats.get_data_bytes());
efforts.ool_record_bytes += ool_record_bytes;
- // Note: we only account overhead from committed ool records
if (t.get_src() == Transaction::src_t::CLEANER_TRIM ||
t.get_src() == Transaction::src_t::CLEANER_RECLAIM) {
SUBDEBUGT(seastore_t,
"commit H{} dirty_from={}, {} read, {} fresh with {} invalid, "
- "{} delta, {} retire, {}(md={}B, data={}B, fill={}) ool-records, "
+ "{} delta, {} retire, {}(md={}B, data={}B) ool-records, "
"{}B md, {}B data",
t, (void*)&t.get_handle(),
get_oldest_dirty_from().value_or(JOURNAL_SEQ_NULL),
delta_stat,
retire_stat,
ool_stats.num_records,
- ool_stats.header_raw_bytes,
- ool_stats.data_bytes,
- ((double)(ool_stats.header_raw_bytes + ool_stats.data_bytes) /
- (ool_stats.header_bytes + ool_stats.data_bytes)),
+ ool_stats.md_bytes,
+ ool_stats.get_data_bytes(),
record.size.get_raw_mdlength(),
record.size.dlength);
if (trans_src == Transaction::src_t::CLEANER_TRIM ||
++(efforts.num_trans);
efforts.num_ool_records += ool_stats.num_records;
- efforts.ool_record_padding_bytes +=
- (ool_stats.header_bytes - ool_stats.header_raw_bytes);
- efforts.ool_record_metadata_bytes += ool_stats.header_raw_bytes;
- efforts.ool_record_data_bytes += ool_stats.data_bytes;
+ efforts.ool_record_metadata_bytes += ool_stats.md_bytes;
+ efforts.ool_record_data_bytes += ool_stats.get_data_bytes();
efforts.inline_record_metadata_bytes +=
(record.size.get_raw_mdlength() - record.get_delta_size());
counter_by_extent_t<io_stat_t> fresh_ool_by_ext;
uint64_t num_trans = 0; // the number of inline records
uint64_t num_ool_records = 0;
- uint64_t ool_record_padding_bytes = 0;
uint64_t ool_record_metadata_bytes = 0;
uint64_t ool_record_data_bytes = 0;
uint64_t inline_record_metadata_bytes = 0; // metadata exclude the delta bytes
assert(!record.deltas.size());
// account transactional ool writes before write()
- // TODO: drop the incorrect size and fix the metrics
- auto record_size = record_group_size_t(
- record.size, segment_allocator.get_block_size());
auto& stats = t.get_ool_write_stats();
stats.extents.num += extents.size();
- stats.extents.bytes += record_size.dlength;
- stats.header_raw_bytes += record_size.get_raw_mdlength();
- stats.header_bytes += record_size.get_mdlength();
- stats.data_bytes += record_size.dlength;
+ stats.extents.bytes += record.size.dlength;
+ stats.md_bytes += record.size.get_raw_mdlength();
stats.num_records += 1;
return record_submitter.submit(std::move(record)
RecordSubmitter::open_ret
RecordSubmitter::open()
{
- return segment_allocator.open();
+ return segment_allocator.open(
+ ).safe_then([this](journal_seq_t ret) {
+ LOG_PREFIX(RecordSubmitter::open);
+ DEBUG("{} register metrics", get_name());
+ stats = {};
+ namespace sm = seastar::metrics;
+ std::vector<sm::label_instance> label_instances;
+ label_instances.push_back(sm::label_instance("submitter", get_name()));
+ metrics.add_group(
+ "journal",
+ {
+ sm::make_counter(
+ "record_num",
+ stats.record_batch_stats.num_io,
+ sm::description("total number of records submitted"),
+ label_instances
+ ),
+ sm::make_counter(
+ "record_batch_num",
+ stats.record_batch_stats.num_io_grouped,
+ sm::description("total number of records batched"),
+ label_instances
+ ),
+ sm::make_counter(
+ "io_num",
+ stats.io_depth_stats.num_io,
+ sm::description("total number of io submitted"),
+ label_instances
+ ),
+ sm::make_counter(
+ "io_depth_num",
+ stats.io_depth_stats.num_io_grouped,
+ sm::description("total number of io depth"),
+ label_instances
+ ),
+ sm::make_counter(
+ "record_group_padding_bytes",
+ stats.record_group_padding_bytes,
+ sm::description("bytes of metadata padding when write record groups"),
+ label_instances
+ ),
+ sm::make_counter(
+ "record_group_metadata_bytes",
+ stats.record_group_metadata_bytes,
+ sm::description("bytes of raw metadata when write record groups"),
+ label_instances
+ ),
+ sm::make_counter(
+ "record_group_data_bytes",
+ stats.record_group_data_bytes,
+ sm::description("bytes of data when write record groups"),
+ label_instances
+ ),
+ }
+ );
+ return ret;
+ });
}
RecordSubmitter::close_ertr::future<>
assert(!wait_available_promise.has_value());
has_io_error = false;
assert(!wait_unfull_flush_promise.has_value());
+ metrics.clear();
return segment_allocator.close();
}
(size.get_mdlength() - size.get_raw_mdlength());
stats.record_group_metadata_bytes += size.get_raw_mdlength();
stats.record_group_data_bytes += size.dlength;
+ stats.record_batch_stats.increment(num);
}
void RecordSubmitter::finish_submit_batch(
#include <optional>
#include <seastar/core/circular_buffer.hh>
+#include <seastar/core/metrics.hh>
#include <seastar/core/shared_future.hh>
#include "include/buffer.h"
return segment_allocator.get_name();
}
- grouped_io_stats get_record_batch_stats() const {
- return stats.record_batch_stats;
- }
-
- grouped_io_stats get_io_depth_stats() const {
- return stats.io_depth_stats;
- }
-
- uint64_t get_record_group_padding_bytes() const {
- return stats.record_group_padding_bytes;
- }
-
- uint64_t get_record_group_metadata_bytes() const {
- return stats.record_group_metadata_bytes;
- }
-
- uint64_t get_record_group_data_bytes() const {
- return stats.record_group_data_bytes;
- }
-
journal_seq_t get_committed_to() const {
return committed_to;
}
- void reset_stats() {
- stats = {};
- }
-
// whether is available to submit a record
bool is_available() const;
uint64_t record_group_metadata_bytes = 0;
uint64_t record_group_data_bytes = 0;
} stats;
+ seastar::metrics::metric_group metrics;
};
}
journal_segment_allocator),
scanner(scanner)
{
- register_metrics();
}
SegmentedJournal::open_for_write_ret SegmentedJournal::open_for_write()
LOG_PREFIX(Journal::close);
INFO("closing, committed_to={}",
record_submitter.get_committed_to());
- metrics.clear();
return record_submitter.close();
}
return do_submit_record(std::move(record), handle);
}
-void SegmentedJournal::register_metrics()
-{
- LOG_PREFIX(Journal::register_metrics);
- DEBUG("");
- record_submitter.reset_stats();
- namespace sm = seastar::metrics;
- metrics.add_group(
- "journal",
- {
- sm::make_counter(
- "record_num",
- [this] {
- return record_submitter.get_record_batch_stats().num_io;
- },
- sm::description("total number of records submitted")
- ),
- sm::make_counter(
- "record_batch_num",
- [this] {
- return record_submitter.get_record_batch_stats().num_io_grouped;
- },
- sm::description("total number of records batched")
- ),
- sm::make_counter(
- "io_num",
- [this] {
- return record_submitter.get_io_depth_stats().num_io;
- },
- sm::description("total number of io submitted")
- ),
- sm::make_counter(
- "io_depth_num",
- [this] {
- return record_submitter.get_io_depth_stats().num_io_grouped;
- },
- sm::description("total number of io depth")
- ),
- sm::make_counter(
- "record_group_padding_bytes",
- [this] {
- return record_submitter.get_record_group_padding_bytes();
- },
- sm::description("bytes of metadata padding when write record groups")
- ),
- sm::make_counter(
- "record_group_metadata_bytes",
- [this] {
- return record_submitter.get_record_group_metadata_bytes();
- },
- sm::description("bytes of raw metadata when write record groups")
- ),
- sm::make_counter(
- "record_group_data_bytes",
- [this] {
- return record_submitter.get_record_group_data_bytes();
- },
- sm::description("bytes of data when write record groups")
- ),
- }
- );
-}
-
}
#pragma once
#include <seastar/core/future.hh>
-#include <seastar/core/metrics.hh>
#include "include/ceph_assert.h"
#include "include/buffer.h"
SegmentAllocator journal_segment_allocator;
RecordSubmitter record_submitter;
ExtentReader& scanner;
- seastar::metrics::metric_group metrics;
WritePipeline* write_pipeline = nullptr;
/// read journal segment headers from scanner
segment_header_t header, ///< [in] segment header
delta_handler_t &delta_handler ///< [in] processes deltas in order
);
-
- void register_metrics();
};
}
struct ool_write_stats_t {
io_stat_t extents;
- uint64_t header_raw_bytes = 0;
- uint64_t header_bytes = 0;
- uint64_t data_bytes = 0;
+ uint64_t md_bytes = 0;
uint64_t num_records = 0;
+ uint64_t get_data_bytes() const {
+ return extents.bytes;
+ }
+
bool is_clear() const {
return (extents.is_clear() &&
- header_raw_bytes == 0 &&
- header_bytes == 0 &&
- data_bytes == 0 &&
+ md_bytes == 0 &&
num_records == 0);
}
};
projects / ceph.git / commitdiff