#define MINIMUM_TO_RECOVER 2u
-using namespace std;
-
class ErasureCodeExample final : public ErasureCode {
public:
~ErasureCodeExample() override {}
int create_rule(const std::string &name,
CrushWrapper &crush,
- ostream *ss) const override {
+ std::ostream *ss) const override {
return crush.add_simple_rule(name, "default", "host", "",
"indep", pg_pool_t::TYPE_ERASURE, ss);
}
c2c[CODING_CHUNK] > c2c[SECOND_DATA_CHUNK])
c2c.erase(CODING_CHUNK);
}
- set <int> available_chunks;
+ std::set <int> available_chunks;
for (std::map<int, int>::const_iterator i = c2c.begin();
i != c2c.end();
++i)
// to chunk boundaries
//
const bufferptr &ptr = out.front();
- for (set<int>::iterator j = want_to_encode.begin();
+ for (auto j = want_to_encode.begin();
j != want_to_encode.end();
++j) {
bufferlist tmp;
int _decode(const std::set<int> &want_to_read,
const std::map<int, bufferlist> &chunks,
- std::map<int, bufferlist> *decoded) {
+ std::map<int, bufferlist> *decoded) override {
//
// All chunks have the same size
//
-// -*- mode:C; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph distributed storage system
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
- *
+ *
*/
#include <stdlib.h>
#include "global/global_context.h"
#include "gtest/gtest.h"
+using namespace std;
+
TEST(ErasureCodeExample, chunk_size)
{
ErasureCodeExample example;
#include "erasure-code/ErasureCode.h"
#include "ceph_erasure_code_benchmark.h"
+using std::endl;
+using std::cerr;
+using std::cout;
+using std::map;
+using std::set;
+using std::string;
+using std::stringstream;
+using std::vector;
+
namespace po = boost::program_options;
int ErasureCodeBench::setup(int argc, char** argv) {
}
utime_t begin_time = ceph_clock_now();
for (int i = 0; i < max_iterations; i++) {
- map<int,bufferlist> encoded;
+ std::map<int,bufferlist> encoded;
code = erasure_code->encode(want_to_encode, in, &encoded);
if (code)
return code;
#define CEPH_ERASURE_CODE_BENCHMARK_H
#include <string>
+#include <map>
+#include <vector>
-using namespace std;
+#include <boost/intrusive_ptr.hpp>
+
+#include "include/buffer.h"
+
+#include "common/ceph_context.h"
+
+#include "erasure-code/ErasureCodeInterface.h"
class ErasureCodeBench {
int in_size;
int k;
int m;
- string plugin;
+ std::string plugin;
bool exhaustive_erasures;
- vector<int> erased;
- string workload;
+ std::vector<int> erased;
+ std::string workload;
- ErasureCodeProfile profile;
+ ceph::ErasureCodeProfile profile;
bool verbose;
boost::intrusive_ptr<CephContext> cct;
public:
int setup(int argc, char** argv);
int run();
- int decode_erasures(const map<int,bufferlist> &all_chunks,
- const map<int,bufferlist> &chunks,
+ int decode_erasures(const std::map<int, ceph::buffer::list> &all_chunks,
+ const std::map<int, ceph::buffer::list> &chunks,
unsigned i,
unsigned want_erasures,
ErasureCodeInterfaceRef erasure_code);
#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).
StopWatch sw;
//kv_bench_data data;
KvStoreBench * kvsb;
- bufferlist val;
+ ceph::buffer::list val;
int err;
char op;
{}
};
-typedef pair<string, bufferlist> (KvStoreBench::*next_gen_t)(bool new_elem);
+typedef std::pair<std::string, ceph::buffer::list> (KvStoreBench::*next_gen_t)(bool new_elem);
class KvStoreBench {
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;
+ std::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
+ std::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
+ std::set<std::string> key_set;//set of keys already in the data set
KeyValueStructure * kvs;
kv_bench_data data;//stores throughput and latency from completed tests
ceph::mutex data_lock = ceph::make_mutex("data lock");
ceph::make_mutex("KvStoreBench::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;
+ std::string rados_id;
+ std::string pool_name;
bool io_ctx_ready;
librados::IoCtx io_ctx;
/**
* Returns a string of random characters of length len
*/
- string random_string(int len);
+ std::string random_string(int len);
/**
* Inserts entries random keys and values asynchronously.
* 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);
+ int test_teuthology_aio(next_gen_t distr, const std::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);
+ int test_teuthology_sync(next_gen_t distr, const std::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);
+ std::pair<std::string, ceph::buffer::list> rand_distr(bool new_elem);
/**
* Called when aio operations complete. Updates data.
#include <boost/system/system_error.hpp>
namespace bs = boost::system;
+using namespace std::literals;
using namespace std::placeholders;
namespace neorados {
namespace detail {
-struct Client {
+class Client {
+public:
ceph::mutex mutex = ceph::make_mutex("NeoradosTestStub::Client");
librados::TestRadosClient* test_rados_client;
projects / ceph.git / commitdiff