optimization by inlining

Signed-off-by: BlackEagle <ike.devolder@gmail.com>

reedsolomon.cpp

@@ -101,15 +101,8 @@ template <> bool ReedSolomon<Galois8>::SetInput(u32 count)
   return true;
 }
 
-template <> bool ReedSolomon<Galois8>::Process(size_t size, u32 inputindex, const void *inputbuffer, u32 outputindex, void *outputbuffer)
+template <> bool ReedSolomon<Galois8>::InternalProcess(const Galois8 &factor, size_t size, const void *inputbuffer, void *outputbuffer)
 {
-  // Look up the appropriate element in the RS matrix
-  Galois8 factor = leftmatrix[outputindex * (datapresent + datamissing) + inputindex];
-
-  // Do nothing if the factor happens to be 0
-  if (factor == 0)
-    return eSuccess;
-
 #ifdef LONGMULTIPLY
   // The 8-bit long multiplication tables
   Galois8 *table = glmt->tables;
@@ -267,15 +260,8 @@ template <> bool ReedSolomon<Galois16>::SetInput(u32 count)
   return true;
 }
 
-template <> bool ReedSolomon<Galois16>::Process(size_t size, u32 inputindex, const void *inputbuffer, u32 outputindex, void *outputbuffer)
+template<> bool ReedSolomon<Galois16>::InternalProcess(const Galois16 &factor, size_t size, const void *inputbuffer, void *outputbuffer)
 {
-  // Look up the appropriate element in the RS matrix
-
-  Galois16 factor = leftmatrix[outputindex * (datapresent + datamissing) + inputindex];
-  // Do nothing if the factor happens to be 0
-  if (factor == 0)
-    return eSuccess;
-
 #ifdef LONGMULTIPLY
   // The 8-bit long multiplication tables
   Galois16 *table = glmt->tables;

reedsolomon.h

@@ -64,20 +64,22 @@ class ReedSolomon
                const void *inputbuffer, // Buffer containing input data
                u32 outputindex,         // The row in the RS matrix
                void *outputbuffer);     // Buffer containing output data
+private:
+		bool InternalProcess(const g &factor, size_t size, const void *inputbuffer, void *outputbuffer);	// Optimization
 
 protected:
   // Perform Gaussian Elimination
   bool GaussElim(CommandLine::NoiseLevel noiselevel,
-                 unsigned int rows, 
-                 unsigned int leftcols, 
-                 G *leftmatrix, 
-                 G *rightmatrix, 
+                 unsigned int rows,
+                 unsigned int leftcols,
+                 G *leftmatrix,
+                 G *rightmatrix,
                  unsigned int datamissing);
 
 protected:
   u32 inputcount;        // Total number of input blocks
 
-  u32 datapresent;       // Number of input blocks that are present 
+  u32 datapresent;       // Number of input blocks that are present
   u32 datamissing;       // Number of input blocks that are missing
   u32 *datapresentindex; // The index numbers of the data blocks that are present
   u32 *datamissingindex; // The index numbers of the data blocks that are missing
@@ -146,6 +148,20 @@ inline ReedSolomon<g>::~ReedSolomon(void)
 #endif
 }
 
+template<class g>
+inline bool ReedSolomon<g>::Process(size_t size, u32 inputindex, const void *inputbuffer, u32 outputindex, void *outputbuffer)
+{
+	// Optimization: it occurs frequently the function exits early on, so inline the start.
+	// This resulted in a speed gain of approx. 8% in repairing.
+
+	// Look up the appropriate element in the RS matrix
+	g factor = leftmatrix[outputindex * (datapresent + datamissing) + inputindex];
+	// Do nothing if the factor happens to be 0
+	if (factor == 0)
+		return eSuccess;
+	return this->InternalProcess (factor, size, inputbuffer, outputbuffer);
+}
+
 u32 gcd(u32 a, u32 b);
 
 // Record whether the recovery block with the specified
@@ -242,11 +258,14 @@ inline bool ReedSolomon<g>::Compute(CommandLine::NoiseLevel noiselevel)
   // One row for each present recovery block that will be used for a missing data block
   for (unsigned int row=0; row<datamissing; row++)
   {
+    // Define MPDL to skip reporting and speed things up
+#ifndef MPDL
     if (noiselevel > CommandLine::nlQuiet)
     {
       int progress = row * 1000 / (datamissing+parmissing);
       cout << "Constructing: " << progress/10 << '.' << progress%10 << "%\r" << flush;
     }
+#endif
 
     // Get the exponent of the next present recovery block
     while (!outputrow->present)
@@ -286,11 +305,14 @@ inline bool ReedSolomon<g>::Compute(CommandLine::NoiseLevel noiselevel)
   outputrow = outputrows.begin();
   for (unsigned int row=0; row<parmissing; row++)
   {
+    // Define MPDL to skip reporting and speed things up
+#ifndef MPDL
     if (noiselevel > CommandLine::nlQuiet)
     {
       int progress = (row+datamissing) * 1000 / (datamissing+parmissing);
       cout << "Constructing: " << progress/10 << '.' << progress%10 << "%\r" << flush;
     }
+#endif
 
     // Get the exponent of the next missing recovery block
     while (outputrow->present)
@@ -332,7 +354,7 @@ inline bool ReedSolomon<g>::Compute(CommandLine::NoiseLevel noiselevel)
   // Solve the matrices only if recovering data
   if (datamissing > 0)
   {
-    // Perform Gaussian Elimination and then delete the right matrix (which 
+    // Perform Gaussian Elimination and then delete the right matrix (which
     // will no longer be required).
     bool success = GaussElim(noiselevel, outcount, incount, leftmatrix, rightmatrix, datamissing);
     delete [] rightmatrix;
@@ -420,6 +442,8 @@ inline bool ReedSolomon<g>::GaussElim(CommandLine::NoiseLevel noiselevel, unsign
     // For every other row in the matrix
     for (unsigned int row2=0; row2<rows; row2++)
     {
+      // Define MPDL to skip reporting and speed things up
+#ifndef MPDL
       if (noiselevel > CommandLine::nlQuiet)
       {
         int newprogress = (row*rows+row2) * 1000 / (datamissing*rows);
@@ -429,6 +453,7 @@ inline bool ReedSolomon<g>::GaussElim(CommandLine::NoiseLevel noiselevel, unsign
           cout << "Solving: " << progress/10 << '.' << progress%10 << "%\r" << flush;
         }
       }
+#endif
 
       if (row != row2)
       {