From 99f27c39b05f2b0b7e29905b1d91b7dc6ec0fbc8 Mon Sep 17 00:00:00 2001 From: shawn Date: Tue, 7 Jun 2016 22:37:02 -0400 Subject: [PATCH] erasure-code: optimize header file dependency Signed-off-by: Xiaowei Chen --- src/erasure-code/ErasureCode.cc | 7 +- src/erasure-code/ErasureCode.h | 56 +++++++------- src/erasure-code/ErasureCodeInterface.h | 55 +++++++------- src/erasure-code/ErasureCodePlugin.cc | 2 + src/erasure-code/ErasureCodePlugin.h | 8 +- src/erasure-code/isa/ErasureCodeIsa.cc | 3 +- src/erasure-code/isa/ErasureCodeIsa.h | 27 +++---- .../isa/ErasureCodeIsaTableCache.cc | 1 - src/erasure-code/isa/ErasureCodePluginIsa.cc | 6 +- src/erasure-code/isa/xor_op.cc | 1 + src/erasure-code/isa/xor_op.h | 1 - .../jerasure/ErasureCodeJerasure.cc | 3 + .../jerasure/ErasureCodeJerasure.h | 44 +++++------ .../jerasure/ErasureCodePluginJerasure.cc | 2 +- src/erasure-code/lrc/ErasureCodeLrc.cc | 2 + src/erasure-code/lrc/ErasureCodeLrc.h | 76 +++++++++---------- src/erasure-code/lrc/ErasureCodePluginLrc.cc | 5 +- .../shec/ErasureCodePluginShec.cc | 2 +- src/erasure-code/shec/ErasureCodeShec.cc | 6 +- src/erasure-code/shec/ErasureCodeShec.h | 2 - .../shec/ErasureCodeShecTableCache.cc | 2 +- src/osd/ECUtil.cc | 1 + src/osd/ECUtil.h | 38 +++++----- 23 files changed, 173 insertions(+), 177 deletions(-) diff --git a/src/erasure-code/ErasureCode.cc b/src/erasure-code/ErasureCode.cc index eaacb246932..353ab4f0d8e 100644 --- a/src/erasure-code/ErasureCode.cc +++ b/src/erasure-code/ErasureCode.cc @@ -16,14 +16,15 @@ */ #include -#include #include -#include + +#include "ErasureCode.h" #include "common/strtol.h" -#include "ErasureCode.h" #include "include/buffer.h" +using namespace std; + const unsigned ErasureCode::SIMD_ALIGN = 32; int ErasureCode::sanity_check_k(int k, ostream *ss) diff --git a/src/erasure-code/ErasureCode.h b/src/erasure-code/ErasureCode.h index 6ca39d6f983..e544b022a12 100644 --- a/src/erasure-code/ErasureCode.h +++ b/src/erasure-code/ErasureCode.h @@ -22,8 +22,6 @@ */ -#include - #include "ErasureCodeInterface.h" namespace ceph { @@ -32,12 +30,12 @@ namespace ceph { public: static const unsigned SIMD_ALIGN; - vector chunk_mapping; + std::vector chunk_mapping; ErasureCodeProfile _profile; ~ErasureCode() override {} - int init(ErasureCodeProfile &profile, ostream *ss) override { + int init(ErasureCodeProfile &profile, std::ostream *ss) override { _profile = profile; return 0; } @@ -46,67 +44,67 @@ namespace ceph { return _profile; } - int sanity_check_k(int k, ostream *ss); + int sanity_check_k(int k, std::ostream *ss); unsigned int get_coding_chunk_count() const override { return get_chunk_count() - get_data_chunk_count(); } - int minimum_to_decode(const set &want_to_read, - const set &available_chunks, - set *minimum) override; + int minimum_to_decode(const std::set &want_to_read, + const std::set &available_chunks, + std::set *minimum) override; - int minimum_to_decode_with_cost(const set &want_to_read, - const map &available, - set *minimum) override; + int minimum_to_decode_with_cost(const std::set &want_to_read, + const std::map &available, + std::set *minimum) override; int encode_prepare(const bufferlist &raw, - map &encoded) const; + std::map &encoded) const; - int encode(const set &want_to_encode, + int encode(const std::set &want_to_encode, const bufferlist &in, - map *encoded) override; + std::map *encoded) override; - int encode_chunks(const set &want_to_encode, - map *encoded) override; + int encode_chunks(const std::set &want_to_encode, + std::map *encoded) override; - int decode(const set &want_to_read, - const map &chunks, - map *decoded) override; + int decode(const std::set &want_to_read, + const std::map &chunks, + std::map *decoded) override; - int decode_chunks(const set &want_to_read, - const map &chunks, - map *decoded) override; + int decode_chunks(const std::set &want_to_read, + const std::map &chunks, + std::map *decoded) override; - const vector &get_chunk_mapping() const override; + const std::vector &get_chunk_mapping() const override; int to_mapping(const ErasureCodeProfile &profile, - ostream *ss); + std::ostream *ss); static int to_int(const std::string &name, ErasureCodeProfile &profile, int *value, const std::string &default_value, - ostream *ss); + std::ostream *ss); static int to_bool(const std::string &name, ErasureCodeProfile &profile, bool *value, const std::string &default_value, - ostream *ss); + std::ostream *ss); static int to_string(const std::string &name, ErasureCodeProfile &profile, std::string *value, const std::string &default_value, - ostream *ss); + std::ostream *ss); - int decode_concat(const map &chunks, + int decode_concat(const std::map &chunks, bufferlist *decoded) override; protected: int parse(const ErasureCodeProfile &profile, - ostream *ss); + std::ostream *ss); private: int chunk_index(unsigned int i) const; diff --git a/src/erasure-code/ErasureCodeInterface.h b/src/erasure-code/ErasureCodeInterface.h index 32c3b1ac2c8..fbe9eea2726 100644 --- a/src/erasure-code/ErasureCodeInterface.h +++ b/src/erasure-code/ErasureCodeInterface.h @@ -143,19 +143,18 @@ #include #include #include -#include -#include "include/memory.h" +#include +#include +#include #include "include/buffer_fwd.h" class CrushWrapper; -using namespace std; - namespace ceph { - typedef map ErasureCodeProfile; + typedef std::map ErasureCodeProfile; - inline ostream& operator<<(ostream& out, const ErasureCodeProfile& profile) { + inline std::ostream& operator<<(std::ostream& out, const ErasureCodeProfile& profile) { out << "{"; for (ErasureCodeProfile::const_iterator it = profile.begin(); it != profile.end(); @@ -186,7 +185,7 @@ namespace ceph { * @param [out] ss contains informative messages when an error occurs * @return 0 on success or a negative errno on error. */ - virtual int init(ErasureCodeProfile &profile, ostream *ss) = 0; + virtual int init(ErasureCodeProfile &profile, std::ostream *ss) = 0; /** * Return the profile that was used to initialize the instance @@ -210,9 +209,9 @@ namespace ceph { * @param [out] ss contains informative messages when an error occurs * @return a ruleset on success or a negative errno on error. */ - virtual int create_ruleset(const string &name, + virtual int create_ruleset(const std::string &name, CrushWrapper &crush, - ostream *ss) const = 0; + std::ostream *ss) const = 0; /** * Return the number of chunks created by a call to the **encode** @@ -284,9 +283,9 @@ namespace ceph { * @param [out] minimum chunk indexes to retrieve * @return **0** on success or a negative errno on error. */ - virtual int minimum_to_decode(const set &want_to_read, - const set &available, - set *minimum) = 0; + virtual int minimum_to_decode(const std::set &want_to_read, + const std::set &available, + std::set *minimum) = 0; /** * Compute the smallest subset of **available** chunks that needs @@ -312,9 +311,9 @@ namespace ceph { * @param [out] minimum chunk indexes to retrieve * @return **0** on success or a negative errno on error. */ - virtual int minimum_to_decode_with_cost(const set &want_to_read, - const map &available, - set *minimum) = 0; + virtual int minimum_to_decode_with_cost(const std::set &want_to_read, + const std::map &available, + std::set *minimum) = 0; /** * Encode the content of **in** and store the result in @@ -351,13 +350,13 @@ namespace ceph { * @param [out] encoded map chunk indexes to chunk data * @return **0** on success or a negative errno on error. */ - virtual int encode(const set &want_to_encode, + virtual int encode(const std::set &want_to_encode, const bufferlist &in, - map *encoded) = 0; + std::map *encoded) = 0; - virtual int encode_chunks(const set &want_to_encode, - map *encoded) = 0; + virtual int encode_chunks(const std::set &want_to_encode, + std::map *encoded) = 0; /** * Decode the **chunks** and store at least **want_to_read** @@ -392,13 +391,13 @@ namespace ceph { * @param [out] decoded map chunk indexes to chunk data * @return **0** on success or a negative errno on error. */ - virtual int decode(const set &want_to_read, - const map &chunks, - map *decoded) = 0; + virtual int decode(const std::set &want_to_read, + const std::map &chunks, + std::map *decoded) = 0; - virtual int decode_chunks(const set &want_to_read, - const map &chunks, - map *decoded) = 0; + virtual int decode_chunks(const std::set &want_to_read, + const std::map &chunks, + std::map *decoded) = 0; /** * Return the ordered list of chunks or an empty vector @@ -433,7 +432,7 @@ namespace ceph { * * @return vector list of indices of chunks to be remapped */ - virtual const vector &get_chunk_mapping() const = 0; + virtual const std::vector &get_chunk_mapping() const = 0; /** * Decode the first **get_data_chunk_count()** **chunks** and @@ -445,11 +444,11 @@ namespace ceph { * @param [out] decoded concatenante of the data chunks * @return **0** on success or a negative errno on error. */ - virtual int decode_concat(const map &chunks, + virtual int decode_concat(const std::map &chunks, bufferlist *decoded) = 0; }; - typedef ceph::shared_ptr ErasureCodeInterfaceRef; + typedef std::shared_ptr ErasureCodeInterfaceRef; } diff --git a/src/erasure-code/ErasureCodePlugin.cc b/src/erasure-code/ErasureCodePlugin.cc index b120eda3a56..026cd3cf632 100644 --- a/src/erasure-code/ErasureCodePlugin.cc +++ b/src/erasure-code/ErasureCodePlugin.cc @@ -23,6 +23,8 @@ #include "common/errno.h" #include "include/str_list.h" +using namespace std; + #define PLUGIN_PREFIX "libec_" #if defined(DARWIN) #define PLUGIN_SUFFIX ".dylib" diff --git a/src/erasure-code/ErasureCodePlugin.h b/src/erasure-code/ErasureCodePlugin.h index 72c187bd01e..a92d0e2cc61 100644 --- a/src/erasure-code/ErasureCodePlugin.h +++ b/src/erasure-code/ErasureCodePlugin.h @@ -39,7 +39,7 @@ namespace ceph { virtual int factory(const std::string &directory, ErasureCodeProfile &profile, ErasureCodeInterfaceRef *erasure_code, - ostream *ss) = 0; + std::ostream *ss) = 0; }; class ErasureCodePluginRegistry { @@ -62,7 +62,7 @@ namespace ceph { const std::string &directory, ErasureCodeProfile &profile, ErasureCodeInterfaceRef *erasure_code, - ostream *ss); + std::ostream *ss); int add(const std::string &name, ErasureCodePlugin *plugin); int remove(const std::string &name); @@ -71,11 +71,11 @@ namespace ceph { int load(const std::string &plugin_name, const std::string &directory, ErasureCodePlugin **plugin, - ostream *ss); + std::ostream *ss); int preload(const std::string &plugins, const std::string &directory, - ostream *ss); + std::ostream *ss); }; } diff --git a/src/erasure-code/isa/ErasureCodeIsa.cc b/src/erasure-code/isa/ErasureCodeIsa.cc index 0d69e8cb7bb..3c8c03eae25 100644 --- a/src/erasure-code/isa/ErasureCodeIsa.cc +++ b/src/erasure-code/isa/ErasureCodeIsa.cc @@ -14,7 +14,6 @@ // ----------------------------------------------------------------------------- #include -#include #include // ----------------------------------------------------------------------------- #include "common/debug.h" @@ -22,6 +21,8 @@ #include "xor_op.h" #include "crush/CrushWrapper.h" #include "osd/osd_types.h" +using namespace std; + // ----------------------------------------------------------------------------- extern "C" { #include "isa-l/include/erasure_code.h" diff --git a/src/erasure-code/isa/ErasureCodeIsa.h b/src/erasure-code/isa/ErasureCodeIsa.h index 17ba4ff30e0..ccf8d8437ce 100644 --- a/src/erasure-code/isa/ErasureCodeIsa.h +++ b/src/erasure-code/isa/ErasureCodeIsa.h @@ -26,12 +26,9 @@ #define CEPH_ERASURE_CODE_ISA_L_H // ----------------------------------------------------------------------------- -#include "common/Mutex.h" #include "erasure-code/ErasureCode.h" #include "ErasureCodeIsaTableCache.h" // ----------------------------------------------------------------------------- -#include -// ----------------------------------------------------------------------------- #define DEFAULT_RULESET_ROOT "default" #define DEFAULT_RULESET_FAILURE_DOMAIN "host" @@ -49,8 +46,8 @@ public: ErasureCodeIsaTableCache &tcache; const char *technique; - string ruleset_root; - string ruleset_failure_domain; + std::string ruleset_root; + std::string ruleset_failure_domain; ErasureCodeIsa(const char *_technique, ErasureCodeIsaTableCache &_tcache) : @@ -69,9 +66,9 @@ public: { } - int create_ruleset(const string &name, + int create_ruleset(const std::string &name, CrushWrapper &crush, - ostream *ss) const override; + std::ostream *ss) const override; unsigned int get_chunk_count() const override @@ -87,14 +84,14 @@ public: unsigned int get_chunk_size(unsigned int object_size) const override; - int encode_chunks(const set &want_to_encode, - map *encoded) override; + int encode_chunks(const std::set &want_to_encode, + std::map *encoded) override; - int decode_chunks(const set &want_to_read, - const map &chunks, - map *decoded) override; + int decode_chunks(const std::set &want_to_read, + const std::map &chunks, + std::map *decoded) override; - int init(ErasureCodeProfile &profile, ostream *ss) override; + int init(ErasureCodeProfile &profile, std::ostream *ss) override; virtual void isa_encode(char **data, char **coding, @@ -112,7 +109,7 @@ public: private: virtual int parse(ErasureCodeProfile &profile, - ostream *ss) = 0; + std::ostream *ss) = 0; }; // ----------------------------------------------------------------------------- @@ -161,7 +158,7 @@ public: private: int parse(ErasureCodeProfile &profile, - ostream *ss) override; + std::ostream *ss) override; }; #endif diff --git a/src/erasure-code/isa/ErasureCodeIsaTableCache.cc b/src/erasure-code/isa/ErasureCodeIsaTableCache.cc index 951f7d08308..a4d20a6fb17 100644 --- a/src/erasure-code/isa/ErasureCodeIsaTableCache.cc +++ b/src/erasure-code/isa/ErasureCodeIsaTableCache.cc @@ -25,7 +25,6 @@ // ----------------------------------------------------------------------------- #include "ErasureCodeIsaTableCache.h" -#include "ErasureCodeIsa.h" #include "common/debug.h" // ----------------------------------------------------------------------------- diff --git a/src/erasure-code/isa/ErasureCodePluginIsa.cc b/src/erasure-code/isa/ErasureCodePluginIsa.cc index 1e95b0bc6a8..34b372a56c5 100644 --- a/src/erasure-code/isa/ErasureCodePluginIsa.cc +++ b/src/erasure-code/isa/ErasureCodePluginIsa.cc @@ -25,15 +25,15 @@ // ----------------------------------------------------------------------------- #include "ceph_ver.h" -#include "common/debug.h" #include "ErasureCodePluginIsa.h" +#include "ErasureCodeIsaTableCache.h" #include "ErasureCodeIsa.h" // ----------------------------------------------------------------------------- int ErasureCodePluginIsa::factory(const std::string &directory, ErasureCodeProfile &profile, ErasureCodeInterfaceRef *erasure_code, - ostream *ss) + std::ostream *ss) { ErasureCodeIsa *interface; std::string t; @@ -83,4 +83,4 @@ int __erasure_code_init(char *plugin_name, char *directory) return instance.add(plugin_name, new ErasureCodePluginIsa()); } -#endif \ No newline at end of file +#endif diff --git a/src/erasure-code/isa/xor_op.cc b/src/erasure-code/isa/xor_op.cc index 358ce4a5e84..be0071d8fa9 100644 --- a/src/erasure-code/isa/xor_op.cc +++ b/src/erasure-code/isa/xor_op.cc @@ -13,6 +13,7 @@ // ----------------------------------------------------------------------------- #include "xor_op.h" #include +#include #include "arch/intel.h" // ----------------------------------------------------------------------------- diff --git a/src/erasure-code/isa/xor_op.h b/src/erasure-code/isa/xor_op.h index 9dc70614262..978b9a95358 100644 --- a/src/erasure-code/isa/xor_op.h +++ b/src/erasure-code/isa/xor_op.h @@ -18,7 +18,6 @@ // ----------------------------------------------------------------------------- #include #include -#include // ----------------------------------------------------------------------------- // ------------------------------------------------------------------------- diff --git a/src/erasure-code/jerasure/ErasureCodeJerasure.cc b/src/erasure-code/jerasure/ErasureCodeJerasure.cc index 1d411b9c247..8d73a16421b 100644 --- a/src/erasure-code/jerasure/ErasureCodeJerasure.cc +++ b/src/erasure-code/jerasure/ErasureCodeJerasure.cc @@ -19,6 +19,9 @@ #include "ErasureCodeJerasure.h" #include "crush/CrushWrapper.h" #include "osd/osd_types.h" + +using namespace std; + extern "C" { #include "jerasure.h" #include "reed_sol.h" diff --git a/src/erasure-code/jerasure/ErasureCodeJerasure.h b/src/erasure-code/jerasure/ErasureCodeJerasure.h index da341175ecc..5696c6e90c4 100644 --- a/src/erasure-code/jerasure/ErasureCodeJerasure.h +++ b/src/erasure-code/jerasure/ErasureCodeJerasure.h @@ -32,8 +32,8 @@ public: int w; std::string DEFAULT_W; const char *technique; - string ruleset_root; - string ruleset_failure_domain; + std::string ruleset_root; + std::string ruleset_failure_domain; bool per_chunk_alignment; explicit ErasureCodeJerasure(const char *_technique) : @@ -51,9 +51,9 @@ public: ~ErasureCodeJerasure() override {} - int create_ruleset(const string &name, + int create_ruleset(const std::string &name, CrushWrapper &crush, - ostream *ss) const override; + std::ostream *ss) const override; unsigned int get_chunk_count() const override { return k + m; @@ -65,14 +65,14 @@ public: unsigned int get_chunk_size(unsigned int object_size) const override; - int encode_chunks(const set &want_to_encode, - map *encoded) override; + int encode_chunks(const std::set &want_to_encode, + std::map *encoded) override; - int decode_chunks(const set &want_to_read, - const map &chunks, - map *decoded) override; + int decode_chunks(const std::set &want_to_read, + const std::map &chunks, + std::map *decoded) override; - int init(ErasureCodeProfile &profile, ostream *ss) override; + int init(ErasureCodeProfile &profile, std::ostream *ss) override; virtual void jerasure_encode(char **data, char **coding, @@ -85,7 +85,7 @@ public: virtual void prepare() = 0; static bool is_prime(int value); protected: - virtual int parse(ErasureCodeProfile &profile, ostream *ss); + virtual int parse(ErasureCodeProfile &profile, std::ostream *ss); }; class ErasureCodeJerasureReedSolomonVandermonde : public ErasureCodeJerasure { @@ -115,7 +115,7 @@ public: unsigned get_alignment() const override; void prepare() override; private: - int parse(ErasureCodeProfile &profile, ostream *ss) override; + int parse(ErasureCodeProfile &profile, std::ostream *ss) override; }; class ErasureCodeJerasureReedSolomonRAID6 : public ErasureCodeJerasure { @@ -144,7 +144,7 @@ public: unsigned get_alignment() const override; void prepare() override; private: - int parse(ErasureCodeProfile &profile, ostream *ss) override; + int parse(ErasureCodeProfile &profile, std::ostream *ss) override; }; #define DEFAULT_PACKETSIZE "2048" @@ -182,7 +182,7 @@ public: unsigned get_alignment() const override; void prepare_schedule(int *matrix); private: - int parse(ErasureCodeProfile &profile, ostream *ss) override; + int parse(ErasureCodeProfile &profile, std::ostream *ss) override; }; class ErasureCodeJerasureCauchyOrig : public ErasureCodeJerasureCauchy { @@ -229,15 +229,15 @@ public: char **coding, int blocksize) override; unsigned get_alignment() const override; - virtual bool check_k(ostream *ss) const; - virtual bool check_w(ostream *ss) const; - virtual bool check_packetsize_set(ostream *ss) const; - virtual bool check_packetsize(ostream *ss) const; + virtual bool check_k(std::ostream *ss) const; + virtual bool check_w(std::ostream *ss) const; + virtual bool check_packetsize_set(std::ostream *ss) const; + virtual bool check_packetsize(std::ostream *ss) const; virtual int revert_to_default(ErasureCodeProfile &profile, - ostream *ss); + std::ostream *ss); void prepare() override; private: - int parse(ErasureCodeProfile &profile, ostream *ss) override; + int parse(ErasureCodeProfile &profile, std::ostream *ss) override; }; class ErasureCodeJerasureBlaumRoth : public ErasureCodeJerasureLiberation { @@ -247,7 +247,7 @@ public: { } - bool check_w(ostream *ss) const override; + bool check_w(std::ostream *ss) const override; void prepare() override; }; @@ -263,7 +263,7 @@ public: void prepare() override; private: - int parse(ErasureCodeProfile &profile, ostream *ss) override; + int parse(ErasureCodeProfile &profile, std::ostream *ss) override; }; #endif diff --git a/src/erasure-code/jerasure/ErasureCodePluginJerasure.cc b/src/erasure-code/jerasure/ErasureCodePluginJerasure.cc index ac6923e3366..38f403826e7 100644 --- a/src/erasure-code/jerasure/ErasureCodePluginJerasure.cc +++ b/src/erasure-code/jerasure/ErasureCodePluginJerasure.cc @@ -34,7 +34,7 @@ static ostream& _prefix(std::ostream* _dout) int ErasureCodePluginJerasure::factory(const std::string& directory, ErasureCodeProfile &profile, ErasureCodeInterfaceRef *erasure_code, - ostream *ss) { + std::ostream *ss) { ErasureCodeJerasure *interface; std::string t; if (profile.find("technique") != profile.end()) diff --git a/src/erasure-code/lrc/ErasureCodeLrc.cc b/src/erasure-code/lrc/ErasureCodeLrc.cc index a60fa6e0861..52dc2d87934 100644 --- a/src/erasure-code/lrc/ErasureCodeLrc.cc +++ b/src/erasure-code/lrc/ErasureCodeLrc.cc @@ -36,6 +36,8 @@ #undef dout_prefix #define dout_prefix _prefix(_dout) +using namespace std; + static ostream& _prefix(std::ostream* _dout) { return *_dout << "ErasureCodeLrc: "; diff --git a/src/erasure-code/lrc/ErasureCodeLrc.h b/src/erasure-code/lrc/ErasureCodeLrc.h index c12a8ad353d..fac4d54a5ab 100644 --- a/src/erasure-code/lrc/ErasureCodeLrc.h +++ b/src/erasure-code/lrc/ErasureCodeLrc.h @@ -46,33 +46,33 @@ class ErasureCodeLrc : public ErasureCode { public: - static const string DEFAULT_KML; + static const std::string DEFAULT_KML; struct Layer { - explicit Layer(string _chunks_map) : chunks_map(_chunks_map) { } + explicit Layer(std::string _chunks_map) : chunks_map(_chunks_map) { } ErasureCodeInterfaceRef erasure_code; - vector data; - vector coding; - vector chunks; - set chunks_as_set; - string chunks_map; + std::vector data; + std::vector coding; + std::vector chunks; + std::set chunks_as_set; + std::string chunks_map; ErasureCodeProfile profile; }; - vector layers; - string directory; + std::vector layers; + std::string directory; unsigned int chunk_count; unsigned int data_chunk_count; - string ruleset_root; + std::string ruleset_root; struct Step { - Step(string _op, string _type, int _n) : + Step(std::string _op, std::string _type, int _n) : op(_op), type(_type), n(_n) {} - string op; - string type; + std::string op; + std::string type; int n; }; - vector ruleset_steps; + std::vector ruleset_steps; explicit ErasureCodeLrc(const std::string &dir) : directory(dir), @@ -83,16 +83,16 @@ public: ~ErasureCodeLrc() override {} - set get_erasures(const set &need, - const set &available) const; + std::set get_erasures(const std::set &need, + const std::set &available) const; - int minimum_to_decode(const set &want_to_read, - const set &available, - set *minimum) override; + int minimum_to_decode(const std::set &want_to_read, + const std::set &available, + std::set *minimum) override; - int create_ruleset(const string &name, + int create_ruleset(const std::string &name, CrushWrapper &crush, - ostream *ss) const override; + std::ostream *ss) const override; unsigned int get_chunk_count() const override { return chunk_count; @@ -104,34 +104,34 @@ public: unsigned int get_chunk_size(unsigned int object_size) const override; - int encode_chunks(const set &want_to_encode, - map *encoded) override; + int encode_chunks(const std::set &want_to_encode, + std::map *encoded) override; - int decode_chunks(const set &want_to_read, - const map &chunks, - map *decoded) override; + int decode_chunks(const std::set &want_to_read, + const std::map &chunks, + std::map *decoded) override; - int init(ErasureCodeProfile &profile, ostream *ss) override; + int init(ErasureCodeProfile &profile, std::ostream *ss) override; - virtual int parse(ErasureCodeProfile &profile, ostream *ss); + virtual int parse(ErasureCodeProfile &profile, std::ostream *ss); - int parse_kml(ErasureCodeProfile &profile, ostream *ss); + int parse_kml(ErasureCodeProfile &profile, std::ostream *ss); - int parse_ruleset(ErasureCodeProfile &profile, ostream *ss); + int parse_ruleset(ErasureCodeProfile &profile, std::ostream *ss); - int parse_ruleset_step(string description_string, + int parse_ruleset_step(std::string description_string, json_spirit::mArray description, - ostream *ss); + std::ostream *ss); int layers_description(const ErasureCodeProfile &profile, json_spirit::mArray *description, - ostream *ss) const; - int layers_parse(string description_string, + std::ostream *ss) const; + int layers_parse(std::string description_string, json_spirit::mArray description, - ostream *ss); - int layers_init(ostream *ss); - int layers_sanity_checks(string description_string, - ostream *ss) const; + std::ostream *ss); + int layers_init(std::ostream *ss); + int layers_sanity_checks(std::string description_string, + std::ostream *ss) const; }; #endif diff --git a/src/erasure-code/lrc/ErasureCodePluginLrc.cc b/src/erasure-code/lrc/ErasureCodePluginLrc.cc index c2be14b016a..b5699cd74b2 100644 --- a/src/erasure-code/lrc/ErasureCodePluginLrc.cc +++ b/src/erasure-code/lrc/ErasureCodePluginLrc.cc @@ -20,9 +20,6 @@ #include "ErasureCodePluginLrc.h" #include "ErasureCodeLrc.h" -// re-include our assert -#include "include/assert.h" - #define dout_subsys ceph_subsys_osd #undef dout_prefix #define dout_prefix _prefix(_dout) @@ -30,7 +27,7 @@ int ErasureCodePluginLrc::factory(const std::string &directory, ErasureCodeProfile &profile, ErasureCodeInterfaceRef *erasure_code, - ostream *ss) { + std::ostream *ss) { ErasureCodeLrc *interface; interface = new ErasureCodeLrc(directory); int r = interface->init(profile, ss); diff --git a/src/erasure-code/shec/ErasureCodePluginShec.cc b/src/erasure-code/shec/ErasureCodePluginShec.cc index ded31692f50..eb967f8d463 100644 --- a/src/erasure-code/shec/ErasureCodePluginShec.cc +++ b/src/erasure-code/shec/ErasureCodePluginShec.cc @@ -39,7 +39,7 @@ static ostream& _prefix(std::ostream* _dout) int ErasureCodePluginShec::factory(const std::string &directory, ErasureCodeProfile &profile, ErasureCodeInterfaceRef *erasure_code, - ostream *ss) { + std::ostream *ss) { ErasureCodeShec *interface; if (profile.find("technique") == profile.end()) diff --git a/src/erasure-code/shec/ErasureCodeShec.cc b/src/erasure-code/shec/ErasureCodeShec.cc index 139b7b9e804..f8e7a52949f 100644 --- a/src/erasure-code/shec/ErasureCodeShec.cc +++ b/src/erasure-code/shec/ErasureCodeShec.cc @@ -23,6 +23,8 @@ #include #include #include +using namespace std; + #include "common/debug.h" #include "ErasureCodeShec.h" #include "crush/CrushWrapper.h" @@ -63,10 +65,10 @@ int ErasureCodeShec::init(ErasureCodeProfile &profile, ostream *ss) { int err = 0; - err |= to_string("ruleset-root", profile, + err |= ErasureCode::to_string("ruleset-root", profile, &ruleset_root, DEFAULT_RULESET_ROOT, ss); - err |= to_string("ruleset-failure-domain", profile, + err |= ErasureCode::to_string("ruleset-failure-domain", profile, &ruleset_failure_domain, DEFAULT_RULESET_FAILURE_DOMAIN, ss); err |= parse(profile); diff --git a/src/erasure-code/shec/ErasureCodeShec.h b/src/erasure-code/shec/ErasureCodeShec.h index b3c46014637..2974bce9d38 100644 --- a/src/erasure-code/shec/ErasureCodeShec.h +++ b/src/erasure-code/shec/ErasureCodeShec.h @@ -21,10 +21,8 @@ #ifndef CEPH_ERASURE_CODE_SHEC_H #define CEPH_ERASURE_CODE_SHEC_H -#include "common/Mutex.h" #include "erasure-code/ErasureCode.h" #include "ErasureCodeShecTableCache.h" -#include #define DEFAULT_RULESET_ROOT "default" #define DEFAULT_RULESET_FAILURE_DOMAIN "host" diff --git a/src/erasure-code/shec/ErasureCodeShecTableCache.cc b/src/erasure-code/shec/ErasureCodeShecTableCache.cc index 6f0c1d83c8a..891cada6432 100644 --- a/src/erasure-code/shec/ErasureCodeShecTableCache.cc +++ b/src/erasure-code/shec/ErasureCodeShecTableCache.cc @@ -19,9 +19,9 @@ // ----------------------------------------------------------------------------- #include "ErasureCodeShecTableCache.h" -#include "ErasureCodeShec.h" #include "common/debug.h" // ----------------------------------------------------------------------------- +using namespace std; // ----------------------------------------------------------------------------- #define dout_context g_ceph_context diff --git a/src/osd/ECUtil.cc b/src/osd/ECUtil.cc index 6e046526eda..9c3c7981ea3 100644 --- a/src/osd/ECUtil.cc +++ b/src/osd/ECUtil.cc @@ -3,6 +3,7 @@ #include #include "include/encoding.h" #include "ECUtil.h" +using namespace std; int ECUtil::decode( const stripe_info_t &sinfo, diff --git a/src/osd/ECUtil.h b/src/osd/ECUtil.h index 4ca6f550bee..1b00a095f68 100644 --- a/src/osd/ECUtil.h +++ b/src/osd/ECUtil.h @@ -15,10 +15,6 @@ #ifndef ECUTIL_H #define ECUTIL_H -#include -#include - -#include "include/memory.h" #include "erasure-code/ErasureCodeInterface.h" #include "include/buffer_fwd.h" #include "include/assert.h" @@ -72,43 +68,43 @@ public: assert(offset % chunk_size == 0); return (offset / chunk_size) * stripe_width; } - pair aligned_offset_len_to_chunk( - pair in) const { - return make_pair( + std::pair aligned_offset_len_to_chunk( + std::pair in) const { + return std::make_pair( aligned_logical_offset_to_chunk_offset(in.first), aligned_logical_offset_to_chunk_offset(in.second)); } - pair offset_len_to_stripe_bounds( - pair in) const { + std::pair offset_len_to_stripe_bounds( + std::pair in) const { uint64_t off = logical_to_prev_stripe_offset(in.first); uint64_t len = logical_to_next_stripe_offset( (in.first - off) + in.second); - return make_pair(off, len); + return std::make_pair(off, len); } }; int decode( const stripe_info_t &sinfo, ErasureCodeInterfaceRef &ec_impl, - map &to_decode, + std::map &to_decode, bufferlist *out); int decode( const stripe_info_t &sinfo, ErasureCodeInterfaceRef &ec_impl, - map &to_decode, - map &out); + std::map &to_decode, + std::map &out); int encode( const stripe_info_t &sinfo, ErasureCodeInterfaceRef &ec_impl, bufferlist &in, - const set &want, - map *out); + const std::set &want, + std::map *out); class HashInfo { uint64_t total_chunk_size = 0; - vector cumulative_shard_hashes; + std::vector cumulative_shard_hashes; // purely ephemeral, represents the size once all in-flight ops commit uint64_t projected_total_chunk_size = 0; @@ -116,17 +112,17 @@ public: HashInfo() {} explicit HashInfo(unsigned num_chunks) : cumulative_shard_hashes(num_chunks, -1) {} - void append(uint64_t old_size, map &to_append); + void append(uint64_t old_size, std::map &to_append); void clear() { total_chunk_size = 0; - cumulative_shard_hashes = vector( + cumulative_shard_hashes = std::vector( cumulative_shard_hashes.size(), -1); } void encode(bufferlist &bl) const; void decode(bufferlist::iterator &bl); void dump(Formatter *f) const; - static void generate_test_instances(list& o); + static void generate_test_instances(std::list& o); uint32_t get_chunk_hash(int shard) const { assert((unsigned)shard < cumulative_shard_hashes.size()); return cumulative_shard_hashes[shard]; @@ -168,8 +164,8 @@ public: typedef ceph::shared_ptr HashInfoRef; -bool is_hinfo_key_string(const string &key); -const string &get_hinfo_key(); +bool is_hinfo_key_string(const std::string &key); +const std::string &get_hinfo_key(); } WRITE_CLASS_ENCODER(ECUtil::HashInfo)