HPCC-16571 Mangle the functions exported from eclblas plugin

Use C++ linkage and eclblas namespace, to reflect current best-practice.

Signed-off-by: Richard Chapman <rchapman@hpccsystems.com>

plugins/eclblas/Extract_Tri.cpp

@@ -19,6 +19,8 @@
 //
 #include "eclblas.hpp"
 
+namespace eclblas {
+
 ECLBLAS_CALL void Extract_Tri(bool & __isAllResult, size32_t & __lenResult,
                               void * & __result, uint32_t m, uint32_t n, uint8_t tri,
                               uint8_t dt, bool isAllA, size32_t lenA, const void * a){
@@ -44,3 +46,5 @@ ECLBLAS_CALL void Extract_Tri(bool & __isAllResult, size32_t & __lenResult,
   }
   __result = (void*) new_a;
 }
+
+}

plugins/eclblas/dasum.cpp

@@ -20,9 +20,13 @@
 
 #include "eclblas.hpp"
 
+namespace eclblas {
+
 ECLBLAS_CALL double dasum(uint32_t m, bool isAllX, size32_t lenX, const void * x,
                           uint32_t incx, uint32_t skipped) {
   const double* X = ((const double*)x) + skipped;
   double rslt = cblas_dasum(m, X, incx);
   return rslt;
 }
+
+}

plugins/eclblas/daxpy.cpp

@@ -18,6 +18,7 @@
 // Vector add, alpha X  +  Y
 #include "eclblas.hpp"
 
+namespace eclblas {
 
 ECLBLAS_CALL void daxpy(bool & __isAllResult, size32_t & __lenResult,
                         void * & __result, uint32_t n, double alpha,
@@ -33,3 +34,5 @@ ECLBLAS_CALL void daxpy(bool & __isAllResult, size32_t & __lenResult,
   cblas_daxpy(n, alpha, X, incx, Y, incy);
   __result = (void*) result;
 }
+
+}

plugins/eclblas/dgemm.cpp

@@ -20,6 +20,8 @@
 //transpose A and B.  beta defaults to zero, and C to empty
 #include "eclblas.hpp"
 
+namespace eclblas {
+
 ECLBLAS_CALL void dgemm(bool & __isAllResult, size32_t & __lenResult,
                         void * & __result, bool transposeA, bool transposeB,
                         uint32_t m, uint32_t n, uint32_t k,
@@ -42,4 +44,6 @@ ECLBLAS_CALL void dgemm(bool & __isAllResult, size32_t & __lenResult,
               (const double *) B, ldb,
               beta, result, ldc);
   __result = (void *) result;
-  }
+}
+
+}

plugins/eclblas/dgetf2.cpp

@@ -24,6 +24,8 @@
 #include <math.h>
 #include "eclblas.hpp"
 
+namespace eclblas {
+
 ECLBLAS_CALL void dgetf2(bool & __isAllResult, size32_t & __lenResult,
                          void * & __result, uint32_t m, uint32_t n,
                          bool isAllA, size32_t lenA, const void* a) {
@@ -59,3 +61,5 @@ ECLBLAS_CALL void dgetf2(bool & __isAllResult, size32_t & __lenResult,
   }
   __result = (void*) new_a;
 }
+
+}

plugins/eclblas/dpotf2.cpp

@@ -26,6 +26,8 @@
 #include "eclblas.hpp"
 #include <math.h>
 
+namespace eclblas {
+
 ECLBLAS_CALL void dpotf2(bool & __isAllResult, size32_t & __lenResult,
                          void * & __result, uint8_t tri, uint32_t r,
                          bool isAllA, size32_t lenA, const void * A,
@@ -74,3 +76,5 @@ ECLBLAS_CALL void dpotf2(bool & __isAllResult, size32_t & __lenResult,
   }
   __result = (void*) new_a;
 }
+
+}

plugins/eclblas/dscal.cpp

@@ -18,6 +18,8 @@
 
 #include "eclblas.hpp"
 
+namespace eclblas {
+
 ECLBLAS_CALL void dscal(bool & __isAllResult, size32_t & __lenResult,
                         void * & __result, uint32_t n, double alpha,
                         bool isAllX, size32_t lenX, const void * x,
@@ -29,3 +31,5 @@ ECLBLAS_CALL void dscal(bool & __isAllResult, size32_t & __lenResult,
   __isAllResult = false;
   __lenResult = lenX;
 }
+
+}

plugins/eclblas/dsyrk.cpp

@@ -19,6 +19,8 @@
 //the update is upper or lower.  C is N by N
 #include "eclblas.hpp"
 
+namespace eclblas {
+
 ECLBLAS_CALL void dsyrk(bool & __isAllResult, size32_t & __lenResult,
                         void * &__result, uint8_t tri, bool transposeA,
                         uint32_t n, uint32_t k, double alpha, bool isAllA,
@@ -45,3 +47,5 @@ ECLBLAS_CALL void dsyrk(bool & __isAllResult, size32_t & __lenResult,
               n, k, alpha, (const double *)a, lda, beta, new_c, n);
   __result = (void*) new_c;
 }
+
+}

plugins/eclblas/dtrsm.cpp

@@ -19,6 +19,8 @@
 //
 #include "eclblas.hpp"
 
+namespace eclblas {
+
 ECLBLAS_CALL void dtrsm(bool & __isAllResult, size32_t & __lenResult,
                         void * & __result, uint8_t side, uint8_t tri,
                         bool transposeA, uint8_t diag, uint32_t m,
@@ -38,3 +40,5 @@ ECLBLAS_CALL void dtrsm(bool & __isAllResult, size32_t & __lenResult,
               m, n, alpha, (const double *)a, lda, new_b, ldb);
   __result = (void*) new_b;
 }
+
+}

plugins/eclblas/eclblas.hpp

@@ -48,8 +48,9 @@
 extern "C" {
 #include <cblas.h>
 }
+namespace eclblas {
 
-extern "C" {
+//extern "C" {
   ECLBLAS_PLUGIN_API bool getECLPluginDefinition(ECLPluginDefinitionBlock *pb);
 
   ECLBLAS_CALL double dasum(uint32_t m, bool isAllX, size32_t lenX, const void * x,
@@ -99,7 +100,8 @@ extern "C" {
   ECLBLAS_CALL void make_diag(bool & __isAllResult, size32_t & __lenResult,
                               void * & __result, size32_t m, double v,
                               bool isAllX, size32_t lenX, const void * x);
-}
+//}
 
+} // namespace
 
 #endif

plugins/eclblas/lib_eclblas.ecllib

@@ -23,32 +23,28 @@ EXPORT blas_Diagonal     := ENUM(UNSIGNED1, UnitTri=1, NotUnitTri=2);
 EXPORT blas_Side         := ENUM(UNSIGNED1, Ax=1, xA=2);
 
 
-EXPORT eclblas := SERVICE : plugin('eclblasplugin'), library('eclblas')
+EXPORT eclblas := SERVICE : plugin('eclblasplugin'), library('eclblas'), namespace('eclblas'), CPP, PURE
   REAL8 dasum(blas_dimension_t m, const blas_matrix_t x, blas_dimension_t incx,
-                blas_dimension_t skipped=0) : C, PURE;
+                blas_dimension_t skipped=0);
   SET OF REAL8 daxpy(blas_dimension_t N, blas_value_t alpha, const blas_matrix_t X,
                  blas_dimension_t incX, blas_matrix_t Y, blas_dimension_t incY,
-                 blas_dimension_t x_skipped=0, blas_dimension_t y_skipped=0)
-                 : C, PURE;
+                 blas_dimension_t x_skipped=0, blas_dimension_t y_skipped=0);
   SET OF REAL8 dgemm(BOOLEAN transposeA, BOOLEAN transposeB,
                  blas_dimension_t M, blas_dimension_t N, blas_dimension_t K,
                  blas_value_t alpha, const blas_matrix_t A, const blas_matrix_t B,
-                 blas_value_t beta=0.0, const blas_matrix_t C=[]) : C, PURE;
-  SET OF REAL8 dgetf2(blas_dimension_t m, blas_dimension_t n, const blas_matrix_t a)
-                 : C, PURE;
-  SET OF REAL8 dpotf2(blas_Triangle tri, blas_dimension_t r, blas_matrix_t A,
-                  BOOLEAN clear=TRUE) : C, PURE;
+                 blas_value_t beta=0.0, const blas_matrix_t C=[]);
+  SET OF REAL8 dgetf2(blas_dimension_t m, blas_dimension_t n, const blas_matrix_t a);
+  SET OF REAL8 dpotf2(blas_Triangle tri, blas_dimension_t r, blas_matrix_t A, BOOLEAN clear=TRUE);
   SET OF REAL8 dscal(blas_dimension_t N, blas_value_t alpha, const blas_matrix_t X,
-                 blas_dimension_t incX, blas_dimension_t skipped=0) : C, PURE;
+                 blas_dimension_t incX, blas_dimension_t skipped=0);
   SET OF REAL8 dsyrk(blas_Triangle tri, BOOLEAN transposeA, blas_dimension_t N,
                  blas_dimension_t K, blas_value_t alpha, const blas_matrix_t A,
-                 blas_value_t beta, const blas_matrix_t C, BOOLEAN clear=FALSE)
-                 : C, PURE;
+                 blas_value_t beta, const blas_matrix_t C, BOOLEAN clear=FALSE);
   SET OF REAL8 dtrsm(blas_Side side, blas_Triangle tri,
                  BOOLEAN transposeA, blas_Diagonal diag,
                  blas_dimension_t M, blas_dimension_t N,  blas_dimension_t lda,
-                 blas_value_t alpha, const blas_matrix_t A, const blas_matrix_t B) : C, PURE;
+                 blas_value_t alpha, const blas_matrix_t A, const blas_matrix_t B);
   SET OF REAL8 Extract_Tri(blas_dimension_t m, blas_dimension_t n, blas_Triangle tri,
-                       blas_Diagonal dt, const blas_matrix_t a) : C, PURE;
-  SET OF REAL8 make_diag(blas_dimension_t m, blas_value_t v=1.0, const blas_matrix_t X=[]) : C, PURE;
+                       blas_Diagonal dt, const blas_matrix_t a);
+  SET OF REAL8 make_diag(blas_dimension_t m, blas_value_t v=1.0, const blas_matrix_t X=[]);
 END;

plugins/eclblas/make_diag.cpp

@@ -18,6 +18,8 @@
 //If the vector is present the diagonal is the product
 #include "eclblas.hpp"
 
+namespace eclblas {
+
 ECLBLAS_CALL void make_diag(bool & __isAllResult, size32_t & __lenResult,
                             void * & __result, uint32_t m, double v,
                             bool isAllX, size32_t lenX, const void * x) {
@@ -39,3 +41,5 @@ ECLBLAS_CALL void make_diag(bool & __isAllResult, size32_t & __lenResult,
   }
   __result = (void*) diag;
 }
+
+}