Merge pull request #80 from adanalis/master

Added an SDE that counts flops to BLAS++.

include/blas/counter.hh

@@ -9,6 +9,7 @@
 #include "blas/defines.h"
 #include "blas/util.hh"
 #include "blas/flops.hh"
+#include <atomic>
 
 #ifdef BLAS_HAVE_PAPI
     #include "sde_lib.h"
@@ -230,13 +231,12 @@ public:
     };
 
     //--------------------------------------------------------------------------
-    /// Initializes PAPI counting set on first call.
-    /// Without PAPI, returns null.
-    /// @return PAPI counting set.
-    static CountingSet* get()
+    /// Initializes PAPI counters on first call.
+    /// @return reference to counter class.
+    static counter &get()
     {
         static counter s_cnt;
-        return s_cnt.set_;
+        return s_cnt;
     }
 
     //--------------------------------------------------------------------------
@@ -246,7 +246,7 @@ public:
     static void insert( T element, Id id )
     {
         #ifdef BLAS_HAVE_PAPI
-            get()->insert( element, uint32_t( id ) );
+            get().set_->insert( element, uint32_t( id ) );
         #endif
     }
 
@@ -258,10 +258,33 @@ public:
     static void insert( size_t hashable_size, T element, Id id )
     {
         #ifdef BLAS_HAVE_PAPI
-            get()->insert( hashable_size, element, uint32_t( id ) );
+            get().set_->insert( hashable_size, element, uint32_t( id ) );
         #endif
     }
 
+    //--------------------------------------------------------------------------
+    /// Get the current flop count.
+    /// Without PAPI, returns zero.
+    static long long int get_flop_count(std::atomic<long long> *atmc_var)
+    {
+        long long int fp = 0;
+        #ifdef BLAS_HAVE_PAPI
+            fp = *atmc_var;
+        #endif
+        return fp;
+    }
+
+    //--------------------------------------------------------------------------
+    /// Increment the current flop count.
+    /// Without PAPI, does nothing.
+    static void inc_flop_count(long long int fp)
+    {
+        #ifdef BLAS_HAVE_PAPI
+            get().total_flop_count_ += fp;
+        #endif
+        return;
+    }
+
     //--------------------------------------------------------------------------
     /// TODO
     /// Prints out all elements in the BLAS++ counting set.
@@ -707,17 +730,21 @@ public:
 
 private:
     //--------------------------------------------------------------------------
-    /// Constructor initializes PAPI counting set on first call to get().
-    counter():
-        set_( nullptr )
+    /// Constructor initializes SDEs on first call to get().
+    counter()
     {
+        set_ = nullptr;
+        total_flop_count_ = -1;
         #ifdef BLAS_HAVE_PAPI
             papi_sde::PapiSde sde( "blas" );
             set_ = sde.create_counting_set( "counter" );
+            total_flop_count_ = 0;
+            sde.register_counter_cb("flops", PAPI_SDE_RO|PAPI_SDE_DELTA, get_flop_count, total_flop_count_);
         #endif
     }
 
     CountingSet* set_;
+    std::atomic<long long> total_flop_count_;
 };  // class count
 
 }  // namespace blas

src/asum.cc

@@ -81,6 +81,9 @@ real_type<scalar_t> asum(
         memset( &element, 0, sizeof( element ) );
         element = { n };
         counter::insert( element, counter::Id::asum );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::asum( n );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     // convert arguments

src/axpy.cc

@@ -98,6 +98,9 @@ void axpy(
         memset( &element, 0, sizeof( element ) );
         element = { n };
         counter::insert( element, counter::Id::axpy );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::axpy( n );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     // convert arguments

src/copy.cc

@@ -91,6 +91,9 @@ void copy(
         memset( &element, 0, sizeof( element ) );
         element = { n };
         counter::insert( element, counter::Id::copy );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::copy( n );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     // convert arguments

src/device_batch_gemm.cc

@@ -90,6 +90,9 @@ void gemm(
             memset( &element, 0, sizeof( element ) );
             element = { transA_, transB_, m_, n_, k_, batch_size };
             counter::insert( element, counter::Id::dev_batch_gemm );
+
+            double gflops = 1e9 * blas::Gflop< scalar_t >::gemm( m, n, k );
+            counter::inc_flop_count( (long long int)gflops );
         #endif
 
         // gemm needs 3 arrays (A, B, and C).

src/device_batch_hemm.cc

@@ -64,6 +64,9 @@ void hemm(
         memset( &element, 0, sizeof( element ) );
         element = { batch_size };
         counter::insert( element, counter::Id::dev_batch_hemm );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::hemm( side, m, n );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     queue.fork();

src/device_copy.cc

@@ -42,6 +42,9 @@ void copy(
         memset( &element, 0, sizeof( element ) );
         element = { n };
         counter::insert( element, counter::Id::dev_copy );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::copy( n );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     // convert arguments

src/device_dot.cc

@@ -44,6 +44,9 @@ void dot(
         memset( &element, 0, sizeof( element ) );
         element = { n };
         counter::insert( element, counter::Id::dev_dot );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::dot( n );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     // convert arguments

src/device_gemm.cc

@@ -83,6 +83,9 @@ void gemm(
         memset( &element, 0, sizeof( element ) );
         element = { transA, transB, m, n, k };
         counter::insert( element, counter::Id::dev_gemm );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::gemm( m, n, k );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     // convert arguments

src/device_hemm.cc

@@ -71,6 +71,9 @@ void hemm(
         memset( &element, 0, sizeof( element ) );
         element = { side, uplo, m, n };
         counter::insert( element, counter::Id::dev_hemm );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::hemm( side, m, n );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     // convert arguments

src/device_her2k.cc

@@ -64,6 +64,9 @@ void her2k(
         memset( &element, 0, sizeof( element ) );
         element = { uplo, trans, n, k };
         counter::insert( element, counter::Id::dev_her2k );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::her2k( n, k );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     // convert arguments

src/device_herk.cc

@@ -58,6 +58,9 @@ void herk(
         memset( &element, 0, sizeof( element ) );
         element = { uplo, trans, n, k };
         counter::insert( element, counter::Id::dev_herk );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::herk( n, k );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     // convert arguments

src/device_nrm2.cc

@@ -41,6 +41,9 @@ void nrm2(
         memset( &element, 0, sizeof( element ) );
         element = { n };
         counter::insert( element, counter::Id::dev_nrm2 );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::nrm2( n );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     // convert arguments

src/device_scal.cc

@@ -41,6 +41,9 @@ void scal(
         memset( &element, 0, sizeof( element ) );
         element = { n };
         counter::insert( element, counter::Id::dev_scal );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::scal( n );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     // convert arguments

src/device_swap.cc

@@ -42,6 +42,9 @@ void swap(
         memset( &element, 0, sizeof( element ) );
         element = { n };
         counter::insert( element, counter::Id::dev_swap );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::swap( n );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     // convert arguments

src/device_symm.cc

@@ -71,6 +71,9 @@ void symm(
         memset( &element, 0, sizeof( element ) );
         element = { side, uplo, m, n };
         counter::insert( element, counter::Id::dev_symm );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::symm( side, m, n );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     // convert arguments

src/device_syr2k.cc

@@ -72,6 +72,9 @@ void syr2k(
         memset( &element, 0, sizeof( element ) );
         element = { uplo, trans, n, k };
         counter::insert( element, counter::Id::dev_syr2k );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::syr2k( n, k );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     // convert arguments

src/device_syrk.cc

@@ -67,6 +67,9 @@ void syrk(
         memset( &element, 0, sizeof( element ) );
         element = { uplo, trans, n, k };
         counter::insert( element, counter::Id::dev_syrk );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::syrk( n, k );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     // convert arguments

src/device_trmm.cc

@@ -70,6 +70,9 @@ void trmm(
         memset( &element, 0, sizeof( element ) );
         element = { side, uplo, trans, diag, m, n };
         counter::insert( element, counter::Id::dev_trmm );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::trmm( side, m, n );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     // convert arguments

src/device_trsm.cc

@@ -70,6 +70,9 @@ void trsm(
         memset( &element, 0, sizeof( element ) );
         element = { side, uplo, trans, diag, m, n };
         counter::insert( element, counter::Id::dev_trsm );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::trsm( side, m, n );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     // convert arguments

src/dot.cc

@@ -171,6 +171,9 @@ scalar_t dot(
         memset( &element, 0, sizeof( element ) );
         element = { n };
         counter::insert( element, counter::Id::dot );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::dot( n );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     // convert arguments

src/gemm.cc

@@ -156,6 +156,9 @@ void gemm(
         memset( &element, 0, sizeof( element ) );
         element = { transA, transB, m, n, k };
         counter::insert( element, counter::Id::gemm );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::gemm( m, n, k );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     // convert arguments
@@ -274,6 +277,7 @@ papi_handle_t papi_sde_hook_list_events( papi_sde_fptr_struct_t* fptr_struct )
     papi_handle_t tmp_handle;
     tmp_handle = fptr_struct->init( "blas" );
     fptr_struct->create_counting_set( tmp_handle, "counter", NULL );
+    fptr_struct->register_counter_cb( tmp_handle, "flops", PAPI_SDE_RO|PAPI_SDE_DELTA, PAPI_SDE_long_long, NULL, NULL);
     return tmp_handle;
 }
 

src/gemv.cc

@@ -134,6 +134,9 @@ void gemv(
         memset( &element, 0, sizeof( element ) );
         element = { trans, m, n };
         counter::insert( element, counter::Id::gemv );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::gemv( m, n );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     // convert arguments

src/ger.cc

@@ -158,6 +158,9 @@ void ger(
         memset( &element, 0, sizeof( element ) );
         element = { m, n };
         counter::insert( element, counter::Id::ger );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::ger( m, n );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     // convert arguments
@@ -222,6 +225,9 @@ void geru(
         memset( &element, 0, sizeof( element ) );
         element = { m, n };
         counter::insert( element, counter::Id::geru );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::ger( m, n );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     blas_int m_    = to_blas_int( m );

src/hemm.cc

@@ -114,6 +114,9 @@ void hemm(
         memset( &element, 0, sizeof( element ) );
         element = { side, uplo, m, n };
         counter::insert( element, counter::Id::hemm );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::hemm( side, m, n );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     // convert arguments

src/hemv.cc

@@ -95,6 +95,9 @@ void hemv(
         memset( &element, 0, sizeof( element ) );
         element = { uplo, n };
         counter::insert( element, counter::Id::hemv );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::hemv( n );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     // convert arguments

src/her.cc

@@ -82,6 +82,9 @@ void her(
         memset( &element, 0, sizeof( element ) );
         element = { uplo, n };
         counter::insert( element, counter::Id::her );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::her( n );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     // convert arguments

src/her2.cc

@@ -88,6 +88,9 @@ void her2(
         memset( &element, 0, sizeof( element ) );
         element = { uplo, n };
         counter::insert( element, counter::Id::her2 );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::her2( n );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     // convert arguments

src/her2k.cc

@@ -107,6 +107,9 @@ void her2k(
         memset( &element, 0, sizeof( element ) );
         element = { uplo, trans, n, k };
         counter::insert( element, counter::Id::her2k );
+
+        double gflops = 1e9 * blas::Gflop< scalar_t >::her2k( n, k );
+        counter::inc_flop_count( (long long int)gflops );
     #endif
 
     // convert arguments