[ceph.git] / ceph / src / tools / rbd / action / Bench.cc

// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab

#include "tools/rbd/ArgumentTypes.h"
#include "tools/rbd/Shell.h"
#include "tools/rbd/Utils.h"
#include "common/errno.h"
#include "common/strtol.h"
#include "common/Cond.h"
#include "common/Mutex.h"
#include <iostream>
#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics/stats.hpp>
#include <boost/accumulators/statistics/rolling_sum.hpp>
#include <boost/program_options.hpp>

namespace rbd {
namespace action {
namespace bench {

namespace at = argument_types;
namespace po = boost::program_options;

namespace {

enum io_type_t {
  IO_TYPE_READ = 0,
  IO_TYPE_WRITE,

  IO_TYPE_NUM,
};

struct IOType {};
struct Size {};
struct IOPattern {};

void validate(boost::any& v, const std::vector<std::string>& values,
              Size *target_type, int) {
  po::validators::check_first_occurrence(v);
  const std::string &s = po::validators::get_single_string(values);

  std::string parse_error;
  uint64_t size = strict_sistrtoll(s.c_str(), &parse_error);
  if (!parse_error.empty()) {
    throw po::validation_error(po::validation_error::invalid_option_value);
  }
  v = boost::any(size);
}

void validate(boost::any& v, const std::vector<std::string>& values,
              IOPattern *target_type, int) {
  po::validators::check_first_occurrence(v);
  const std::string &s = po::validators::get_single_string(values);
  if (s == "rand") {
    v = boost::any(true);
  } else if (s == "seq") {
    v = boost::any(false);
  } else {
    throw po::validation_error(po::validation_error::invalid_option_value);
  }
}

io_type_t get_io_type(string io_type_string) {
  if (io_type_string == "read")
    return IO_TYPE_READ;
  else if (io_type_string == "write")
    return IO_TYPE_WRITE;
  else
    return IO_TYPE_NUM;
}

void validate(boost::any& v, const std::vector<std::string>& values,
              IOType *target_type, int) {
  po::validators::check_first_occurrence(v);
  const std::string &s = po::validators::get_single_string(values);
  io_type_t io_type = get_io_type(s);
  if (io_type >= IO_TYPE_NUM)
    throw po::validation_error(po::validation_error::invalid_option_value);
  else
    v = boost::any(io_type);
}

} // anonymous namespace

static void rbd_bencher_completion(void *c, void *pc);
struct rbd_bencher;

struct bencher_completer {
  rbd_bencher *bencher;
  bufferlist *bl;

public:
  bencher_completer(rbd_bencher *bencher, bufferlist *bl)
    : bencher(bencher), bl(bl)
  { }

  ~bencher_completer()
  {
    if (bl)
      delete bl;
  }
};

struct rbd_bencher {
  librbd::Image *image;
  Mutex lock;
  Cond cond;
  int in_flight;
  io_type_t io_type;
  uint64_t io_size;
  bufferlist write_bl;

  explicit rbd_bencher(librbd::Image *i, io_type_t io_type, uint64_t io_size)
    : image(i),
      lock("rbd_bencher::lock"),
      in_flight(0),
      io_type(io_type),
      io_size(io_size)
  {
    if (io_type == IO_TYPE_WRITE) {
      bufferptr bp(io_size);
      memset(bp.c_str(), rand() & 0xff, io_size);
      write_bl.push_back(bp);
    }
  }


  bool start_io(int max, uint64_t off, uint64_t len, int op_flags)
  {
    {
      Mutex::Locker l(lock);
      if (in_flight >= max)
        return false;
      in_flight++;
    }

    librbd::RBD::AioCompletion *c;
    if (io_type == IO_TYPE_READ) {
      bufferlist *read_bl = new bufferlist();
      c = new librbd::RBD::AioCompletion((void *)(new bencher_completer(this, read_bl)),
					 rbd_bencher_completion);
      image->aio_read2(off, len, *read_bl, c, op_flags);
    } else if (io_type == IO_TYPE_WRITE) {
      c = new librbd::RBD::AioCompletion((void *)(new bencher_completer(this, NULL)),
					 rbd_bencher_completion);
      image->aio_write2(off, len, write_bl, c, op_flags);
    } else {
      assert(0 == "Invalid io_type");
    }
    //cout << "start " << c << " at " << off << "~" << len << std::endl;
    return true;
  }

  void wait_for(int max) {
    Mutex::Locker l(lock);
    while (in_flight > max) {
      utime_t dur;
      dur.set_from_double(.2);
      cond.WaitInterval(lock, dur);
    }
  }

};

void rbd_bencher_completion(void *vc, void *pc)
{
  librbd::RBD::AioCompletion *c = (librbd::RBD::AioCompletion *)vc;
  bencher_completer *bc = static_cast<bencher_completer *>(pc);
  rbd_bencher *b = bc->bencher;
  //cout << "complete " << c << std::endl;
  int ret = c->get_return_value();
  if (b->io_type == IO_TYPE_WRITE && ret != 0) {
    cout << "write error: " << cpp_strerror(ret) << std::endl;
    exit(ret < 0 ? -ret : ret);
  } else if (b->io_type == IO_TYPE_READ && (unsigned int)ret != b->io_size) {
    cout << "read error: " << cpp_strerror(ret) << std::endl;
    exit(ret < 0 ? -ret : ret);
  }
  b->lock.Lock();
  b->in_flight--;
  b->cond.Signal();
  b->lock.Unlock();
  c->release();
  delete bc;
}

int do_bench(librbd::Image& image, io_type_t io_type,
		   uint64_t io_size, uint64_t io_threads,
		   uint64_t io_bytes, bool random)
{
  uint64_t size = 0;
  image.size(&size);
  if (io_size > size) {
    std::cerr << "rbd: io-size " << prettybyte_t(io_size) << " "
              << "larger than image size " << prettybyte_t(size) << std::endl;
    return -EINVAL;
  }

  if (io_size > std::numeric_limits<uint32_t>::max()) {
    std::cerr << "rbd: io-size should be less than 4G" << std::endl;
    return -EINVAL;
  }

  rbd_bencher b(&image, io_type, io_size);

  std::cout << "bench "
       << " type " << (io_type == IO_TYPE_READ ? "read" : "write")
       << " io_size " << io_size
       << " io_threads " << io_threads
       << " bytes " << io_bytes
       << " pattern " << (random ? "random" : "sequential")
       << std::endl;

  srand(time(NULL) % (unsigned long) -1);

  utime_t start = ceph_clock_now();
  utime_t last;
  unsigned ios = 0;

  vector<uint64_t> thread_offset;
  uint64_t i;
  uint64_t start_pos;

  // disturb all thread's offset, used by seq IO
  for (i = 0; i < io_threads; i++) {
    start_pos = (rand() % (size / io_size)) * io_size;
    thread_offset.push_back(start_pos);
  }

  const int WINDOW_SIZE = 5;
  typedef boost::accumulators::accumulator_set<
    double, boost::accumulators::stats<
      boost::accumulators::tag::rolling_sum> > RollingSum;

  RollingSum time_acc(
    boost::accumulators::tag::rolling_window::window_size = WINDOW_SIZE);
  RollingSum ios_acc(
    boost::accumulators::tag::rolling_window::window_size = WINDOW_SIZE);
  RollingSum off_acc(
    boost::accumulators::tag::rolling_window::window_size = WINDOW_SIZE);
  uint64_t cur_ios = 0;
  uint64_t cur_off = 0;

  int op_flags;
  if  (random) {
    op_flags = LIBRADOS_OP_FLAG_FADVISE_RANDOM;
  } else {
    op_flags = LIBRADOS_OP_FLAG_FADVISE_SEQUENTIAL;
  }

  printf("  SEC       OPS   OPS/SEC   BYTES/SEC\n");
  uint64_t off;
  for (off = 0; off < io_bytes; ) {
    b.wait_for(io_threads - 1);
    i = 0;
    while (i < io_threads && off < io_bytes) {
      if (!b.start_io(io_threads, thread_offset[i], io_size, op_flags)) {
        break;
      }
      if (random) {
        thread_offset[i] = (rand() % (size / io_size)) * io_size;
      } else {
        thread_offset[i] += io_size;
        if (thread_offset[i] + io_size > size)
          thread_offset[i] = 0;
      }
      ++i;
      ++ios;
      off += io_size;

      ++cur_ios;
      cur_off += io_size;
    }

    utime_t now = ceph_clock_now();
    utime_t elapsed = now - start;
    if (last.is_zero()) {
      last = elapsed;
    } else if (elapsed.sec() != last.sec()) {
      time_acc(elapsed - last);
      ios_acc(static_cast<double>(cur_ios));
      off_acc(static_cast<double>(cur_off));
      cur_ios = 0;
      cur_off = 0;

      double time_sum = boost::accumulators::rolling_sum(time_acc);
      printf("%5d  %8d  %8.2lf  %8.2lf\n",
             (int)elapsed,
             (int)(ios - io_threads),
             boost::accumulators::rolling_sum(ios_acc) / time_sum,
             boost::accumulators::rolling_sum(off_acc) / time_sum);
      last = elapsed;
    }
  }
  b.wait_for(0);
  int r = image.flush();
  if (r < 0) {
    std::cerr << "Error flushing data at the end: " << cpp_strerror(r)
              << std::endl;
  }

  utime_t now = ceph_clock_now();
  double elapsed = now - start;

  printf("elapsed: %5d  ops: %8d  ops/sec: %8.2lf  bytes/sec: %8.2lf\n",
         (int)elapsed, ios, (double)ios / elapsed, (double)off / elapsed);

  return 0;
}

void add_bench_common_options(po::options_description *positional,
			      po::options_description *options) {
  at::add_image_spec_options(positional, options, at::ARGUMENT_MODIFIER_NONE);

  options->add_options()
    ("io-size", po::value<Size>(), "IO size (in B/K/M/G/T) [default: 4K]")
    ("io-threads", po::value<uint32_t>(), "ios in flight [default: 16]")
    ("io-total", po::value<Size>(), "total size for IO (in B/K/M/G/T) [default: 1G]")
    ("io-pattern", po::value<IOPattern>(), "IO pattern (rand or seq) [default: seq]");
}

void get_arguments_for_write(po::options_description *positional,
                             po::options_description *options) {
  add_bench_common_options(positional, options);
}

void get_arguments_for_bench(po::options_description *positional,
                             po::options_description *options) {
  add_bench_common_options(positional, options);

  options->add_options()
    ("io-type", po::value<IOType>()->required(), "IO type (read or write)");
}

int bench_execute(const po::variables_map &vm, io_type_t bench_io_type) {
  size_t arg_index = 0;
  std::string pool_name;
  std::string image_name;
  std::string snap_name;
  utils::SnapshotPresence snap_presence = utils::SNAPSHOT_PRESENCE_NONE;
  if (bench_io_type == IO_TYPE_READ)
    snap_presence = utils::SNAPSHOT_PRESENCE_PERMITTED;

  int r = utils::get_pool_image_snapshot_names(
    vm, at::ARGUMENT_MODIFIER_NONE, &arg_index, &pool_name, &image_name,
    &snap_name, snap_presence, utils::SPEC_VALIDATION_NONE);
  if (r < 0) {
    return r;
  }

  uint64_t bench_io_size;
  if (vm.count("io-size")) {
    bench_io_size = vm["io-size"].as<uint64_t>();
  } else {
    bench_io_size = 4096;
  }
  if (bench_io_size == 0) {
    std::cerr << "rbd: --io-size should be greater than zero." << std::endl;
    return -EINVAL;
  }

  uint32_t bench_io_threads;
  if (vm.count("io-threads")) {
    bench_io_threads = vm["io-threads"].as<uint32_t>();
  } else {
    bench_io_threads = 16;
  }
  if (bench_io_threads == 0) {
    std::cerr << "rbd: --io-threads should be greater than zero." << std::endl;
    return -EINVAL;
  }

  uint64_t bench_bytes;
  if (vm.count("io-total")) {
    bench_bytes = vm["io-total"].as<uint64_t>();
  } else {
    bench_bytes = 1 << 30;
  }

  bool bench_random;
  if (vm.count("io-pattern")) {
    bench_random = vm["io-pattern"].as<bool>();
  } else {
    bench_random = false;
  }

  librados::Rados rados;
  librados::IoCtx io_ctx;
  librbd::Image image;
  r = utils::init_and_open_image(pool_name, image_name, "", "", false, &rados,
                                 &io_ctx, &image);
  if (r < 0) {
    return r;
  }

  r = do_bench(image, bench_io_type, bench_io_size, bench_io_threads,
		     bench_bytes, bench_random);
  if (r < 0) {
    std::cerr << "bench failed: " << cpp_strerror(r) << std::endl;
    return r;
  }
  return 0;
}

int execute_for_write(const po::variables_map &vm) {
  std::cerr << "rbd: bench-write is deprecated, use rbd bench --io-type write ..." << std::endl;
  return bench_execute(vm, IO_TYPE_WRITE);
}

int execute_for_bench(const po::variables_map &vm) {
  io_type_t bench_io_type;
  if (vm.count("io-type")) {
    bench_io_type = vm["io-type"].as<io_type_t>();
  } else {
    std::cerr << "rbd: --io-type must be specified." << std::endl;
    return -EINVAL;
  }

  return bench_execute(vm, bench_io_type);
}

Shell::Action action_write(
  {"bench-write"}, {}, "Simple write benchmark. (Deprecated, please use `rbd bench --io-type write` instead.)",
		   "", &get_arguments_for_write, &execute_for_write, false);

Shell::Action action_bench(
  {"bench"}, {}, "Simple benchmark.", "", &get_arguments_for_bench, &execute_for_bench);

} // namespace bench
} // namespace action
} // namespace rbd
Commit	Line	Data
7c673cae FG	1	// -- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t --
	2	// vim: ts=8 sw=2 smarttab
	3
	4	#include "tools/rbd/ArgumentTypes.h"
	5	#include "tools/rbd/Shell.h"
	6	#include "tools/rbd/Utils.h"
	7	#include "common/errno.h"
	8	#include "common/strtol.h"
	9	#include "common/Cond.h"
	10	#include "common/Mutex.h"
	11	#include <iostream>
	12	#include <boost/accumulators/accumulators.hpp>
	13	#include <boost/accumulators/statistics/stats.hpp>
	14	#include <boost/accumulators/statistics/rolling_sum.hpp>
	15	#include <boost/program_options.hpp>
	16
	17	namespace rbd {
	18	namespace action {
	19	namespace bench {
	20
	21	namespace at = argument_types;
	22	namespace po = boost::program_options;
	23
	24	namespace {
	25
	26	enum io_type_t {
	27	IO_TYPE_READ = 0,
	28	IO_TYPE_WRITE,
	29
	30	IO_TYPE_NUM,
	31	};
	32
	33	struct IOType {};
	34	struct Size {};
	35	struct IOPattern {};
	36
	37	void validate(boost::any& v, const std::vector<std::string>& values,
	38	Size *target_type, int) {
	39	po::validators::check_first_occurrence(v);
	40	const std::string &s = po::validators::get_single_string(values);
	41
	42	std::string parse_error;
	43	uint64_t size = strict_sistrtoll(s.c_str(), &parse_error);
	44	if (!parse_error.empty()) {
	45	throw po::validation_error(po::validation_error::invalid_option_value);
	46	}
	47	v = boost::any(size);
	48	}
	49
	50	void validate(boost::any& v, const std::vector<std::string>& values,
	51	IOPattern *target_type, int) {
	52	po::validators::check_first_occurrence(v);
	53	const std::string &s = po::validators::get_single_string(values);
	54	if (s == "rand") {
	55	v = boost::any(true);
	56	} else if (s == "seq") {
	57	v = boost::any(false);
	58	} else {
	59	throw po::validation_error(po::validation_error::invalid_option_value);
	60	}
	61	}
	62
	63	io_type_t get_io_type(string io_type_string) {
	64	if (io_type_string == "read")
65	return IO_TYPE_READ;
66	else if (io_type_string == "write")
67	return IO_TYPE_WRITE;
68	else
69	return IO_TYPE_NUM;
70	}
71
72	void validate(boost::any& v, const std::vector<std::string>& values,
73	IOType *target_type, int) {
74	po::validators::check_first_occurrence(v);
75	const std::string &s = po::validators::get_single_string(values);
76	io_type_t io_type = get_io_type(s);
77	if (io_type >= IO_TYPE_NUM)
78	throw po::validation_error(po::validation_error::invalid_option_value);
79	else
80	v = boost::any(io_type);
81	}
82
83	} // anonymous namespace
84
85	static void rbd_bencher_completion(void c, void pc);
86	struct rbd_bencher;
87
88	struct bencher_completer {
89	rbd_bencher *bencher;
90	bufferlist *bl;
91
92	public:
93	bencher_completer(rbd_bencher bencher, bufferlist bl)
94	: bencher(bencher), bl(bl)
95	{ }
96
97	~bencher_completer()
98	{
99	if (bl)
100	delete bl;
101	}
102	};
103
104	struct rbd_bencher {
105	librbd::Image *image;
106	Mutex lock;
107	Cond cond;
108	int in_flight;
109	io_type_t io_type;
110	uint64_t io_size;
111	bufferlist write_bl;
112
113	explicit rbd_bencher(librbd::Image *i, io_type_t io_type, uint64_t io_size)
114	: image(i),
115	lock("rbd_bencher::lock"),
116	in_flight(0),
117	io_type(io_type),
118	io_size(io_size)
119	{
120	if (io_type == IO_TYPE_WRITE) {
121	bufferptr bp(io_size);
122	memset(bp.c_str(), rand() & 0xff, io_size);
123	write_bl.push_back(bp);
124	}
125	}
126
127
128	bool start_io(int max, uint64_t off, uint64_t len, int op_flags)
129	{
130	{
131	Mutex::Locker l(lock);
132	if (in_flight >= max)
133	return false;
134	in_flight++;
135	}
136
137	librbd::RBD::AioCompletion *c;
138	if (io_type == IO_TYPE_READ) {
139	bufferlist *read_bl = new bufferlist();
140	c = new librbd::RBD::AioCompletion((void *)(new bencher_completer(this, read_bl)),
141	rbd_bencher_completion);
142	image->aio_read2(off, len, *read_bl, c, op_flags);
143	} else if (io_type == IO_TYPE_WRITE) {
144	c = new librbd::RBD::AioCompletion((void *)(new bencher_completer(this, NULL)),
145	rbd_bencher_completion);
146	image->aio_write2(off, len, write_bl, c, op_flags);
147	} else {
148	assert(0 == "Invalid io_type");
149	}
150	//cout << "start " << c << " at " << off << "~" << len << std::endl;
151	return true;
152	}
153
154	void wait_for(int max) {
155	Mutex::Locker l(lock);
156	while (in_flight > max) {
157	utime_t dur;
158	dur.set_from_double(.2);
159	cond.WaitInterval(lock, dur);
160	}
161	}
162
163	};
164
165	void rbd_bencher_completion(void vc, void pc)
166	{
167	librbd::RBD::AioCompletion c = (librbd::RBD::AioCompletion )vc;
168	bencher_completer bc = static_cast<bencher_completer >(pc);
169	rbd_bencher *b = bc->bencher;
170	//cout << "complete " << c << std::endl;
171	int ret = c->get_return_value();
172	if (b->io_type == IO_TYPE_WRITE && ret != 0) {
173	cout << "write error: " << cpp_strerror(ret) << std::endl;
174	exit(ret < 0 ? -ret : ret);
175	} else if (b->io_type == IO_TYPE_READ && (unsigned int)ret != b->io_size) {
176	cout << "read error: " << cpp_strerror(ret) << std::endl;
177	exit(ret < 0 ? -ret : ret);
178	}
179	b->lock.Lock();
180	b->in_flight--;
181	b->cond.Signal();
182	b->lock.Unlock();
183	c->release();
184	delete bc;
185	}
186
187	int do_bench(librbd::Image& image, io_type_t io_type,
188	uint64_t io_size, uint64_t io_threads,
189	uint64_t io_bytes, bool random)
190	{
191	uint64_t size = 0;
192	image.size(&size);
193	if (io_size > size) {
194	std::cerr << "rbd: io-size " << prettybyte_t(io_size) << " "
195	<< "larger than image size " << prettybyte_t(size) << std::endl;
196	return -EINVAL;
197	}
198
199	if (io_size > std::numeric_limits<uint32_t>::max()) {
200	std::cerr << "rbd: io-size should be less than 4G" << std::endl;
201	return -EINVAL;
202	}
203
204	rbd_bencher b(&image, io_type, io_size);
205
206	std::cout << "bench "
207	<< " type " << (io_type == IO_TYPE_READ ? "read" : "write")
208	<< " io_size " << io_size
209	<< " io_threads " << io_threads
210	<< " bytes " << io_bytes
211	<< " pattern " << (random ? "random" : "sequential")
212	<< std::endl;
213
214	srand(time(NULL) % (unsigned long) -1);
215
216	utime_t start = ceph_clock_now();
217	utime_t last;
218	unsigned ios = 0;
219
220	vector<uint64_t> thread_offset;
221	uint64_t i;
222	uint64_t start_pos;
223
224	// disturb all thread's offset, used by seq IO
225	for (i = 0; i < io_threads; i++) {
226	start_pos = (rand() % (size / io_size)) * io_size;
227	thread_offset.push_back(start_pos);
228	}
229
230	const int WINDOW_SIZE = 5;
231	typedef boost::accumulators::accumulator_set<
232	double, boost::accumulators::stats<
233	boost::accumulators::tag::rolling_sum> > RollingSum;
234
235	RollingSum time_acc(
236	boost::accumulators::tag::rolling_window::window_size = WINDOW_SIZE);
237	RollingSum ios_acc(
238	boost::accumulators::tag::rolling_window::window_size = WINDOW_SIZE);
239	RollingSum off_acc(
240	boost::accumulators::tag::rolling_window::window_size = WINDOW_SIZE);
241	uint64_t cur_ios = 0;
242	uint64_t cur_off = 0;
243
244	int op_flags;
245	if (random) {
246	op_flags = LIBRADOS_OP_FLAG_FADVISE_RANDOM;
247	} else {
248	op_flags = LIBRADOS_OP_FLAG_FADVISE_SEQUENTIAL;
249	}
250
251	printf(" SEC OPS OPS/SEC BYTES/SEC\n");
252	uint64_t off;
253	for (off = 0; off < io_bytes; ) {
254	b.wait_for(io_threads - 1);
255	i = 0;
256	while (i < io_threads && off < io_bytes) {
31f18b77 FG	257	if (!b.start_io(io_threads, thread_offset[i], io_size, op_flags)) {
	258	break;
	259	}
7c673cae FG	260	if (random) {
	261	thread_offset[i] = (rand() % (size / io_size)) * io_size;
	262	} else {
	263	thread_offset[i] += io_size;
	264	if (thread_offset[i] + io_size > size)
	265	thread_offset[i] = 0;
	266	}
7c673cae FG	267	++i;
	268	++ios;
	269	off += io_size;
	270
	271	++cur_ios;
	272	cur_off += io_size;
	273	}
	274
	275	utime_t now = ceph_clock_now();
	276	utime_t elapsed = now - start;
	277	if (last.is_zero()) {
	278	last = elapsed;
	279	} else if (elapsed.sec() != last.sec()) {
	280	time_acc(elapsed - last);
	281	ios_acc(static_cast<double>(cur_ios));
	282	off_acc(static_cast<double>(cur_off));
	283	cur_ios = 0;
	284	cur_off = 0;
	285
	286	double time_sum = boost::accumulators::rolling_sum(time_acc);
	287	printf("%5d %8d %8.2lf %8.2lf\n",
	288	(int)elapsed,
	289	(int)(ios - io_threads),
	290	boost::accumulators::rolling_sum(ios_acc) / time_sum,
	291	boost::accumulators::rolling_sum(off_acc) / time_sum);
	292	last = elapsed;
	293	}
	294	}
	295	b.wait_for(0);
	296	int r = image.flush();
	297	if (r < 0) {
	298	std::cerr << "Error flushing data at the end: " << cpp_strerror(r)
	299	<< std::endl;
	300	}
	301
	302	utime_t now = ceph_clock_now();
	303	double elapsed = now - start;
	304
	305	printf("elapsed: %5d ops: %8d ops/sec: %8.2lf bytes/sec: %8.2lf\n",
	306	(int)elapsed, ios, (double)ios / elapsed, (double)off / elapsed);
	307
	308	return 0;
	309	}
	310
	311	void add_bench_common_options(po::options_description *positional,
	312	po::options_description *options) {
	313	at::add_image_spec_options(positional, options, at::ARGUMENT_MODIFIER_NONE);
	314
	315	options->add_options()
	316	("io-size", po::value<Size>(), "IO size (in B/K/M/G/T) [default: 4K]")
	317	("io-threads", po::value<uint32_t>(), "ios in flight [default: 16]")
	318	("io-total", po::value<Size>(), "total size for IO (in B/K/M/G/T) [default: 1G]")
	319	("io-pattern", po::value<IOPattern>(), "IO pattern (rand or seq) [default: seq]");
	320	}
	321
	322	void get_arguments_for_write(po::options_description *positional,
	323	po::options_description *options) {
	324	add_bench_common_options(positional, options);
	325	}
	326
	327	void get_arguments_for_bench(po::options_description *positional,
	328	po::options_description *options) {
	329	add_bench_common_options(positional, options);
	330
331	options->add_options()
332	("io-type", po::value<IOType>()->required(), "IO type (read or write)");
333	}
334
335	int bench_execute(const po::variables_map &vm, io_type_t bench_io_type) {
336	size_t arg_index = 0;
337	std::string pool_name;
338	std::string image_name;
339	std::string snap_name;
340	utils::SnapshotPresence snap_presence = utils::SNAPSHOT_PRESENCE_NONE;
341	if (bench_io_type == IO_TYPE_READ)
342	snap_presence = utils::SNAPSHOT_PRESENCE_PERMITTED;
343
344	int r = utils::get_pool_image_snapshot_names(
345	vm, at::ARGUMENT_MODIFIER_NONE, &arg_index, &pool_name, &image_name,
346	&snap_name, snap_presence, utils::SPEC_VALIDATION_NONE);
347	if (r < 0) {
348	return r;
349	}
350
351	uint64_t bench_io_size;
352	if (vm.count("io-size")) {
353	bench_io_size = vm["io-size"].as<uint64_t>();
354	} else {
355	bench_io_size = 4096;
356	}
357	if (bench_io_size == 0) {
358	std::cerr << "rbd: --io-size should be greater than zero." << std::endl;
359	return -EINVAL;
360	}
361
362	uint32_t bench_io_threads;
363	if (vm.count("io-threads")) {
364	bench_io_threads = vm["io-threads"].as<uint32_t>();
365	} else {
366	bench_io_threads = 16;
367	}
368	if (bench_io_threads == 0) {
369	std::cerr << "rbd: --io-threads should be greater than zero." << std::endl;
370	return -EINVAL;
371	}
372
373	uint64_t bench_bytes;
374	if (vm.count("io-total")) {
375	bench_bytes = vm["io-total"].as<uint64_t>();
376	} else {
377	bench_bytes = 1 << 30;
378	}
379
380	bool bench_random;
381	if (vm.count("io-pattern")) {
382	bench_random = vm["io-pattern"].as<bool>();
383	} else {
384	bench_random = false;
385	}
386
387	librados::Rados rados;
388	librados::IoCtx io_ctx;
389	librbd::Image image;
390	r = utils::init_and_open_image(pool_name, image_name, "", "", false, &rados,
391	&io_ctx, &image);
392	if (r < 0) {
393	return r;
394	}
395
396	r = do_bench(image, bench_io_type, bench_io_size, bench_io_threads,
397	bench_bytes, bench_random);
398	if (r < 0) {
399	std::cerr << "bench failed: " << cpp_strerror(r) << std::endl;
400	return r;
401	}
402	return 0;
403	}
404
405	int execute_for_write(const po::variables_map &vm) {
406	std::cerr << "rbd: bench-write is deprecated, use rbd bench --io-type write ..." << std::endl;
407	return bench_execute(vm, IO_TYPE_WRITE);
408	}
409
410	int execute_for_bench(const po::variables_map &vm) {
411	io_type_t bench_io_type;
412	if (vm.count("io-type")) {
413	bench_io_type = vm["io-type"].as<io_type_t>();
414	} else {
415	std::cerr << "rbd: --io-type must be specified." << std::endl;
416	return -EINVAL;
417	}
418
419	return bench_execute(vm, bench_io_type);
420	}
421
422	Shell::Action action_write(
423	{"bench-write"}, {}, "Simple write benchmark. (Deprecated, please use `rbd bench --io-type write` instead.)",
424	"", &get_arguments_for_write, &execute_for_write, false);
425
426	Shell::Action action_bench(
427	{"bench"}, {}, "Simple benchmark.", "", &get_arguments_for_bench, &execute_for_bench);
428
429	} // namespace bench
430	} // namespace action
431	} // namespace rbd