erasure-code: Add optimization flags for plugins

Add flags to erasure code plugins to report supported optimizations
and new unittest_erasure_code_plugins to test these flags for many
permutations of plugins and profiles.

Signed-off-by: Bill Scales <[email protected]>

[Taken from Bill's fork with permission]
Signed-off-by: Jamie Pryde <[email protected]>

Author: jamiepryde

src/erasure-code/ErasureCodeInterface.h

@@ -476,6 +476,78 @@ namespace ceph {
     virtual int decode_concat(const std::map<int, bufferlist> &chunks,
 			      bufferlist *decoded) = 0;
 
+  	using plugin_flags = uint64_t;
+
+    /**
+     * Return a set of flags indicating which EC optimizations are supported
+     * by the plugin.
+     *
+     * @return logical OR of the supported performance optimizations
+     */
+    virtual plugin_flags get_supported_optimizations() const = 0;
+    enum {
+      /* Partial read optimization assumes that the erasure code is systematic
+       * and that concatenating the data chunks in the order returned by
+       * get_chunk_mapping will create the data encoded for a stripe. The
+       * optimization permits small reads to read data directly from the data
+       * chunks without calling decode.
+       */
+      FLAG_EC_PLUGIN_PARTIAL_READ_OPTIMIZATION = 1<<0,
+      /* Partial write optimization assumes that a write to less than one
+       * chunk only needs to read this fragment from each data chunk in the
+       * stripe and can then use encode to create the corresponding coding
+       * fragments.
+       */
+      FLAG_EC_PLUGIN_PARTIAL_WRITE_OPTIMIZATION = 1<<1,
+      /* Zero input zero output optimization means the erasure code has the
+       * property that if all the data chunks are zero then the coding parity
+       * chunks will also be zero.
+       */
+      FLAG_EC_PLUGIN_ZERO_INPUT_ZERO_OUTPUT_OPTIMIZATION = 1<<2,
+      /* Zero padding optimization permits the encode and decode methods to
+       * be called with buffers that are zero length. The plugin treats
+       * this as a chunk of all zeros.
+       */
+      FLAG_EC_PLUGIN_ZERO_PADDING_OPTIMIZATION = 1<<3,
+      /* Parity delta write optimization means the encode_delta and
+       * apply_delta methods are supported which allows small updates
+       * to a stripe to be applied using a read-modify-write of a
+       * data chunk and the coding parity chunks.
+       */
+      FLAG_EC_PLUGIN_PARITY_DELTA_OPTIMIZATION = 1<<4,
+    };
+    static const char *get_optimization_flag_name(const plugin_flags flag) {
+      switch (flag) {
+      case FLAG_EC_PLUGIN_PARTIAL_READ_OPTIMIZATION: return "partialread";
+      case FLAG_EC_PLUGIN_PARTIAL_WRITE_OPTIMIZATION: return "partialwrite";
+      case FLAG_EC_PLUGIN_ZERO_INPUT_ZERO_OUTPUT_OPTIMIZATION: return "zeroinout";
+      case FLAG_EC_PLUGIN_ZERO_PADDING_OPTIMIZATION: return "zeropadding";
+      case FLAG_EC_PLUGIN_PARITY_DELTA_OPTIMIZATION: return "paritydelta";
+      default: return "???";
+      }
+    }
+    static std::string get_optimization_flags_string(plugin_flags flags) {
+      std::string s;
+      for (unsigned n=0; flags && n<64; ++n) {
+      	if (flags & (1ull << n)) {
+			if (s.length())
+				s += ",";
+			s += get_optimization_flag_name(1ull << n);
+			flags -= flags & (1ull << n);
+		}
+      }
+      return s;
+    }
+
+    /**
+     * Return a string describing which EC optimizations are supported
+     * by the plugin.
+     *
+     * @return string of optimizations supported by the plugin
+     */
+    virtual std::string get_optimizations_flags_string() const {
+      return get_optimization_flags_string(get_supported_optimizations());
+    }
   };
 
   typedef std::shared_ptr<ErasureCodeInterface> ErasureCodeInterfaceRef;

src/erasure-code/clay/ErasureCodeClay.h

@@ -46,6 +46,18 @@ class ErasureCodeClay final : public ceph::ErasureCode {
 
   ~ErasureCodeClay() override;
 
+  uint64_t get_supported_optimizations() const override {
+    if (m == 1) {
+      // PARTIAL_WRITE optimization can be supported in
+      // the corner case of m = 1
+      return FLAG_EC_PLUGIN_PARTIAL_READ_OPTIMIZATION |
+	FLAG_EC_PLUGIN_PARTIAL_WRITE_OPTIMIZATION |
+	FLAG_EC_PLUGIN_ZERO_INPUT_ZERO_OUTPUT_OPTIMIZATION;
+    }
+    return FLAG_EC_PLUGIN_PARTIAL_READ_OPTIMIZATION |
+      FLAG_EC_PLUGIN_ZERO_INPUT_ZERO_OUTPUT_OPTIMIZATION;
+  }
+
   unsigned int get_chunk_count() const override {
     return k+m;
   }

src/erasure-code/isa/ErasureCodeIsa.h

@@ -64,6 +64,12 @@ class ErasureCodeIsa : public ceph::ErasureCode {
   {
   }
 
+  uint64_t get_supported_optimizations() const override {
+    return FLAG_EC_PLUGIN_PARTIAL_READ_OPTIMIZATION |
+      FLAG_EC_PLUGIN_PARTIAL_WRITE_OPTIMIZATION |
+      FLAG_EC_PLUGIN_ZERO_INPUT_ZERO_OUTPUT_OPTIMIZATION;
+  }
+
   unsigned int
   get_chunk_count() const override
   {

src/erasure-code/jerasure/ErasureCodeJerasure.h

@@ -45,6 +45,13 @@ class ErasureCodeJerasure : public ceph::ErasureCode {
   {}
 
   ~ErasureCodeJerasure() override {}
+
+  uint64_t get_supported_optimizations() const override {
+    return FLAG_EC_PLUGIN_PARTIAL_READ_OPTIMIZATION |
+      FLAG_EC_PLUGIN_PARTIAL_WRITE_OPTIMIZATION |
+      FLAG_EC_PLUGIN_ZERO_INPUT_ZERO_OUTPUT_OPTIMIZATION;
+  }
+
 
   unsigned int get_chunk_count() const override {
     return k + m;

src/erasure-code/lrc/ErasureCodeLrc.h

@@ -95,6 +95,12 @@ class ErasureCodeLrc final : public ceph::ErasureCode {
 			     CrushWrapper &crush,
 			     std::ostream *ss) const override;
 
+  uint64_t get_supported_optimizations() const override {
+    return FLAG_EC_PLUGIN_PARTIAL_READ_OPTIMIZATION |
+      FLAG_EC_PLUGIN_PARTIAL_WRITE_OPTIMIZATION |
+      FLAG_EC_PLUGIN_ZERO_INPUT_ZERO_OUTPUT_OPTIMIZATION;
+  }
+
   unsigned int get_chunk_count() const override {
     return chunk_count;
   }

src/erasure-code/shec/ErasureCodeShec.h

@@ -61,6 +61,12 @@ class ErasureCodeShec : public ceph::ErasureCode {
 
   ~ErasureCodeShec() override {}
 
+  uint64_t get_supported_optimizations() const override {
+    return FLAG_EC_PLUGIN_PARTIAL_READ_OPTIMIZATION |
+      FLAG_EC_PLUGIN_PARTIAL_WRITE_OPTIMIZATION |
+      FLAG_EC_PLUGIN_ZERO_INPUT_ZERO_OUTPUT_OPTIMIZATION;
+  }
+
   unsigned int get_chunk_count() const override {
     return k + m;
   }

src/test/erasure-code/CMakeLists.txt

@@ -62,6 +62,25 @@ target_link_libraries(unittest_erasure_code
   ceph-common
   )
 
+if(WITH_EC_ISA_PLUGIN)
+# unittest_erasure_code_plugins
+add_executable(unittest_erasure_code_plugins
+  TestErasureCodePlugins.cc
+  $<TARGET_OBJECTS:unit-main>
+  )
+add_ceph_unittest(unittest_erasure_code_plugins)
+add_dependencies(unittest_erasure_code_plugins
+  ec_jerasure
+  ec_isa
+  ec_lrc
+  ec_shec
+  ec_clay)
+target_link_libraries(unittest_erasure_code_plugins
+  global
+  ${CMAKE_DL_LIBS}
+  ceph-common)
+endif(WITH_EC_ISA_PLUGIN)
+  
 # unittest_erasure_code_plugin_jerasure
 add_executable(unittest_erasure_code_plugin_jerasure
   TestErasureCodePluginJerasure.cc

src/test/erasure-code/ErasureCodeExample.h

@@ -76,6 +76,10 @@ class ErasureCodeExample final : public ErasureCode {
     return _minimum_to_decode(want_to_read, available_chunks, minimum);
   }
 
+  uint64_t get_supported_optimizations() const override {
+    return FLAG_EC_PLUGIN_PARTIAL_READ_OPTIMIZATION;
+  }
+
   unsigned int get_chunk_count() const override {
     return DATA_CHUNKS + CODING_CHUNKS;
   }

src/test/erasure-code/TestErasureCode.cc

@@ -39,6 +39,7 @@ class ErasureCodeTest : public ErasureCode {
     return 0;
   }
 
+  uint64_t get_supported_optimizations() const override { return 0; }
   unsigned int get_chunk_count() const override { return k + m; }
   unsigned int get_data_chunk_count() const override { return k; }
   unsigned int get_chunk_size(unsigned int object_size) const override {