--- /dev/null
+/*
+ * Benchmarking suite for key-value store
+ *
+ * September 2, 2012
+ * Eleanor Cawthon
+ * eleanor.cawthon@inktank.com
+ *
+ * This is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License version 2.1, as published by the Free Software
+ * Foundation. See file COPYING.
+ */
+
+#ifndef KVSTOREBENCH_H_
+#define KVSTOREBENCH_H_
+
+#include "key_value_store/key_value_structure.h"
+#include "key_value_store/kv_flat_btree_async.h"
+#include "common/Clock.h"
+#include "global/global_context.h"
+#include "common/Mutex.h"
+#include "common/Cond.h"
+
+#include <string>
+#include <climits>
+#include <cfloat>
+#include <iostream>
+
+using namespace std;
+using ceph::bufferlist;
+
+/**
+ * stores pairings from op type to time taken for that op (for latency), and to
+ * time that op completed to the nearest second (for throughput).
+ */
+struct kv_bench_data {
+ JSONFormatter throughput_jf;
+
+ JSONFormatter latency_jf;
+};
+
+class KvStoreBench;
+
+/**
+ * keeps track of the number of milliseconds between two events - used to
+ * measure latency
+ */
+struct StopWatch {
+ utime_t begin_time;
+ utime_t end_time;
+
+ void start_time() {
+ begin_time = ceph_clock_now();
+ }
+ void stop_time() {
+ end_time = ceph_clock_now();
+ }
+ double get_time() {
+ return (end_time - begin_time) * 1000;
+ }
+ void clear() {
+ begin_time = end_time = utime_t();
+ }
+};
+
+/**
+ * arguments passed to the callback method when the op is being timed
+ */
+struct timed_args {
+ StopWatch sw;
+ //kv_bench_data data;
+ KvStoreBench * kvsb;
+ bufferlist val;
+ int err;
+ char op;
+
+ timed_args ()
+ : kvsb(NULL),
+ err(0),
+ op(' ')
+ {};
+
+ timed_args (KvStoreBench * k)
+ : kvsb(k),
+ err(0),
+ op(' ')
+ {}
+};
+
+typedef pair<string, bufferlist> (KvStoreBench::*next_gen_t)(bool new_elem);
+
+class KvStoreBench {
+
+protected:
+
+ //test setup variables set from command line
+ int entries; //the number of entries to write initially
+ int ops; //the number of operations to time
+ int clients; //the total number of clients running this test - used
+ //in the aio test to coordinate the end of the initial sets
+ int key_size;//number of characters in keys to write
+ int val_size;//number of characters in values to write
+ int max_ops_in_flight;
+ bool clear_first;//if true, remove all objects in pool before starting tests
+
+ //variables passed to KeyValueStructure
+ int k;
+ int cache_size; //number of index entries to store in cache
+ double cache_refresh; //cache_size / cache_refresh entries are read each time
+ //the index is read
+ string client_name;
+ bool verbose;//if true, display debug output
+
+ //internal
+ map<int, char> probs;//map of numbers from 1 to 100 to chars representing
+ //operation types - used to generate random operations
+ set<string> key_set;//set of keys already in the data set
+ KeyValueStructure * kvs;
+ kv_bench_data data;//stores throughput and latency from completed tests
+ Mutex data_lock;
+ Cond op_avail;//signaled when an op completes
+ int ops_in_flight;//number of operations currently in progress
+ Mutex ops_in_flight_lock;
+ //these are used for cleanup and setup purposes - they are NOT passed to kvs!
+ librados::Rados rados;
+ string rados_id;
+ string pool_name;
+ bool io_ctx_ready;
+ librados::IoCtx io_ctx;
+
+ /**
+ * Prints JSON-formatted throughput and latency data.
+ *
+ * Throughput data is {'char representing the operation type':time the op
+ * completed to the nearest second}
+ * Latency is {'char representing the operation type':time taken by the op}
+ */
+ void print_time_data();
+
+public:
+
+ KvStoreBench();
+
+ //after this is called, objects created by the KeyValueStructure remain.
+ ~KvStoreBench();
+
+ /**
+ * parses command line arguments, sets up this rados instance, clears the
+ * pool if clear_first is true and calls kvs->setup.
+ */
+ int setup(int argc, const char** argv);
+
+ /**
+ * Returns a string of random characters of length len
+ */
+ string random_string(int len);
+
+ /**
+ * Inserts entries random keys and values asynchronously.
+ */
+ int test_random_insertions();
+
+ /**
+ * calls test_random_insertions, then does ops randomly chosen operations
+ * asynchronously, with max_ops_in_flight operations at a time.
+ */
+ int test_teuthology_aio(next_gen_t distr, const map<int, char> &probs);
+
+ /**
+ * calls test_random_insertions, then does ops randomly chosen operations
+ * synchronously.
+ */
+ int test_teuthology_sync(next_gen_t distr, const map<int, char> &probs);
+
+ /**
+ * returns a key-value pair. If new_elem is true, the key is randomly
+ * generated. If it is false, the key is selected from the keys currently in
+ * the key set.
+ */
+ pair<string, bufferlist> rand_distr(bool new_elem);
+
+ /**
+ * Called when aio operations complete. Updates data.
+ */
+ static void aio_callback_timed(int * err, void *arg);
+
+ /**
+ * Calls test_ methods. Change to call, for example, multiple runs of a test
+ * with different settings. Currently just calls test_teuthology_aio.
+ */
+ int teuthology_tests();
+
+};
+
+#endif /* KVSTOREBENCH_H_ */
Code Review / stor4nfv.git / blobdiff