Sacado_ScalarFlopCounter.hpp

Go to the documentation of this file.

// @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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
// 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_ConfigDefs.h"
#include "Sacado_ScalarFlopCounterTraits.hpp"
#include "Sacado_Base.hpp"
#include "Sacado_SFINAE_Macros.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 = 35 };

      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
        ,CBRT
        ,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 Base< ScalarFlopCounter<T> > {
    public:

      typedef typename RemoveConst<T>::type value_type;

      typedef typename ScalarType<value_type>::type scalar_type;

      template <typename U>
      struct apply {
        typedef ScalarFlopCounter<U> type;
      };


      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() {}

      template <typename S>
      ScalarFlopCounter(const S &v, SACADO_ENABLE_VALUE_CTOR_DECL) : val_(v) {}

      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 Base< ScalarFlopCounter<T> >& aa,                           \
      const Base< ScalarFlopCounter<T> >& bb )                          \
    {                                                                   \
      const ScalarFlopCounter<T>& a = aa.derived();                     \
      const ScalarFlopCounter<T>& b = bb.derived();                     \
      ScalarFlopCounter<T>::incrCounter(OP_NAME);                       \
      return ScalarFlopCounter<T>(a.val() OP b.val());                  \
    }                                                                   \
    template<class T>                                                   \
    ScalarFlopCounter<T> operator OP (                                  \
      const typename ScalarFlopCounter<T>::value_type& a,               \
      const Base< ScalarFlopCounter<T> >& bb )                          \
    {                                                                   \
      const ScalarFlopCounter<T>& b = bb.derived();                     \
      ScalarFlopCounter<T>::incrCounter(OP_NAME);                       \
      return ScalarFlopCounter<T>(a OP b.val());                        \
    }                                                                   \
    template<class T>                                                   \
    ScalarFlopCounter<T> operator OP (                                  \
      const int& a,                                                     \
      const Base< ScalarFlopCounter<T> >& bb )                          \
    {                                                                   \
      const ScalarFlopCounter<T>& b = bb.derived();                     \
      ScalarFlopCounter<T>::incrCounter(OP_NAME);                       \
      return ScalarFlopCounter<T>(a OP b.val());                        \
    }                                                                   \
    template<class T>                                                   \
    ScalarFlopCounter<T> operator OP (                                  \
      const Base< ScalarFlopCounter<T> >& aa,                           \
      const typename ScalarFlopCounter<T>::value_type& b )              \
    {                                                                   \
      const ScalarFlopCounter<T>& a = aa.derived();                     \
      ScalarFlopCounter<T>::incrCounter(OP_NAME);                       \
      return ScalarFlopCounter<T>(a.val() OP b);                        \
    }                                                                   \
    template<class T>                                                   \
    ScalarFlopCounter<T> operator OP (                                  \
      const Base< ScalarFlopCounter<T> >& aa,                           \
      const int& b )                                                    \
    {                                                                   \
      const ScalarFlopCounter<T>& a = aa.derived();                     \
      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 Base< ScalarFlopCounter<T> >& aa )                          \
    {                                                                   \
      const ScalarFlopCounter<T>& a = aa.derived();                     \
      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 Base< ScalarFlopCounter<T> >& aa )                          \
    {                                                                   \
      const ScalarFlopCounter<T>& a = aa.derived();                     \
      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 Base< ScalarFlopCounter<T> >& aa,                           \
      const Base< ScalarFlopCounter<T> >& bb )                          \
    {                                                                   \
      const ScalarFlopCounter<T>& a = aa.derived();                     \
      const ScalarFlopCounter<T>& b = bb.derived();                     \
      ScalarFlopCounter<T>::incrCounter(OP_NAME);                       \
      return ScalarFlopCounter<T>( std::OP( a.val(), b.val() ) );       \
    }                                                                   \
    template<class T>                                                   \
    ScalarFlopCounter<T> OP (                                           \
      const typename ScalarFlopCounter<T>::value_type& a,               \
      const Base< ScalarFlopCounter<T> >& bb )                          \
    {                                                                   \
      const ScalarFlopCounter<T>& b = bb.derived();                     \
      ScalarFlopCounter<T>::incrCounter(OP_NAME);                       \
      return ScalarFlopCounter<T>( std::OP( a, b.val() ) );             \
    }                                                                   \
    template<class T>                                                   \
    ScalarFlopCounter<T> OP (                                           \
      const int& a,                                                     \
      const Base< ScalarFlopCounter<T> >& bb )                          \
    {                                                                   \
      const ScalarFlopCounter<T>& b = bb.derived();                     \
      ScalarFlopCounter<T>::incrCounter(OP_NAME);                       \
      return ScalarFlopCounter<T>( std::OP( a, b.val() ) );             \
    }                                                                   \
    template<class T>                                                   \
    ScalarFlopCounter<T> OP (                                           \
      const Base< ScalarFlopCounter<T> >& aa,                           \
      const typename ScalarFlopCounter<T>::value_type& b )              \
    {                                                                   \
      const ScalarFlopCounter<T>& a = aa.derived();                     \
      ScalarFlopCounter<T>::incrCounter(OP_NAME);                       \
      return ScalarFlopCounter<T>( std::OP( a.val(), b ) );             \
    }                                                                   \
    template<class T>                                                   \
    ScalarFlopCounter<T> OP (                                           \
      const Base< ScalarFlopCounter<T> >& aa,                           \
      const int& b )                                                    \
    {                                                                   \
      const ScalarFlopCounter<T>& a = aa.derived();                     \
      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 Base< ScalarFlopCounter<T> >& aa,                           \
      const Base< ScalarFlopCounter<T> >& bb )                          \
    {                                                                   \
      const ScalarFlopCounter<T>& a = aa.derived();                     \
      const ScalarFlopCounter<T>& b = bb.derived();                     \
      ScalarFlopCounter<T>::incrCounter(OP_NAME);                       \
      return (a.val() OP b.val());                                      \
    }                                                                   \
    template<class T>                                                   \
    bool operator OP (                                                  \
      const typename ScalarFlopCounter<T>::value_type& a,               \
      const Base< ScalarFlopCounter<T> >& bb )                          \
    {                                                                   \
      const ScalarFlopCounter<T>& b = bb.derived();                     \
      ScalarFlopCounter<T>::incrCounter(OP_NAME);                       \
      return (a OP b.val());                                            \
    }                                                                   \
    template<class T>                                                   \
    bool operator OP (                                                  \
      const Base< ScalarFlopCounter<T> >& aa,                           \
      const typename ScalarFlopCounter<T>::value_type& b )              \
    {                                                                   \
      const ScalarFlopCounter<T>& a = aa.derived();                     \
      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(cbrt,FlopCounts::CBRT)
    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