Kokkos_ExecPolicy.hpp

/*
//@HEADER
// ************************************************************************
//
//   Kokkos: Manycore Performance-Portable Multidimensional Arrays
//              Copyright (2012) Sandia Corporation
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions?  Contact  H. Carter Edwards (hcedwar@sandia.gov)
//
// ************************************************************************
//@HEADER
*/

#ifndef KOKKOS_EXECPOLICY_HPP
#define KOKKOS_EXECPOLICY_HPP

#include <Kokkos_Core_fwd.hpp>
#include <impl/Kokkos_Traits.hpp>
#include <impl/Kokkos_StaticAssert.hpp>
#include <impl/Kokkos_Tags.hpp>

//----------------------------------------------------------------------------

namespace Kokkos {

template< class Arg0 = void , class Arg1 = void , class Arg2 = void 
        , class ExecSpace =
          // The first argument is the execution space,
          // otherwise use the default execution space.
          typename Impl::if_c< Impl::is_execution_space< Arg0 >::value , Arg0
                             , Kokkos::DefaultExecutionSpace >::type
        >
class RangePolicy {
private:

  // Default integral type and blocking factor:
  typedef int DefaultIntType ;
  enum { DefaultIntValue = 8 };

  enum { Arg0_Void = Impl::is_same< Arg0 , void >::value };
  enum { Arg1_Void = Impl::is_same< Arg1 , void >::value };
  enum { Arg2_Void = Impl::is_same< Arg2 , void >::value };

  enum { Arg0_ExecSpace = Impl::is_execution_space< Arg0 >::value };

  enum { Arg0_IntConst = Impl::is_integral_constant< Arg0 >::value };
  enum { Arg1_IntConst = Impl::is_integral_constant< Arg1 >::value };
  enum { Arg2_IntConst = Impl::is_integral_constant< Arg2 >::value };

  enum { Arg0_IntType = Impl::is_integral< Arg0 >::value };
  enum { Arg1_IntType = Impl::is_integral< Arg1 >::value };
  enum { Arg2_IntType = Impl::is_integral< Arg2 >::value };

  enum { Arg0_WorkTag = ! Arg0_ExecSpace && ! Arg0_IntConst && ! Arg0_IntType && ! Arg0_Void };
  enum { Arg1_WorkTag =   Arg0_ExecSpace && ! Arg1_IntConst && ! Arg1_IntType && ! Arg1_Void };

  enum { ArgOption_OK = Impl::StaticAssert< (
    ( Arg0_ExecSpace && Arg1_WorkTag && ( Arg2_IntConst || Arg2_IntType ) ) ||
    ( Arg0_ExecSpace && Arg1_WorkTag && Arg2_Void ) ||
    ( Arg0_ExecSpace && ( Arg1_IntConst || Arg2_IntType ) && Arg2_Void ) ||
    ( Arg0_ExecSpace && Arg1_Void && Arg2_Void ) ||
    ( Arg0_WorkTag && ( Arg1_IntConst || Arg2_IntType ) && Arg2_Void ) ||
    ( Arg0_WorkTag && Arg1_Void && Arg2_Void ) ||
    ( ( Arg0_IntConst || Arg0_IntType ) && Arg1_Void && Arg2_Void ) ||
    ( Arg0_Void && Arg1_Void && Arg2_Void )
    ) >::value };

  // The work argument tag is the first or second argument
  typedef typename Impl::if_c< Arg0_WorkTag , Arg0 ,
          typename Impl::if_c< Arg1_WorkTag , Arg1 , void
          >::type >::type
    WorkTag ;

  enum { Granularity = Arg0_IntConst ? unsigned(Impl::is_integral_constant<Arg0>::integral_value) : (
                       Arg1_IntConst ? unsigned(Impl::is_integral_constant<Arg1>::integral_value) : (
                       Arg2_IntConst ? unsigned(Impl::is_integral_constant<Arg2>::integral_value) : (
                                       unsigned(DefaultIntValue) ))) };

  // Only accept the integral type if the blocking is a power of two
  typedef typename Impl::enable_if< Impl::is_power_of_two< Granularity >::value ,
            typename Impl::if_c< Arg0_IntType , Arg0 ,
            typename Impl::if_c< Arg1_IntType , Arg1 ,
            typename Impl::if_c< Arg2_IntType , Arg2 ,
            typename Impl::if_c< Arg0_IntConst , typename Impl::is_integral_constant<Arg0>::integral_type ,
            typename Impl::if_c< Arg1_IntConst , typename Impl::is_integral_constant<Arg1>::integral_type ,
            typename Impl::if_c< Arg2_IntConst , typename Impl::is_integral_constant<Arg2>::integral_type ,
                                                 DefaultIntType
            >::type >::type >::type
            >::type >::type >::type
          >::type
    IntType ;

  enum { GranularityMask = IntType(Granularity) - 1 };

  IntType m_begin ;
  IntType m_end ;

public:

  typedef Impl::ExecutionPolicyTag   kokkos_tag ;      
  typedef ExecSpace                  execution_space ;
  typedef RangePolicy                execution_policy ;
  typedef IntType                    member_type ;
  typedef WorkTag                    work_tag ;

  KOKKOS_INLINE_FUNCTION member_type begin() const { return m_begin ; }
  KOKKOS_INLINE_FUNCTION member_type end()   const { return m_end ; }

  KOKKOS_INLINE_FUNCTION RangePolicy() : m_begin(0), m_end(0) {}

  KOKKOS_INLINE_FUNCTION
  RangePolicy( const member_type work_begin
             , const member_type work_end
             )
    : m_begin( work_begin < work_end ? work_begin : 0 )
    , m_end(   work_begin < work_end ? work_end : 0 )
    {}

  KOKKOS_INLINE_FUNCTION
  RangePolicy( const RangePolicy & range
             , const int part_rank
             , const int part_size
             )
    : m_begin(0), m_end(0)
    {
      if ( part_size ) {

        // Split evenly among partitions, then round up to the granularity.
        const member_type work_part =
          ( ( ( ( range.m_end - range.m_begin ) + ( part_size - 1 ) ) / part_size ) + GranularityMask ) & ~member_type(GranularityMask);

        m_begin = range.m_begin + work_part * part_rank ;
        m_end   = m_begin       + work_part ;

        if ( range.m_end < m_begin ) m_begin = range.m_end ;
        if ( range.m_end < m_end )   m_end   = range.m_end ;
      }
    }
};

} // namespace Kokkos

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------

namespace Kokkos {

template< class Arg0 = void
        , class Arg1 = void
        , class ExecSpace =
          // If the first argument is not an execution
          // then use the default execution space.
          typename Impl::if_c< Impl::is_execution_space< Arg0 >::value , Arg0
                             , Kokkos::DefaultExecutionSpace >::type
        >
class TeamPolicy {
private:

  enum { Arg0_ExecSpace = Impl::is_execution_space< Arg0 >::value };
  enum { Arg1_Void      = Impl::is_same< Arg1 , void >::value };
  enum { ArgOption_OK   = Impl::StaticAssert< ( Arg0_ExecSpace || Arg1_Void ) >::value };

  typedef typename Impl::if_c< Arg0_ExecSpace , Arg1 , Arg0 >::type WorkTag ;

public:

  typedef Impl::ExecutionPolicyTag   kokkos_tag ;       
  typedef ExecSpace                  execution_space ;  
  typedef TeamPolicy                 execution_policy ;
  typedef WorkTag                    work_tag ;

  template< class FunctorType >
  static int team_size_max( const FunctorType & );

  TeamPolicy( execution_space & , int league_size_request , int team_size_request );

  TeamPolicy( int league_size_request , int team_size_request );

  KOKKOS_INLINE_FUNCTION int league_size() const ;

  KOKKOS_INLINE_FUNCTION int team_size() const ;

  struct member_type {

    KOKKOS_INLINE_FUNCTION
    typename execution_space::scratch_memory_space team_shmem() const ;

    KOKKOS_INLINE_FUNCTION int league_rank() const ;

    KOKKOS_INLINE_FUNCTION int league_size() const ;

    KOKKOS_INLINE_FUNCTION int team_rank() const ;

    KOKKOS_INLINE_FUNCTION int team_size() const ;

    KOKKOS_INLINE_FUNCTION void team_barrier() const ;

    template< class JoinOp >
    KOKKOS_INLINE_FUNCTION
    typename JoinOp::value_type team_reduce( const typename JoinOp::value_type
                                           , const JoinOp & ) const ;

    template< typename Type >
    KOKKOS_INLINE_FUNCTION Type team_scan( const Type & value ) const ;

    template< typename Type >
    KOKKOS_INLINE_FUNCTION Type team_scan( const Type & value , Type * const global_accum ) const ;
  };
};

} // namespace Kokkos

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------

namespace Kokkos {

template< unsigned VectorLength
        , class Arg0 = void
        , class Arg1 = void
        , class ExecSpace =
          // If the second argument is not an execution
          // then use the default execution space.
          typename Impl::if_c< Impl::is_execution_space< Arg0 >::value , Arg0
                             , Kokkos::DefaultExecutionSpace >::type
        >
class TeamVectorPolicy {
private:
  enum { Arg0_ExecSpace = Impl::is_execution_space< Arg0 >::value };
  enum { Arg1_Void      = Impl::is_same< Arg1 , void >::value };
  enum { ArgOption_OK   = Impl::StaticAssert< ( Arg0_ExecSpace || Arg1_Void ) >::value };

  typedef typename Impl::if_c< Arg0_ExecSpace , Arg1 , Arg0 >::type WorkTag ;

public:

  typedef Impl::ExecutionPolicyTag   kokkos_tag ;      
  typedef ExecSpace                  execution_space ; 
  typedef TeamVectorPolicy           execution_policy ;
  typedef WorkTag                    work_tag ;

  template< class FunctorType >
  static int team_size_max( const FunctorType & );

  TeamVectorPolicy( execution_space & , int league_size_request , int team_size_request );

  TeamVectorPolicy( int league_size_request , int team_size_request );

  KOKKOS_INLINE_FUNCTION int league_size() const ;

  KOKKOS_INLINE_FUNCTION int team_size() const ;

  struct member_type {

    KOKKOS_INLINE_FUNCTION
    typename execution_space::scratch_memory_space team_shmem() const ;

    KOKKOS_INLINE_FUNCTION int league_rank() const ;

    KOKKOS_INLINE_FUNCTION int league_size() const ;

    KOKKOS_INLINE_FUNCTION int team_rank() const ;

    KOKKOS_INLINE_FUNCTION int team_size() const ;

    KOKKOS_INLINE_FUNCTION void team_barrier() const ;

    template< class JoinOp >
    KOKKOS_INLINE_FUNCTION
    typename JoinOp::value_type team_reduce( const typename JoinOp::value_type
                                           , const JoinOp & ) const ;

    template< typename Type >
    KOKKOS_INLINE_FUNCTION Type team_scan( const Type & value ) const ;

    template< typename Type >
    KOKKOS_INLINE_FUNCTION Type team_scan( const Type & value , Type * const global_accum ) const ;

#ifdef KOKKOS_HAVE_CXX11

    //template< typename iType, class Operation, typename ValueType >
    //KOKKOS_INLINE_FUNCTION void team_par_for(const iType n, const Operation & op) const ;

    //template< typename iType, class Operation, typename ValueType >
    //KOKKOS_INLINE_FUNCTION void team_par_reduce(const iType n, const Operation & op, ValueType& result) const ;

    //template< typename iType, class Operation, typename ValueType, class JoinType >
    //KOKKOS_INLINE_FUNCTION void team_par_reduce(const iType n, const Operation & op, ValueType& result, const JoinType & join) const ;

    //template< typename iType, class Operation, typename ValueType >
    //KOKKOS_INLINE_FUNCTION  void team_par_scan(const iType n, const Operation & op, ValueType& scan_val) const ;

    template< class Operation >
    KOKKOS_INLINE_FUNCTION void vector_single(const Operation & op) const ;

    template< typename iType, class Operation>
    KOKKOS_INLINE_FUNCTION void vector_par_for(const iType n, const Operation & op) const ;

    template< typename iType, class Operation, typename ValueType >
    KOKKOS_INLINE_FUNCTION void vector_par_reduce(const iType n, const Operation & op, ValueType& result) const ;

    template< typename iType, class Operation, typename ValueType, class JoinType >
    KOKKOS_INLINE_FUNCTION void vector_par_reduce(const iType n, const Operation & op, ValueType& init_result, const JoinType & join) const ;

    template< typename iType, class Operation, typename ValueType >
    KOKKOS_INLINE_FUNCTION  void vector_par_scan(const iType n, const Operation & op, ValueType& scan_val) const ;
#endif
  };
};

} // namespace Kokkos

#endif /* #define KOKKOS_EXECPOLICY_HPP */

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------