From 7bbcae5a18ed3655456318adf96de988d6edb1bd Mon Sep 17 00:00:00 2001 From: Dipal M Zambare Date: Mon, 10 Aug 2020 12:17:09 +0530 Subject: [PATCH] Fixed build issue in cpp testsuite. This issue was caused by incorrect merging of cpp and testcpp files. Change-Id: Idc40fbdaa55b6052a6a061d2d3e5cfae76b99916 AMD-Internal: [CPUPL-1067] --- cpp/blis.hh | 6 +- cpp/blis_util.hh | 226 ------------------------------------------- testcpp/test_gemm.cc | 84 ---------------- 3 files changed, 1 insertion(+), 315 deletions(-) delete mode 100644 cpp/blis_util.hh diff --git a/cpp/blis.hh b/cpp/blis.hh index 602c094fd..39dc25864 100644 --- a/cpp/blis.hh +++ b/cpp/blis.hh @@ -27,7 +27,6 @@ #define BLIS_HH #include "cblas.hh" -#include "blis_util.hh" namespace blis { @@ -406,10 +405,7 @@ TR dot( T const *x, int64_t incx, T const *y, int64_t incy ) { - if((std::is_same::value)&(std::is_same::value)) - return cblas_dsdot( n, x, incx, y, incy ); - else - return cblas_dot( n, x, incx, y, incy ); + return cblas_dot( n, x, incx, y, incy ); } /*! \brief Performs the dot product of two complex vectors diff --git a/cpp/blis_util.hh b/cpp/blis_util.hh deleted file mode 100644 index ebe4274e6..000000000 --- a/cpp/blis_util.hh +++ /dev/null @@ -1,226 +0,0 @@ -#ifndef BLIS_UTIL_HH -#define BLIS_UTIL_HH - -#include -#include - -namespace blis { - -// ----------------------------------------------------------------------------- -// Extend real, imag, conj to other datatypes. -template< typename T > -inline T real( T x ) { return x; } - -template< typename T > -inline T imag( T x ) { return 0; } - -template< typename T > -inline T conj( T x ) { return x; } - -// ----------------------------------------------------------------------------- -// 1-norm absolute value, |Re(x)| + |Im(x)| -template< typename T > -T abs1( T x ) -{ - return std::abs( x ); -} - -template< typename T > -T abs1( std::complex x ) -{ - return std::abs( real(x) ) + std::abs( imag(x) ); -} - -// ----------------------------------------------------------------------------- -// common_type_t is defined in C++14; here's a C++11 definition -#if __cplusplus >= 201402L - using std::common_type_t; - using std::decay_t; -#else - template< typename... Ts > - using common_type_t = typename std::common_type< Ts... >::type; - - template< typename... Ts > - using decay_t = typename std::decay< Ts... >::type; -#endif - -//------------------------------------------------------------------------------ -/// True if T is std::complex for some type T2. -template -struct is_complex: - std::integral_constant -{}; - -// specialize for std::complex -template -struct is_complex< std::complex >: - std::integral_constant -{}; - -// ----------------------------------------------------------------------------- -// Based on C++14 common_type implementation from -// http://www.cplusplus.com/reference/type_traits/common_type/ -// Adds promotion of complex types based on the common type of the associated -// real types. This fixes various cases: -// -// std::common_type_t< double, complex > is complex (wrong) -// scalar_type< double, complex > is complex (right) -// -// std::common_type_t< int, complex > is not defined (compile error) -// scalar_type< int, complex > is complex (right) - -// for zero types -template< typename... Types > -struct scalar_type_traits; - -// define scalar_type<> type alias -template< typename... Types > -using scalar_type = typename scalar_type_traits< Types... >::type; - -// for one type -template< typename T > -struct scalar_type_traits< T > -{ - using type = decay_t; -}; - -// for two types -// relies on type of ?: operator being the common type of its two arguments -template< typename T1, typename T2 > -struct scalar_type_traits< T1, T2 > -{ - using type = decay_t< decltype( true ? std::declval() : std::declval() ) >; -}; - -// for either or both complex, -// find common type of associated real types, then add complex -template< typename T1, typename T2 > -struct scalar_type_traits< std::complex, T2 > -{ - using type = std::complex< common_type_t< T1, T2 > >; -}; - -template< typename T1, typename T2 > -struct scalar_type_traits< T1, std::complex > -{ - using type = std::complex< common_type_t< T1, T2 > >; -}; - -template< typename T1, typename T2 > -struct scalar_type_traits< std::complex, std::complex > -{ - using type = std::complex< common_type_t< T1, T2 > >; -}; - -// for three or more types -template< typename T1, typename T2, typename... Types > -struct scalar_type_traits< T1, T2, Types... > -{ - using type = scalar_type< scalar_type< T1, T2 >, Types... >; -}; - -// ----------------------------------------------------------------------------- -// for any combination of types, determine associated real, scalar, -// and complex types. -// -// real_type< float > is float -// real_type< float, double, complex > is double -// -// scalar_type< float > is float -// scalar_type< float, complex > is complex -// scalar_type< float, double, complex > is complex -// -// complex_type< float > is complex -// complex_type< float, double > is complex -// complex_type< float, double, complex > is complex - -// for zero types -template< typename... Types > -struct real_type_traits; - -// define real_type<> type alias -template< typename... Types > -using real_type = typename real_type_traits< Types... >::real_t; - -// define complex_type<> type alias -template< typename... Types > -using complex_type = std::complex< real_type< Types... > >; - -// for one type -template< typename T > -struct real_type_traits -{ - using real_t = T; -}; - -// for one complex type, strip complex -template< typename T > -struct real_type_traits< std::complex > -{ - using real_t = T; -}; - -// for two or more types -template< typename T1, typename... Types > -struct real_type_traits< T1, Types... > -{ - using real_t = scalar_type< real_type, real_type< Types... > >; -}; - -// ----------------------------------------------------------------------------- -// max that works with different data types: int64_t = max( int, int64_t ) -// and any number of arguments: max( a, b, c, d ) - -// one argument -template< typename T > -T max( T x ) -{ - return x; -} - -// two arguments -template< typename T1, typename T2 > -scalar_type< T1, T2 > - max( T1 x, T2 y ) -{ - return (x >= y ? x : y); -} - -// three or more arguments -template< typename T1, typename... Types > -scalar_type< T1, Types... > - max( T1 first, Types... args ) -{ - return max( first, max( args... ) ); -} - -// ----------------------------------------------------------------------------- -// min that works with different data types: int64_t = min( int, int64_t ) -// and any number of arguments: min( a, b, c, d ) - -// one argument -template< typename T > -T min( T x ) -{ - return x; -} - -// two arguments -template< typename T1, typename T2 > -scalar_type< T1, T2 > - min( T1 x, T2 y ) -{ - return (x <= y ? x : y); -} - -// three or more arguments -template< typename T1, typename... Types > -scalar_type< T1, Types... > - min( T1 first, Types... args ) -{ - return min( first, min( args... ) ); -} - -} // namespace blis - -#endif // #ifndef BLIS_UTIL_HH diff --git a/testcpp/test_gemm.cc b/testcpp/test_gemm.cc index 12d235e13..2fe6e55a7 100644 --- a/testcpp/test_gemm.cc +++ b/testcpp/test_gemm.cc @@ -33,14 +33,8 @@ #include #include -<<<<<<< HEAD #include "blis.hh" #include "test.hh" -======= -#include -#include -#include "blis.hh" ->>>>>>> Code Cleanup done; Test code updated to add performance measurement using namespace blis; using namespace std; @@ -160,88 +154,10 @@ void test_gemm( ) // ----------------------------------------------------------------------------- int main( int argc, char** argv ) { -<<<<<<< HEAD test_gemm( ); test_gemm( ); test_gemm>( ); test_gemm>( ); return 0; -======= - int M, N, K, lda, ldb, ldc; - double a_d[DIM * DIM] = { 1.111, 2.222, 3.333, 4.444 }; - double b_d[DIM * DIM] = { 5.555, 6.666, 7.777, 8.888 }; - double c_d[DIM * DIM]; - double alpha_d, beta_d; - float a_f[DIM * DIM] = { 1.1, 2.2, 3.3, 4.4 }; - float b_f[DIM * DIM] = { 5.5, 6.6, 7.7, 8.8 }; - float c_f[DIM * DIM]; - float alpha_f, beta_f; - std::complex a_c[DIM * DIM]={{1, 2},{3, 4},{5,6},{7,8}}; - std::complex b_c[DIM * DIM]={{1, 2},{3, 4},{5,6},{7,8}}; - std::complex c_c[DIM * DIM]; - std::complex alpha_c, beta_c; - std::complex a_z[DIM * DIM]={{1.1, 2.2},{3.3, 4.4},{5.5,6.6},{7.7,8.8}}; - std::complex b_z[DIM * DIM]={{1.1, 2.2},{3.3, 4.4},{5.5,6.6},{7.7,8.8}}; - std::complex c_z[DIM * DIM]; - std::complex alpha_z, beta_z; - M = DIM; - N = M; - K = M; - lda = M; - ldb = K; - ldc = M; - alpha_d = 1.0; - beta_d = 0.0; - alpha_f = 1.0; - beta_f = 0.0; - alpha_c = {1.0,1.0}; - beta_c = {0.0,0.0}; - alpha_z = {1.0,1.0}; - beta_z = {0.0,0.0}; - - /*cblis_sgemm*/ - cout<<"a_f= \n"; - print_matrix(a_f , M , K); - cout<<"b_f= \n"; - print_matrix(b_f , K , N); - blis::gemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, M, N, K, alpha_f, a_f, - lda, b_f, ldb, beta_f, c_f, ldc); - cout<<"c_f= \n"; - print_matrix(c_f , M , N); - - - /*cblis_dgemm*/ - printf("a_d = \n"); - print_matrix(a_d , M , K); - printf("b_d = \n"); - print_matrix(b_d , K , N); - blis::gemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, M, N, K, alpha_d, a_d, - lda, b_d, ldb, beta_d, c_d, ldc); - printf("c_d = \n"); - print_matrix(c_d , M , N); - - - /*cblis_cgemm*/ - printf("a_c = \n"); - print_matrix>(a_c , M , K); - printf("b_c = \n"); - print_matrix>(b_c , K , N); - blis::gemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, M, N, K, alpha_c, a_c, - lda, b_c, ldb, beta_c, c_c, ldc); - printf("c_c = \n"); - print_matrix>(c_c , M , N); - - - /*cblis_zgemm*/ - printf("a_z = \n"); - print_matrix>(a_z , M , K); - printf("b_z = \n"); - print_matrix>(b_z , K , N); - blis::gemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, M, N, K, alpha_z, a_z, - lda, b_z, ldb, beta_z, c_z, ldc); - printf("c_z = \n"); - print_matrix>(c_z , M , N); - return 0; ->>>>>>> Code Cleanup done; Test code updated to add performance measurement }