Sacado_ScalarFlopCounter.hpp

Go to the documentation of this file.

// $Id: Sacado_ScalarFlopCounter.hpp,v 1.8 2007/08/01 19:58:54 etphipp Exp $ 
// $Source: /space/CVS/Trilinos/packages/sacado/src/Sacado_ScalarFlopCounter.hpp,v $ 
// @HEADER
// ***********************************************************************
// 
//                           Sacado Package
//                 Copyright (2006) Sandia Corporation
// 
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
// 
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//  
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//  
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
// Questions? Contact David M. Gay (dmgay@sandia.gov) or Eric T. Phipps
// (etphipp@sandia.gov).
// 
// ***********************************************************************
// @HEADER

#ifndef SACADO_SCALAR_FLOP_COUNTER_HPP
#define SACADO_SCALAR_FLOP_COUNTER_HPP

#include "Sacado_ScalarFlopCounterTraits.hpp"
#include <cmath>
#include <algorithm>  // for std::min and std::max
#include <ostream>  // for std::ostream

namespace Sacado {

  namespace FlopCounterPack {

    class  FlopCounts {
    public:

      enum { NUM_OPS = 34 };

      enum EFlopType {
  ASSIGN
  ,PLUS
  ,PLUS_ASSIGN
  ,UNARY_PLUS
  ,MINUS
  ,MINUS_ASSIGN
  ,UNARY_MINUS
  ,MULTIPLY
  ,MULTIPLY_ASSIGN
  ,DIVIDE
  ,DIVIDE_ASSIGN
  ,GREATER_THAN
  ,GREATER_THAN_EQUAL
  ,LESS_THAN
  ,LESS_THAN_EQUAL
  ,EQUAL
  ,EXP
  ,LOG
  ,LOG10
  ,SQRT
  ,COS
  ,SIN
  ,TAN
  ,ACOS
  ,ASIN
  ,ATAN
  ,ATAN2
  ,COSH
  ,SINH
  ,TANH
  ,ABS
  ,POW
  ,MAX
  ,MIN
      };

      enum { NUM_SUMMARY_OPS = 6 };
      
      enum ESummaryFlopType {
  SUMMARY_ASSIGN
  ,SUMMARY_PLUS_MINUS
  ,SUMMARY_MULTIPLY
  ,SUMMARY_DIVIDE
  ,SUMMARY_COMPARISON
  ,SUMMARY_NONLINEAR
      };

      static const char* flopCountsNames[NUM_OPS];

      static const char* summaryFlopCountsNames[NUM_SUMMARY_OPS];

      static unsigned int flopGranularity;

      double flopCounts[NUM_OPS];

      double summaryFlopCounts[NUM_SUMMARY_OPS];

      double totalFlopCount;

      FlopCounts();

      void reset();
      
      void finalize();

      void increment(EFlopType ft);
      
    private:

      ESummaryFlopType getSummaryType(EFlopType ft);

      unsigned int partialFlopCounts[NUM_OPS];

      unsigned int partialSummaryFlopCounts[NUM_SUMMARY_OPS];
    };

    std::ostream& printCountersTable(const int n, 
             const char* names[], 
             const char* abbr[],
             const FlopCounts counts[], 
             std::ostream &out);

    //
    // Member macros
    //

#define SCALAR_FLOP_COUNTER_BINARY_OP_ASSIGN( OP, OP_NAME )         \
    ScalarFlopCounter<T> operator OP ( const ScalarFlopCounter<T>& s )  \
    {                 \
      ScalarFlopCounter<T>::incrCounter(OP_NAME);     \
      val_ OP s.val();              \
      return *this;             \
    }

    template<class T>
    class ScalarFlopCounter {
    public:
  
      
      static void resetCounters() { flopCounts_.reset(); }
      
      static void finalizeCounters() { flopCounts_.finalize(); }

      static FlopCounts getCounters() { return flopCounts_; }

      static std::ostream& printCounters( std::ostream &out ) {
  const int n = 1;
  const char* names[n] = { "Current" };
  const char* abbr[n]  = { "count" };
  const FlopCounts counts[n] = { flopCounts_ };
  return printCountersTable( n, &names[0], &abbr[0], &counts[0], out );
      } 
  


      ScalarFlopCounter() {}

      ScalarFlopCounter(const T &val) : val_(val) {}

      const T& val() const { return val_; }

      void val(const T& a) { val_ = a; }

      SCALAR_FLOP_COUNTER_BINARY_OP_ASSIGN(=,FlopCounts::ASSIGN);
      SCALAR_FLOP_COUNTER_BINARY_OP_ASSIGN(+=,FlopCounts::PLUS_ASSIGN);
      SCALAR_FLOP_COUNTER_BINARY_OP_ASSIGN(-=,FlopCounts::MINUS_ASSIGN);
      SCALAR_FLOP_COUNTER_BINARY_OP_ASSIGN(*=,FlopCounts::MULTIPLY_ASSIGN);
      SCALAR_FLOP_COUNTER_BINARY_OP_ASSIGN(/=,FlopCounts::DIVIDE_ASSIGN);
      

    private:

      // Static members
      static FlopCounts flopCounts_;
 
      // Object members
      T val_;

    public:

      
      static void incrCounter( const FlopCounts::EFlopType& ft ) {
  flopCounts_.increment(ft);
      }

    };

    // Static data members

    template<class T> FlopCounts ScalarFlopCounter<T>::flopCounts_;

    // ////////////////////////////////////////
    // Nonmember operator function macros

#define SCALAR_FLOP_COUNTER_BINARY_OP( OP, OP_NAME )                  \
    template<class T>             \
    ScalarFlopCounter<T> operator OP ( const ScalarFlopCounter<T>& a, \
               const ScalarFlopCounter<T>& b )  \
    {                 \
      ScalarFlopCounter<T>::incrCounter(OP_NAME);     \
      return ScalarFlopCounter<T>(a.val() OP b.val());      \
    }                 \
    template<class T>                   \
    ScalarFlopCounter<T> operator OP ( const T& a,      \
               const ScalarFlopCounter<T>& b )  \
    {                 \
      ScalarFlopCounter<T>::incrCounter(OP_NAME);     \
      return ScalarFlopCounter<T>(a OP b.val());      \
    }                 \
    template<class T>                   \
    ScalarFlopCounter<T> operator OP ( const int& a,      \
               const ScalarFlopCounter<T>& b )  \
    {                 \
      ScalarFlopCounter<T>::incrCounter(OP_NAME);     \
      return ScalarFlopCounter<T>(a OP b.val());      \
    }                 \
    template<class T>                   \
    ScalarFlopCounter<T> operator OP ( const ScalarFlopCounter<T>& a, \
               const T& b )     \
    {                 \
      ScalarFlopCounter<T>::incrCounter(OP_NAME);     \
      return ScalarFlopCounter<T>(a.val() OP b);      \
    }                 \
    template<class T>                   \
    ScalarFlopCounter<T> operator OP ( const ScalarFlopCounter<T>& a, \
               const int& b )     \
    {                 \
      ScalarFlopCounter<T>::incrCounter(OP_NAME);     \
      return ScalarFlopCounter<T>(a.val() OP b);      \
    }

#define SCALAR_FLOP_COUNTER_UNARY_OP( OP, OP_NAME )                 \
    template<class T>             \
    ScalarFlopCounter<T> operator OP ( const ScalarFlopCounter<T>& a )  \
    {                 \
      ScalarFlopCounter<T>::incrCounter(OP_NAME);     \
      return ScalarFlopCounter<T>( OP a.val() );      \
    }

#define SCALAR_FLOP_COUNTER_UNARY_FUNC( OP, OP_NAME )                 \
    template<class T>             \
    ScalarFlopCounter<T> OP( const ScalarFlopCounter<T>& a )    \
    {                 \
      ScalarFlopCounter<T>::incrCounter(OP_NAME);     \
      return ScalarFlopCounter<T>( std::OP( a.val() ) );    \
    }

#define SCALAR_FLOP_COUNTER_BINARY_FUNC( OP, OP_NAME )                  \
    template<class T>             \
    ScalarFlopCounter<T> OP ( const ScalarFlopCounter<T>& a,    \
            const ScalarFlopCounter<T>& b )   \
    {                 \
      ScalarFlopCounter<T>::incrCounter(OP_NAME);     \
      return ScalarFlopCounter<T>( std::OP( a.val(), b.val() ) ); \
    }                 \
    template<class T>                   \
    ScalarFlopCounter<T> OP ( const T& a,       \
            const ScalarFlopCounter<T>& b )   \
    {                 \
      ScalarFlopCounter<T>::incrCounter(OP_NAME);     \
      return ScalarFlopCounter<T>( std::OP( a, b.val() ) );   \
    }                 \
    template<class T>                   \
    ScalarFlopCounter<T> OP ( const int& a,       \
            const ScalarFlopCounter<T>& b )   \
    {                 \
      ScalarFlopCounter<T>::incrCounter(OP_NAME);     \
      return ScalarFlopCounter<T>( std::OP( a, b.val() ) );   \
    }                 \
    template<class T>                   \
    ScalarFlopCounter<T> OP ( const ScalarFlopCounter<T>& a,    \
            const T& b )        \
    {                 \
      ScalarFlopCounter<T>::incrCounter(OP_NAME);     \
      return ScalarFlopCounter<T>( std::OP( a.val(), b ) );   \
    }                 \
    template<class T>                   \
    ScalarFlopCounter<T> OP ( const ScalarFlopCounter<T>& a,    \
            const int& b )        \
    {                 \
      ScalarFlopCounter<T>::incrCounter(OP_NAME);     \
      return ScalarFlopCounter<T>( std::OP(a.val(), b ) );    \
    }
    
#define SCALAR_FLOP_COUNTER_BINARY_COMPARISON_OP( OP, OP_NAME )         \
    template<class T>             \
    bool operator OP ( const ScalarFlopCounter<T>& a,     \
           const ScalarFlopCounter<T>& b )      \
    {                 \
      ScalarFlopCounter<T>::incrCounter(OP_NAME);     \
      return (a.val() OP b.val());          \
    }                 \
    template<class T>                   \
    bool operator OP ( const T& a, const ScalarFlopCounter<T>& b )  \
    {                 \
      ScalarFlopCounter<T>::incrCounter(OP_NAME);     \
      return (a OP b.val());            \
    }                 \
    template<class T>                   \
    bool operator OP ( const ScalarFlopCounter<T>& a, const T& b )  \
    {                 \
      ScalarFlopCounter<T>::incrCounter(OP_NAME);     \
      return (a.val() OP b);            \
    }

    // ////////////////////////////////////////////
    // Nonmember operator and other functions
    
    // Binary operations
    SCALAR_FLOP_COUNTER_BINARY_OP(+,FlopCounts::PLUS)
    SCALAR_FLOP_COUNTER_BINARY_OP(-,FlopCounts::MINUS)
    SCALAR_FLOP_COUNTER_BINARY_OP(*,FlopCounts::MULTIPLY)
    SCALAR_FLOP_COUNTER_BINARY_OP(/,FlopCounts::DIVIDE)

    // Unary operations
    SCALAR_FLOP_COUNTER_UNARY_OP(+,FlopCounts::UNARY_PLUS)
    SCALAR_FLOP_COUNTER_UNARY_OP(-,FlopCounts::UNARY_MINUS)

    // Unary functions
    SCALAR_FLOP_COUNTER_UNARY_FUNC(exp,FlopCounts::EXP)
    SCALAR_FLOP_COUNTER_UNARY_FUNC(log,FlopCounts::LOG)
    SCALAR_FLOP_COUNTER_UNARY_FUNC(log10,FlopCounts::LOG10)
    SCALAR_FLOP_COUNTER_UNARY_FUNC(sqrt,FlopCounts::SQRT) 
    SCALAR_FLOP_COUNTER_UNARY_FUNC(cos,FlopCounts::COS)
    SCALAR_FLOP_COUNTER_UNARY_FUNC(sin,FlopCounts::SIN)
    SCALAR_FLOP_COUNTER_UNARY_FUNC(tan,FlopCounts::TAN)
    SCALAR_FLOP_COUNTER_UNARY_FUNC(acos,FlopCounts::ACOS)
    SCALAR_FLOP_COUNTER_UNARY_FUNC(asin,FlopCounts::ASIN)
    SCALAR_FLOP_COUNTER_UNARY_FUNC(atan,FlopCounts::ATAN)
    SCALAR_FLOP_COUNTER_UNARY_FUNC(cosh,FlopCounts::COSH)
    SCALAR_FLOP_COUNTER_UNARY_FUNC(sinh,FlopCounts::SINH)
    SCALAR_FLOP_COUNTER_UNARY_FUNC(tanh,FlopCounts::TANH)
    SCALAR_FLOP_COUNTER_UNARY_FUNC(abs,FlopCounts::ABS)
    SCALAR_FLOP_COUNTER_UNARY_FUNC(fabs,FlopCounts::ABS)

    // Binary functions
    SCALAR_FLOP_COUNTER_BINARY_FUNC(atan2,FlopCounts::ATAN2)
    SCALAR_FLOP_COUNTER_BINARY_FUNC(pow,FlopCounts::POW)
    SCALAR_FLOP_COUNTER_BINARY_FUNC(max,FlopCounts::MAX)
    SCALAR_FLOP_COUNTER_BINARY_FUNC(min,FlopCounts::MIN)

    // Comparison
    SCALAR_FLOP_COUNTER_BINARY_COMPARISON_OP(>,FlopCounts::GREATER_THAN)
    SCALAR_FLOP_COUNTER_BINARY_COMPARISON_OP(>=,FlopCounts::GREATER_THAN_EQUAL)
    SCALAR_FLOP_COUNTER_BINARY_COMPARISON_OP(<,FlopCounts::LESS_THAN)
    SCALAR_FLOP_COUNTER_BINARY_COMPARISON_OP(<=,FlopCounts::LESS_THAN_EQUAL)
    SCALAR_FLOP_COUNTER_BINARY_COMPARISON_OP(==,FlopCounts::EQUAL)

  } // namespace FlopCounterPack
} // namespace Sacado

#endif // SACADO_SCALAR_FLOP_COUNTER_HPP

---