always use mad() when possible (both single and double precision)

cjang · Aug 17, 2010 · 70f4099 · 70f4099
1 parent 04ab205
commit 70f4099
Show file tree

Hide file tree

Showing 3 changed files with 26 additions and 24 deletions.
diff --git a/KernelBaseMatmul.hpp b/KernelBaseMatmul.hpp
@@ -314,33 +314,33 @@ class KernelBaseMatmul : public KernelInterface,
             const size_t index = j % VECTOR_LENGTH;
             if (transposeB())
                 // At Bt
-                return nameof<SCALAR>() == "double"
-                    ? increment(accum[j][k],
+                return true //isfloat<SCALAR>()
+                    ? assign(accum[j][k], MADValue(valA[l + offset][index], valB[k][l], accum[j][k]))
+                    : increment(accum[j][k],
                                 ConstantValue<std::string>(valA[l + offset][index]) *
-                                ConstantValue<std::string>(valB[k][l]))
-                    : assign(accum[j][k], MADValue(valA[l + offset][index], valB[k][l], accum[j][k]));
+                                ConstantValue<std::string>(valB[k][l]));
             else
                 // At B
-                return nameof<SCALAR>() == "double"
-                    ? increment(accum[j][k],
+                return true //isfloat<SCALAR>()
+                    ? assign(accum[j][k], MADValue(valA[l + offset][index], valB[l][k], accum[j][k]))
+                    : increment(accum[j][k],
                                 ConstantValue<std::string>(valA[l + offset][index]) *
-                                ConstantValue<std::string>(valB[l][k]))
-                    : assign(accum[j][k], MADValue(valA[l + offset][index], valB[l][k], accum[j][k]));
+                                ConstantValue<std::string>(valB[l][k]));
         } else {
             if (transposeB())
                 // A Bt
-                return nameof<SCALAR>() == "double"
-                    ? increment(accum[j][k],
+                return true //isfloat<SCALAR>()
+                    ? assign(accum[j][k], MADValue(valA[j][l], valB[k][l], accum[j][k]))
+                    : increment(accum[j][k],
                                 ConstantValue<std::string>(valA[j][l]) *
-                                ConstantValue<std::string>(valB[k][l]))
-                    : assign(accum[j][k], MADValue(valA[j][l], valB[k][l], accum[j][k]));
+                                ConstantValue<std::string>(valB[k][l]));
             else
                 // A B
-                return nameof<SCALAR>() == "double"
-                    ? increment(accum[j][k],
+                return true //isfloat<SCALAR>()
+                    ? assign(accum[j][k], MADValue(valA[j][l], valB[l][k], accum[j][k]))
+                    : increment(accum[j][k],
                                 ConstantValue<std::string>(valA[j][l]) *
-                                ConstantValue<std::string>(valB[l][k]))
-                    : assign(accum[j][k], MADValue(valA[j][l], valB[l][k], accum[j][k]));
+                                ConstantValue<std::string>(valB[l][k]));
         }
     }
 

diff --git a/KernelMatmulBuffer.hpp b/KernelMatmulBuffer.hpp
@@ -304,12 +304,12 @@ class KernelMatmulBuffer : public KernelBaseMatmul,
         for (size_t i = 0; i < blockHeight(); i++)
             if (generalizedMatmul())
                 os << assign(*(outC + i * (N / VECTOR_LENGTH)),
-                             (nameof<SCALAR>() == "double")
-                                 ? CastValue<scalarN>(alpha) * accum[i] +
-                                   CastValue<scalarN>(beta) * *(outC + i * (N / VECTOR_LENGTH))
-                                 : MADValue(CastValue<scalarN>(alpha),
+                             true //isfloat<SCALAR>()
+                                 ? MADValue(CastValue<scalarN>(alpha),
                                             accum[i],
-                                            CastValue<scalarN>(beta) * *(outC + i * (N / VECTOR_LENGTH))));
+                                            CastValue<scalarN>(beta) * *(outC + i * (N / VECTOR_LENGTH)))
+                                 : CastValue<scalarN>(alpha) * accum[i] +
+                                   CastValue<scalarN>(beta) * *(outC + i * (N / VECTOR_LENGTH)));
             else
                 os << assign(*(outC + i * (N / VECTOR_LENGTH)), accum[i]);
 

diff --git a/KernelMatmulImage.hpp b/KernelMatmulImage.hpp
@@ -275,9 +275,11 @@ class KernelMatmulImage : public KernelBaseMatmul,
             const ConstantValue<std::string> outC = matC_buf + multHeight(N) * globalRow + globalCol;
             for (size_t i = 0; i < blockHeight(); i++)
                 os << assign(*(outC + i * (N / VECTOR_LENGTH)),
-                             MADValue(CastValue<scalarN>(alpha),
-                                      accum[i],
-                                      CastValue<scalarN>(beta) * *(outC + i * (N / VECTOR_LENGTH))));
+                             true // isfloat<scalar>()
+                                 ? MADValue(CastValue<scalarN>(alpha),
+                                            accum[i],
+                                            CastValue<scalarN>(beta) * *(outC + i * (N / VECTOR_LENGTH)))
+                                 : CastValue<scalarN>(alpha) * accum[i] + CastValue<scalarN>(beta) * *(outC + i * (N / VECTOR_LENGTH)));
         } else {
             const ConstantValue<std::string> valueGlobalCol = globalID()
                                                                   ? globalCol