erasure-code: Add parity delta write optimization to Jerasure

jamiepryde · aainscow · commit 4527b8c91731 · 2025-03-19T11:03:55.000Z
This commit adds FLAG_EC_PLUGIN_PARITY_DELTA_OPTIMIZATION to the list of
optimizations supported by the Jerasure plugin, and encode_delta and
apply_delta functions for all Jerasure techniques.

Signed-off-by: Jamie Pryde &lt;jamiepry@uk.ibm.com&gt;
Signed-off-by: Alex Ainscow &lt;aainscow@uk.ibm.com&gt;
diff --git a/src/erasure-code/jerasure/ErasureCodeJerasure.cc b/src/erasure-code/jerasure/ErasureCodeJerasure.cc
@@ -137,6 +137,18 @@ int ErasureCodeJerasure::decode_chunks(const set<int> &want_to_read,
   return jerasure_decode(erasures, data, coding, blocksize);
 }
 
+void ErasureCodeJerasure::encode_delta(const bufferptr &old_data,
+                                       const bufferptr &new_data,
+                                       bufferptr *delta_maybe_in_place)
+{
+  if (&old_data != delta_maybe_in_place) {
+    memcpy(delta_maybe_in_place->c_str(), old_data.c_str(), delta_maybe_in_place->length());
+  }
+  char *new_data_p = const_cast<char*>(new_data.c_str());
+  char *delta_p = delta_maybe_in_place->c_str();
+  galois_region_xor(new_data_p, delta_p, delta_maybe_in_place->length());
+}
+
 bool ErasureCodeJerasure::is_prime(int value)
 {
   int prime55[] = {
@@ -152,7 +164,86 @@ bool ErasureCodeJerasure::is_prime(int value)
   return false;
 }
 
-// 
+void ErasureCodeJerasure::matrix_apply_delta(const shard_id_map<bufferptr> &in,
+                                             shard_id_map<bufferptr> &out,
+                                             int k, int w, int *matrix)
+{
+  auto first = in.begin();
+  const unsigned blocksize = first->second.length();
+
+  for (auto const& [datashard, databuf] : in) {
+    if (datashard < k) {
+      for (auto const& [codingshard, codingbuf] : out) {
+        if (codingshard >= k) {
+          ceph_assert(codingbuf.length() == blocksize);
+          char* input_data = const_cast<char*>(databuf.c_str());
+          char* output_data = const_cast<char*>(codingbuf.c_str());
+          if (static_cast<int>(codingshard) == k) {
+            galois_region_xor(input_data, output_data, blocksize);
+          }
+          else {
+            switch (w) {
+              case 8:
+                galois_w08_region_multiply(input_data, matrix[static_cast<int>(datashard) + (k * (static_cast<int>(codingshard) - k))], blocksize, output_data, 1);
+                break;
+              case 16:
+                galois_w16_region_multiply(input_data, matrix[static_cast<int>(datashard) + (k * (static_cast<int>(codingshard) - k))], blocksize, output_data, 1);
+                break;
+              case 32:
+                galois_w32_region_multiply(input_data, matrix[static_cast<int>(datashard) + (k * (static_cast<int>(codingshard) - k))], blocksize, output_data, 1);
+                break;
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+void ErasureCodeJerasure::do_scheduled_ops(char **ptrs, int **operations, int packetsize, int s, int d)
+{
+  char *sptr;
+  char *dptr;
+  int op;
+
+  for (op = 0; operations[op][0] >= 0; op++) {
+    if (operations[op][0] == s && operations[op][2] == d) {
+      sptr = ptrs[0] + operations[op][1]*packetsize;
+      dptr = ptrs[1] + operations[op][3]*packetsize;
+      galois_region_xor(sptr, dptr, packetsize);
+    }
+  }
+}
+
+void ErasureCodeJerasure::schedule_apply_delta(const shard_id_map<bufferptr> &in,
+                                               shard_id_map<bufferptr> &out,
+                                               int k, int w, int packetsize,
+                                               int ** simple_schedule)
+{
+  auto first = in.begin();
+  unsigned int blocksize = first->second.length();
+
+  for (auto const& [datashard, databuf] : in) {
+    if (datashard < k) {
+      for (auto const& [codingshard, codingbuf] : out) {
+        if (codingshard >= k) {
+          ceph_assert(codingbuf.length() == blocksize);
+          char * ptr_copy[2];
+          ptr_copy[0] = const_cast<char*>(databuf.c_str());
+          ptr_copy[1] = const_cast<char*>(codingbuf.c_str());
+          unsigned int done;
+          for (done = 0; done < blocksize; done += (packetsize*w)) {
+            do_scheduled_ops(ptr_copy, simple_schedule, packetsize, static_cast<int>(datashard), static_cast<int>(codingshard));
+            ptr_copy[0] += (packetsize*w);
+            ptr_copy[1] += (packetsize*w);
+          }
+        }
+      }
+    }
+  }
+}
+
+//
 // ErasureCodeJerasureReedSolomonVandermonde
 //
 void ErasureCodeJerasureReedSolomonVandermonde::jerasure_encode(char **data,
@@ -171,6 +262,12 @@ int ErasureCodeJerasureReedSolomonVandermonde::jerasure_decode(int *erasures,
 				erasures, data, coding, blocksize);
 }
 
+void ErasureCodeJerasureReedSolomonVandermonde::apply_delta(const shard_id_map<bufferptr> &in,
+                                                            shard_id_map<bufferptr> &out)
+{
+  matrix_apply_delta(in, out, k, w, matrix);
+}
+
 unsigned ErasureCodeJerasureReedSolomonVandermonde::get_alignment() const
 {
   if (per_chunk_alignment) {
@@ -221,6 +318,12 @@ int ErasureCodeJerasureReedSolomonRAID6::jerasure_decode(int *erasures,
   return jerasure_matrix_decode(k, m, w, matrix, 1, erasures, data, coding, blocksize);
 }
 
+void ErasureCodeJerasureReedSolomonRAID6::apply_delta(const shard_id_map<bufferptr> &in,
+                                                      shard_id_map<bufferptr> &out)
+{
+  matrix_apply_delta(in, out, k, w, matrix);
+}
+
 unsigned ErasureCodeJerasureReedSolomonRAID6::get_alignment() const
 {
   if (per_chunk_alignment) {
@@ -275,6 +378,12 @@ int ErasureCodeJerasureCauchy::jerasure_decode(int *erasures,
 				       erasures, data, coding, blocksize, packetsize, 1);
 }
 
+void ErasureCodeJerasureCauchy::apply_delta(const shard_id_map<bufferptr> &in,
+                                            shard_id_map<bufferptr> &out)
+{
+  schedule_apply_delta(in, out, k, w, packetsize, simple_schedule);
+}
+
 unsigned ErasureCodeJerasureCauchy::get_alignment() const
 {
   if (per_chunk_alignment) {
@@ -305,6 +414,7 @@ void ErasureCodeJerasureCauchy::prepare_schedule(int *matrix)
 {
   bitmatrix = jerasure_matrix_to_bitmatrix(k, m, w, matrix);
   schedule = jerasure_smart_bitmatrix_to_schedule(k, m, w, bitmatrix);
+  simple_schedule = jerasure_dumb_bitmatrix_to_schedule(k, m, w, bitmatrix);
 }
 
 ErasureCodeJerasureCauchy::~ErasureCodeJerasureCauchy() 
@@ -313,6 +423,8 @@ ErasureCodeJerasureCauchy::~ErasureCodeJerasureCauchy()
     free(bitmatrix);
   if (schedule)
     jerasure_free_schedule(schedule);
+  if (simple_schedule)
+    jerasure_free_schedule(simple_schedule);
 }
 
 // 
@@ -344,6 +456,8 @@ ErasureCodeJerasureLiberation::~ErasureCodeJerasureLiberation()
     free(bitmatrix);
   if (schedule)
     jerasure_free_schedule(schedule);
+  if (simple_schedule)
+    jerasure_free_schedule(simple_schedule);
 }
 
 void ErasureCodeJerasureLiberation::jerasure_encode(char **data,
@@ -363,6 +477,12 @@ int ErasureCodeJerasureLiberation::jerasure_decode(int *erasures,
 				       coding, blocksize, packetsize, 1);
 }
 
+void ErasureCodeJerasureLiberation::apply_delta(const shard_id_map<bufferptr> &in,
+                                                shard_id_map<bufferptr> &out)
+{
+  schedule_apply_delta(in, out, k, w, packetsize, simple_schedule);
+}
+
 unsigned ErasureCodeJerasureLiberation::get_alignment() const
 {
   unsigned alignment = k*w*packetsize*sizeof(int);
@@ -451,6 +571,7 @@ void ErasureCodeJerasureLiberation::prepare()
 {
   bitmatrix = liberation_coding_bitmatrix(k, w);
   schedule = jerasure_smart_bitmatrix_to_schedule(k, m, w, bitmatrix);
+  simple_schedule = jerasure_dumb_bitmatrix_to_schedule(k, m, w, bitmatrix);
 }
 
 // 
@@ -475,6 +596,7 @@ void ErasureCodeJerasureBlaumRoth::prepare()
 {
   bitmatrix = blaum_roth_coding_bitmatrix(k, w);
   schedule = jerasure_smart_bitmatrix_to_schedule(k, m, w, bitmatrix);
+  simple_schedule = jerasure_dumb_bitmatrix_to_schedule(k, m, w, bitmatrix);
 }
 
 // 
@@ -512,4 +634,5 @@ void ErasureCodeJerasureLiber8tion::prepare()
 {
   bitmatrix = liber8tion_coding_bitmatrix(k);
   schedule = jerasure_smart_bitmatrix_to_schedule(k, m, w, bitmatrix);
+  simple_schedule = jerasure_dumb_bitmatrix_to_schedule(k, m, w, bitmatrix);
 }
diff --git a/src/erasure-code/jerasure/ErasureCodeJerasure.h b/src/erasure-code/jerasure/ErasureCodeJerasure.h
@@ -49,7 +49,8 @@ class ErasureCodeJerasure : 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;
+      FLAG_EC_PLUGIN_ZERO_INPUT_ZERO_OUTPUT_OPTIMIZATION |
+      FLAG_EC_PLUGIN_PARITY_DELTA_OPTIMIZATION;
   }
 
   
@@ -70,6 +71,13 @@ class ErasureCodeJerasure : public ceph::ErasureCode {
 		    const std::map<int, ceph::buffer::list> &chunks,
 		    std::map<int, ceph::buffer::list> *decoded) override;
 
+  void encode_delta(const ceph::bufferptr &old_data,
+                    const ceph::bufferptr &new_data,
+                    ceph::bufferptr *delta_maybe_in_place);
+
+  void apply_delta(const shard_id_map<ceph::bufferptr> &in,
+                           shard_id_map<ceph::bufferptr> &out) = 0;
+
   int init(ceph::ErasureCodeProfile &profile, std::ostream *ss) override;
 
   virtual void jerasure_encode(char **data,
@@ -82,6 +90,18 @@ class ErasureCodeJerasure : public ceph::ErasureCode {
   virtual unsigned get_alignment() const = 0;
   virtual void prepare() = 0;
   static bool is_prime(int value);
+
+  void matrix_apply_delta(const shard_id_map<bufferptr> &in,
+                          shard_id_map<bufferptr> &out,
+                          int k, int w, int *matrix);
+
+  void schedule_apply_delta(const shard_id_map<bufferptr> &in,
+                            shard_id_map<bufferptr> &out,
+                            int k, int w, int packetsize,
+                            int ** simple_schedule);
+
+  void do_scheduled_ops(char **ptrs, int **operations, int packetsize, int s, int d);
+
 protected:
   virtual int parse(ceph::ErasureCodeProfile &profile, std::ostream *ss);
 };
@@ -109,6 +129,8 @@ class ErasureCodeJerasureReedSolomonVandermonde : public ErasureCodeJerasure {
                                char **data,
                                char **coding,
                                int blocksize) override;
+  void apply_delta(const shard_id_map<ceph::bufferptr> &in,
+                   shard_id_map<ceph::bufferptr> &out) override;
   unsigned get_alignment() const override;
   size_t get_minimum_granularity() override
   {
@@ -143,6 +165,8 @@ class ErasureCodeJerasureReedSolomonRAID6 : public ErasureCodeJerasure {
                                char **data,
                                char **coding,
                                int blocksize) override;
+  void apply_delta(const shard_id_map<ceph::bufferptr> &in,
+                   shard_id_map<ceph::bufferptr> &out) override;
   unsigned get_alignment() const override;
   size_t get_minimum_granularity() override
   {
@@ -159,12 +183,14 @@ class ErasureCodeJerasureCauchy : public ErasureCodeJerasure {
 public:
   int *bitmatrix;
   int **schedule;
+  int **simple_schedule;
   int packetsize;
 
   explicit ErasureCodeJerasureCauchy(const char *technique) :
     ErasureCodeJerasure(technique),
     bitmatrix(0),
     schedule(0),
+    simple_schedule(0),
     packetsize(0)
   {
     DEFAULT_K = "7";
@@ -180,6 +206,8 @@ class ErasureCodeJerasureCauchy : public ErasureCodeJerasure {
                                char **data,
                                char **coding,
                                int blocksize) override;
+  void apply_delta(const shard_id_map<ceph::bufferptr> &in,
+                   shard_id_map<ceph::bufferptr> &out) override;
   unsigned get_alignment() const override;
   size_t get_minimum_granularity() override
   {
@@ -212,12 +240,14 @@ class ErasureCodeJerasureLiberation : public ErasureCodeJerasure {
 public:
   int *bitmatrix;
   int **schedule;
+  int **simple_schedule;
   int packetsize;
 
   explicit ErasureCodeJerasureLiberation(const char *technique = "liberation") :
     ErasureCodeJerasure(technique),
     bitmatrix(0),
     schedule(0),
+    simple_schedule(0),
     packetsize(0)
   {
     DEFAULT_K = "2";
@@ -233,6 +263,8 @@ class ErasureCodeJerasureLiberation : public ErasureCodeJerasure {
                                char **data,
                                char **coding,
                                int blocksize) override;
+  void apply_delta(const shard_id_map<ceph::bufferptr> &in,
+                   shard_id_map<ceph::bufferptr> &out) override;
   unsigned get_alignment() const override;
   size_t get_minimum_granularity() override
   {
diff --git a/src/test/erasure-code/TestErasureCodePlugins.cc b/src/test/erasure-code/TestErasureCodePlugins.cc
@@ -613,7 +613,7 @@ INSTANTIATE_TEST_SUITE_P(
     "plugin=lrc mapping=_D_D_DDD layers=[[\"cDcDcDDD\",\"\"]]",
     "plugin=lrc mapping=_D_D_DDDD layers=[[\"cDcDcDDDD\",\"\"]]",
     "plugin=jerasure technique=reed_sol_van k=6 m=3 w=16",
-    "plugin=jerasure technique=reed_sol_van k=6 m=3 w=32"
+    "plugin=jerasure technique=reed_sol_van k=6 m=3 w=32",
     "plugin=jerasure technique=liberation k=6 m=2 packetsize=32 w=11",
     "plugin=jerasure technique=liberation k=6 m=2 packetsize=36 w=13",
     "plugin=jerasure technique=blaum_roth k=6 m=2 packetsize=44 w=7",
