erasure-code: Use ceph_assert for asserts.

Signed-off-by: Adam C. Emerson <aemerson@redhat.com>

diff --git a/src/erasure-code/ErasureCode.cc b/src/erasure-code/ErasureCode.cc
index 45607bf2f4b2a7e5a640820d66a9bdb4f94a0236..2a6c68c83dadf4d2118eda96d6d36ff6624ab0c6 100644 (file)
--- a/src/erasure-code/ErasureCode.cc
+++ b/src/erasure-code/ErasureCode.cc
@@ -148,7 +148,7 @@ int ErasureCode::encode_prepare(const bufferlist &raw,
     bufferlist &chunk = encoded[chunk_index(i)];
     chunk.substr_of(prepared, i * blocksize, blocksize);
     chunk.rebuild_aligned_size_and_memory(blocksize, SIMD_ALIGN);
-    assert(chunk.is_contiguous());
+    ceph_assert(chunk.is_contiguous());
   }
   if (padded_chunks) {
     unsigned remainder = raw.length() - (k - padded_chunks) * blocksize;
@@ -193,7 +193,7 @@ int ErasureCode::encode(const set<int> &want_to_encode,
 int ErasureCode::encode_chunks(const set<int> &want_to_encode,
                                map<int, bufferlist> *encoded)
 {
-  assert("ErasureCode::encode_chunks not implemented" == 0);
+  ceph_assert("ErasureCode::encode_chunks not implemented" == 0);
 }
  
 int ErasureCode::_decode(const set<int> &want_to_read,
@@ -245,7 +245,7 @@ int ErasureCode::decode_chunks(const set<int> &want_to_read,
                                const map<int, bufferlist> &chunks,
                                map<int, bufferlist> *decoded)
 {
-  assert("ErasureCode::decode_chunks not implemented" == 0);
+  ceph_assert("ErasureCode::decode_chunks not implemented" == 0);
 }
 
 int ErasureCode::parse(const ErasureCodeProfile &profile,

diff --git a/src/erasure-code/ErasureCodePlugin.cc b/src/erasure-code/ErasureCodePlugin.cc
index ddd591b20c5c5f150720dc4202b8cf8db9e486ff..bc595629bd82f8ee94b9afb1ac66c388018a9d6f 100644 (file)
--- a/src/erasure-code/ErasureCodePlugin.cc
+++ b/src/erasure-code/ErasureCodePlugin.cc
@@ -59,7 +59,7 @@ ErasureCodePluginRegistry::~ErasureCodePluginRegistry()
 
 int ErasureCodePluginRegistry::remove(const std::string &name)
 {
-  assert(lock.is_locked());
+  ceph_assert(lock.is_locked());
   if (plugins.find(name) == plugins.end())
     return -ENOENT;
   std::map<std::string,ErasureCodePlugin*>::iterator plugin = plugins.find(name);
@@ -73,7 +73,7 @@ int ErasureCodePluginRegistry::remove(const std::string &name)
 int ErasureCodePluginRegistry::add(const std::string &name,
                                    ErasureCodePlugin* plugin)
 {
-  assert(lock.is_locked());
+  ceph_assert(lock.is_locked());
   if (plugins.find(name) != plugins.end())
     return -EEXIST;
   plugins[name] = plugin;
@@ -82,7 +82,7 @@ int ErasureCodePluginRegistry::add(const std::string &name,
 
 ErasureCodePlugin *ErasureCodePluginRegistry::get(const std::string &name)
 {
-  assert(lock.is_locked());
+  ceph_assert(lock.is_locked());
   if (plugins.find(name) != plugins.end())
     return plugins[name];
   else
@@ -128,7 +128,7 @@ int ErasureCodePluginRegistry::load(const std::string &plugin_name,
                                    ErasureCodePlugin **plugin,
                                    ostream *ss)
 {
-  assert(lock.is_locked());
+  ceph_assert(lock.is_locked());
   std::string fname = directory + "/" PLUGIN_PREFIX
     + plugin_name + PLUGIN_SUFFIX;
   void *library = dlopen(fname.c_str(), RTLD_NOW);

diff --git a/src/erasure-code/isa/ErasureCodeIsa.cc b/src/erasure-code/isa/ErasureCodeIsa.cc
index 46c8e830173aecaea5edcecbb4e44f24d4a8c747..cf8e5cadd1cbd943af52e72a1c16554bb29998fe 100644 (file)
--- a/src/erasure-code/isa/ErasureCodeIsa.cc
+++ b/src/erasure-code/isa/ErasureCodeIsa.cc
@@ -109,7 +109,7 @@ int ErasureCodeIsa::decode_chunks(const set<int> &want_to_read,
       coding[i - k] = (*decoded)[i].c_str();
   }
   erasures[erasures_count] = -1;
-  assert(erasures_count > 0);
+  ceph_assert(erasures_count > 0);
   return isa_decode(erasures, data, coding, blocksize);
 }
 
@@ -194,7 +194,7 @@ ErasureCodeIsaDefault::isa_decode(int *erasures,
 
   if (m == 1) {
     // single parity decoding
-    assert(1 == nerrs);
+    ceph_assert(1 == nerrs);
     dout(20) << "isa_decode: reconstruct using region xor [" <<
       erasures[0] << "]" << dendl;
     region_xor(recover_source, recover_target[0], k, blocksize);
@@ -208,8 +208,8 @@ ErasureCodeIsaDefault::isa_decode(int *erasures,
     // use xor decoding if a data chunk is missing or the first coding chunk
     dout(20) << "isa_decode: reconstruct using region xor [" <<
       erasures[0] << "]" << dendl;
-    assert(1 == s);
-    assert(k == r);
+    ceph_assert(1 == s);
+    ceph_assert(k == r);
     region_xor(recover_source, recover_target[0], k, blocksize);
     return 0;
   }
@@ -415,7 +415,7 @@ ErasureCodeIsaDefault::prepare()
     " [ matrix ] = " <<
     ((matrixtype == kVandermonde) ? "Vandermonde" : "Cauchy") << dendl;
 
-  assert((matrixtype == kVandermonde) || (matrixtype == kCauchy));
+  ceph_assert((matrixtype == kVandermonde) || (matrixtype == kCauchy));
 
 }
 // -----------------------------------------------------------------------------

diff --git a/src/erasure-code/isa/xor_op.cc b/src/erasure-code/isa/xor_op.cc
index be0071d8fa95c6f40584785f89f75746299ea9b8..5ddcced8c796b30dd1072746bfd00e02ade580ea 100644 (file)
--- a/src/erasure-code/isa/xor_op.cc
+++ b/src/erasure-code/isa/xor_op.cc
@@ -15,6 +15,9 @@
 #include <stdio.h>
 #include <string.h>
 #include "arch/intel.h"
+
+#include "include/assert.h"
+
 // -----------------------------------------------------------------------------
 
 
@@ -38,9 +41,9 @@ vector_xor(vector_op_t* cw,
            vector_op_t* ew)
 // -----------------------------------------------------------------------------
 {
-  assert(is_aligned(cw, EC_ISA_VECTOR_OP_WORDSIZE));
-  assert(is_aligned(dw, EC_ISA_VECTOR_OP_WORDSIZE));
-  assert(is_aligned(ew, EC_ISA_VECTOR_OP_WORDSIZE));
+  ceph_assert(is_aligned(cw, EC_ISA_VECTOR_OP_WORDSIZE));
+  ceph_assert(is_aligned(dw, EC_ISA_VECTOR_OP_WORDSIZE));
+  ceph_assert(is_aligned(ew, EC_ISA_VECTOR_OP_WORDSIZE));
   while (cw < ew) {
     *dw++ ^= *cw++;
   }
@@ -139,7 +142,7 @@ region_sse2_xor(char** src,
 // -----------------------------------------------------------------------------
 {
 #ifdef __x86_64__
-  assert(!(size % EC_ISA_VECTOR_SSE2_WORDSIZE));
+  ceph_assert(!(size % EC_ISA_VECTOR_SSE2_WORDSIZE));
   unsigned char* p;
   int d, l;
   unsigned i;

diff --git a/src/erasure-code/jerasure/ErasureCodeJerasure.cc b/src/erasure-code/jerasure/ErasureCodeJerasure.cc
index ea76b22f00402d697c7c50a835205faef4b3f57b..649cbc2498abfaa496deba8b80d0ccb59719a4c9 100644 (file)
--- a/src/erasure-code/jerasure/ErasureCodeJerasure.cc
+++ b/src/erasure-code/jerasure/ErasureCodeJerasure.cc
@@ -79,7 +79,7 @@ unsigned int ErasureCodeJerasure::get_chunk_size(unsigned int object_size) const
       chunk_size++;
     dout(20) << "get_chunk_size: chunk_size " << chunk_size
             << " must be modulo " << alignment << dendl; 
-    assert(alignment <= chunk_size);
+    ceph_assert(alignment <= chunk_size);
     unsigned modulo = chunk_size % alignment;
     if (modulo) {
       dout(10) << "get_chunk_size: " << chunk_size
@@ -90,7 +90,7 @@ unsigned int ErasureCodeJerasure::get_chunk_size(unsigned int object_size) const
   } else {
     unsigned tail = object_size % alignment;
     unsigned padded_length = object_size + ( tail ?  ( alignment - tail ) : 0 );
-    assert(padded_length % k == 0);
+    ceph_assert(padded_length % k == 0);
     return padded_length / k;
   }
 }
@@ -126,7 +126,7 @@ int ErasureCodeJerasure::decode_chunks(const set<int> &want_to_read,
   }
   erasures[erasures_count] = -1;
 
-  assert(erasures_count > 0);
+  ceph_assert(erasures_count > 0);
   return jerasure_decode(erasures, data, coding, blocksize);
 }
 

diff --git a/src/erasure-code/lrc/ErasureCodeLrc.cc b/src/erasure-code/lrc/ErasureCodeLrc.cc
index 54b0b3e22f699378654a84b6d7ce1b1c33a16fd3..772704522774ca072c4592d1dd6b8d1053ca06bc 100644 (file)
--- a/src/erasure-code/lrc/ErasureCodeLrc.cc
+++ b/src/erasure-code/lrc/ErasureCodeLrc.cc
@@ -83,15 +83,15 @@ int ErasureCodeLrc::create_rule(const string &name,
   int ret;
   ret = crush.add_rule(rno, steps, pg_pool_t::TYPE_ERASURE,
                       min_rep, max_rep);
-  assert(ret == rno);
+  ceph_assert(ret == rno);
   int step = 0;
 
   ret = crush.set_rule_step(rno, step++, CRUSH_RULE_SET_CHOOSELEAF_TRIES, 5, 0);
-  assert(ret == 0);
+  ceph_assert(ret == 0);
   ret = crush.set_rule_step(rno, step++, CRUSH_RULE_SET_CHOOSE_TRIES, 100, 0);
-  assert(ret == 0);
+  ceph_assert(ret == 0);
   ret = crush.set_rule_step(rno, step++, CRUSH_RULE_TAKE, root, 0);
-  assert(ret == 0);
+  ceph_assert(ret == 0);
   // [ [ "choose", "rack", 2 ],
   //   [ "chooseleaf", "host", 5 ] ]
   for (vector<Step>::const_iterator i = rule_steps.begin();
@@ -105,10 +105,10 @@ int ErasureCodeLrc::create_rule(const string &name,
       return -EINVAL;
     }
     ret = crush.set_rule_step(rno, step++, op, i->n, type);
-    assert(ret == 0);
+    ceph_assert(ret == 0);
   }
   ret = crush.set_rule_step(rno, step++, CRUSH_RULE_EMIT, 0, 0);
-  assert(ret == 0);
+  ceph_assert(ret == 0);
   crush.set_rule_name(rno, name);
   return rno;
 }

diff --git a/src/erasure-code/shec/ErasureCodeShec.cc b/src/erasure-code/shec/ErasureCodeShec.cc
index 2c31958ce444f0d7c7a60fdcc35bf4b5d11aac4e..75bbe97d38d2b85369f73ee508f1770edf0655d8 100644 (file)
--- a/src/erasure-code/shec/ErasureCodeShec.cc
+++ b/src/erasure-code/shec/ErasureCodeShec.cc
@@ -62,7 +62,7 @@ unsigned int ErasureCodeShec::get_chunk_size(unsigned int object_size) const
   unsigned tail = object_size % alignment;
   unsigned padded_length = object_size + ( tail ?  ( alignment - tail ) : 0 );
 
-  assert(padded_length % k == 0);
+  ceph_assert(padded_length % k == 0);
   return padded_length / k;
 }
 
@@ -408,7 +408,7 @@ void ErasureCodeShecReedSolomonVandermonde::prepare()
   dout(10) << " [ technique ] = " <<
     ((technique == MULTIPLE) ? "multiple" : "single") << dendl;
 
-  assert((technique == SINGLE) || (technique == MULTIPLE));
+  ceph_assert((technique == SINGLE) || (technique == MULTIPLE));
 
 }