ceph/src/tools/crimson/perf_staged_fltree.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:nil -*-
   2 // vim: ts=8 sw=2 smarttab
   3
   4 #include <boost/program_options.hpp>
   5
   6 #include <seastar/core/app-template.hh>
   7 #include <seastar/core/thread.hh>
   8
   9 #include "crimson/common/config_proxy.h"
  10 #include "crimson/common/log.h"
  11 #include "crimson/common/perf_counters_collection.h"
  12 #include "crimson/os/seastore/onode_manager/staged-fltree/tree_utils.h"
  13 #include "crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager.h"
  14
  15 #include "test/crimson/seastore/onode_tree/test_value.h"
  16 #include "test/crimson/seastore/transaction_manager_test_state.h"
  17
  18 using namespace crimson::os::seastore::onode;
  19 namespace bpo = boost::program_options;
  20
  21 seastar::logger& logger() {
  22   return crimson::get_logger(ceph_subsys_test);
  23 }
  24
  25 template <bool TRACK>
  26 class PerfTree : public TMTestState {
  27  public:
  28   PerfTree(bool is_dummy) : is_dummy{is_dummy} {}
  29
  30   seastar::future<> run(KVPool<test_item_t>& kvs, double erase_ratio) {
  31     return tm_setup().then([this, &kvs, erase_ratio] {
  32       return seastar::async([this, &kvs, erase_ratio] {
  33         auto tree = std::make_unique<TreeBuilder<TRACK, ExtendedValue>>(kvs,
  34             (is_dummy ? NodeExtentManager::create_dummy(true)
  35                       : NodeExtentManager::create_seastore(*tm)));
  36         {
  37           auto t = create_mutate_transaction();
  38           with_trans_intr(*t, [&](auto &tr){
  39             return tree->bootstrap(tr);
  40           }).unsafe_get();
  41           submit_transaction(std::move(t));
  42         }
  43         {
  44           auto t = create_mutate_transaction();
  45           with_trans_intr(*t, [&](auto &tr){
  46             return tree->insert(tr);
  47           }).unsafe_get();
  48           auto start_time = mono_clock::now();
  49           submit_transaction(std::move(t));
  50           std::chrono::duration<double> duration = mono_clock::now() - start_time;
  51           logger().warn("submit_transaction() done! {}s", duration.count());
  52         }
  53         {
  54           // Note: create_weak_transaction() can also work, but too slow.
  55           auto t = create_read_transaction();
  56           with_trans_intr(*t, [&](auto &tr){
  57             return tree->get_stats(tr);
  58           }).unsafe_get();
  59
  60           with_trans_intr(*t, [&](auto &tr){
  61             return tree->validate(tr);
  62           }).unsafe_get();
  63         }
  64         {
  65           auto t = create_mutate_transaction();
  66           with_trans_intr(*t, [&](auto &tr){
  67             return tree->erase(tr, kvs.size() * erase_ratio);
  68           }).unsafe_get();
  69           submit_transaction(std::move(t));
  70         }
  71         {
  72           auto t = create_read_transaction();
  73           with_trans_intr(*t, [&](auto &tr){
  74             return tree->get_stats(tr);
  75           }).unsafe_get();
  76
  77           with_trans_intr(*t, [&](auto &tr){
  78             return tree->validate(tr);
  79           }).unsafe_get();
  80         }
  81         tree.reset();
  82       });
  83     }).then([this] {
  84       return tm_teardown();
  85     });
  86   }
  87
  88  private:
  89   bool is_dummy;
  90 };
  91
  92 template <bool TRACK>
  93 seastar::future<> run(const bpo::variables_map& config) {
  94   return seastar::async([&config] {
  95     auto backend = config["backend"].as<std::string>();
  96     bool is_dummy;
  97     if (backend == "dummy") {
  98       is_dummy = true;
  99     } else if (backend == "seastore") {
 100       is_dummy = false;
 101     } else {
 102       ceph_abort(false && "invalid backend");
 103     }
 104     auto ns_sizes = config["ns-sizes"].as<std::vector<size_t>>();
 105     auto oid_sizes = config["oid-sizes"].as<std::vector<size_t>>();
 106     auto onode_sizes = config["onode-sizes"].as<std::vector<size_t>>();
 107     auto range2 = config["range2"].as<std::vector<int>>();
 108     ceph_assert(range2.size() == 2);
 109     auto range1 = config["range1"].as<std::vector<unsigned>>();
 110     ceph_assert(range1.size() == 2);
 111     auto range0 = config["range0"].as<std::vector<unsigned>>();
 112     ceph_assert(range0.size() == 2);
 113     auto erase_ratio = config["erase-ratio"].as<double>();
 114     ceph_assert(erase_ratio >= 0);
 115     ceph_assert(erase_ratio <= 1);
 116
 117     using crimson::common::sharded_conf;
 118     sharded_conf().start(EntityName{}, std::string_view{"ceph"}).get();
 119     seastar::engine().at_exit([] {
 120       return sharded_conf().stop();
 121     });
 122
 123     using crimson::common::sharded_perf_coll;
 124     sharded_perf_coll().start().get();
 125     seastar::engine().at_exit([] {
 126       return sharded_perf_coll().stop();
 127     });
 128
 129     auto kvs = KVPool<test_item_t>::create_raw_range(
 130         ns_sizes, oid_sizes, onode_sizes,
 131         {range2[0], range2[1]},
 132         {range1[0], range1[1]},
 133         {range0[0], range0[1]});
 134     PerfTree<TRACK> perf{is_dummy};
 135     perf.run(kvs, erase_ratio).get0();
 136   });
 137 }
 138
 139
 140 int main(int argc, char** argv)
 141 {
 142   seastar::app_template app;
 143   app.add_options()
 144     ("backend", bpo::value<std::string>()->default_value("dummy"),
 145      "tree backend: dummy, seastore")
 146     ("tracked", bpo::value<bool>()->default_value(false),
 147      "track inserted cursors")
 148     ("ns-sizes", bpo::value<std::vector<size_t>>()->default_value(
 149         {8, 11, 64, 128, 255, 256}),
 150      "sizes of ns strings")
 151     ("oid-sizes", bpo::value<std::vector<size_t>>()->default_value(
 152         {8, 13, 64, 512, 2035, 2048}),
 153      "sizes of oid strings")
 154     ("onode-sizes", bpo::value<std::vector<size_t>>()->default_value(
 155         {8, 16, 128, 576, 992, 1200}),
 156      "sizes of onode")
 157     ("range2", bpo::value<std::vector<int>>()->default_value(
 158         {0, 128}),
 159      "range of shard-pool-crush [a, b)")
 160     ("range1", bpo::value<std::vector<unsigned>>()->default_value(
 161         {0, 10}),
 162      "range of ns-oid strings [a, b)")
 163     ("range0", bpo::value<std::vector<unsigned>>()->default_value(
 164         {0, 4}),
 165      "range of snap-gen [a, b)")
 166     ("erase-ratio", bpo::value<double>()->default_value(
 167         0.8),
 168      "erase-ratio of all the inserted onodes");
 169   return app.run(argc, argv, [&app] {
 170     auto&& config = app.configuration();
 171     auto tracked = config["tracked"].as<bool>();
 172     if (tracked) {
 173       return run<true>(config);
 174     } else {
 175       return run<false>(config);
 176     }
 177   });
 178 }