Kokkos_Serial.hpp

Go to the documentation of this file.

/*
//@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_SERIAL_HPP
#define KOKKOS_SERIAL_HPP

#include <cstddef>
#include <iosfwd>
#include <Kokkos_Parallel.hpp>
#include <Kokkos_Layout.hpp>
#include <Kokkos_HostSpace.hpp>
#include <Kokkos_ScratchSpace.hpp>
#include <Kokkos_MemoryTraits.hpp>
#include <impl/Kokkos_Tags.hpp>

/*--------------------------------------------------------------------------*/

namespace Kokkos {

class Serial {
public:


  typedef Impl::ExecutionSpaceTag  kokkos_tag ;

  typedef Serial                device_type ;
  typedef Serial                execution_space ;
  typedef HostSpace::size_type  size_type ;
  typedef HostSpace             memory_space ;
  typedef LayoutRight           array_layout ;
  typedef Serial                host_mirror_device_type ;

  typedef ScratchMemorySpace< Kokkos::Serial >  scratch_memory_space ;


  inline static int in_parallel() { return false ; }

  static bool sleep();

  static bool wake();

  static void fence() {}

  static void initialize( unsigned threads_count = 1 ,
                          unsigned use_numa_count = 0 ,
                          unsigned use_cores_per_numa = 0 ,
                          bool allow_asynchronous_threadpool = false) {
    (void) threads_count;
    (void) use_numa_count;
    (void) use_cores_per_numa;
    (void) allow_asynchronous_threadpool;
  }

  static int is_initialized() { return 1 ; }

  static void finalize() {}

  static void print_configuration( std::ostream & , const bool detail = false );

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

  inline static int thread_pool_size( int = 0 ) { return 1 ; }
  KOKKOS_INLINE_FUNCTION static int thread_pool_rank() { return 0 ; }

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

  KOKKOS_INLINE_FUNCTION static unsigned hardware_thread_id() { return thread_pool_rank(); }
  inline static unsigned max_hardware_threads() { return thread_pool_size(0); }

  static inline int team_max()         { return thread_pool_size(1) ; }
  static inline int team_recommended() { return thread_pool_size(2); }

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

  static void * scratch_memory_resize( unsigned reduce_size , unsigned shared_size );

  //--------------------------------------------------------------------------
};

} // namespace Kokkos

/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/

namespace Kokkos {
namespace Impl {

template<>
struct VerifyExecutionCanAccessMemorySpace
  < Kokkos::Serial::memory_space
  , Kokkos::Serial::scratch_memory_space
  >
{
  inline static void verify( void ) { }
  inline static void verify( const void * ) { }
};

namespace SerialImpl {

struct Sentinel {

  void *   m_scratch ;
  unsigned m_reduce_end ;
  unsigned m_shared_end ;

  Sentinel();
  ~Sentinel();
  static Sentinel & singleton();
};

inline
unsigned align( unsigned n );
}
} // namespace Impl
} // namespace Kokkos

/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/

namespace Kokkos {
namespace Impl {

class SerialTeamMember {
private:
  typedef Kokkos::ScratchMemorySpace< Kokkos::Serial > scratch_memory_space ;
  const scratch_memory_space  m_space ;
  const int                   m_league_rank ;
  const int                   m_league_size ;

  SerialTeamMember & operator = ( const SerialTeamMember & );

public:

  KOKKOS_INLINE_FUNCTION
  const scratch_memory_space & team_shmem() const { return m_space ; }

  KOKKOS_INLINE_FUNCTION int league_rank() const { return m_league_rank ; }
  KOKKOS_INLINE_FUNCTION int league_size() const { return m_league_size ; }
  KOKKOS_INLINE_FUNCTION int team_rank() const { return 0 ; }
  KOKKOS_INLINE_FUNCTION int team_size() const { return 1 ; }

  KOKKOS_INLINE_FUNCTION void team_barrier() const {}

  template< class JoinOp >
  typename JoinOp::value_type team_reduce( const typename JoinOp::value_type & value
                                         , const JoinOp & ) const
    { return value ; }

  template< typename Type >
  KOKKOS_INLINE_FUNCTION Type team_scan( const Type & value , Type * const global_accum ) const
    {
      const Type tmp = global_accum ? *global_accum : Type(0) ;
      if ( global_accum ) { *global_accum += value ; }
      return tmp ;
    }

  template< typename Type >
  KOKKOS_INLINE_FUNCTION Type team_scan( const Type & ) const
    { return Type(0); }

#ifdef KOKKOS_HAVE_CXX11

  template< typename iType, class Operation>
  KOKKOS_INLINE_FUNCTION void team_par_for(const iType n, const Operation & op) const {
    for(int i=0; i<n ; i++) {
      op(i);
    }
  }

#endif

  //----------------------------------------
  // Execution space specific:

  SerialTeamMember( int arg_league_rank
                  , int arg_league_size 
                  , int arg_shared_size
                  );
};

template<unsigned int VectorLength>
class SerialTeamVectorMember {
private:
  typedef Kokkos::ScratchMemorySpace< Kokkos::Serial > scratch_memory_space ;
  const scratch_memory_space  m_space ;
  const int                   m_league_rank ;
  const int                   m_league_size ;

  SerialTeamVectorMember & operator = ( const SerialTeamVectorMember & );

public:

  KOKKOS_INLINE_FUNCTION
  const scratch_memory_space & team_shmem() const { return m_space ; }

  KOKKOS_INLINE_FUNCTION int league_rank() const { return m_league_rank ; }
  KOKKOS_INLINE_FUNCTION int league_size() const { return m_league_size ; }
  KOKKOS_INLINE_FUNCTION int team_rank() const { return 0 ; }
  KOKKOS_INLINE_FUNCTION int team_size() const { return 1 ; }

  KOKKOS_INLINE_FUNCTION void team_barrier() const {}

  template< class JoinOp >
  typename JoinOp::value_type team_reduce( const typename JoinOp::value_type & value
                                         , const JoinOp & ) const
    { return value ; }

  template< typename Type >
  KOKKOS_INLINE_FUNCTION Type team_scan( const Type & value , Type * const global_accum ) const
    {
      const Type tmp = global_accum ? *global_accum : Type(0) ;
      if ( global_accum ) { *global_accum += value ; }
      return tmp ;
    }

  template< typename Type >
  KOKKOS_INLINE_FUNCTION Type team_scan( const Type & ) const
    { return Type(0); }

#ifdef KOKKOS_HAVE_CXX11

  template< typename iType, class Operation>
  KOKKOS_INLINE_FUNCTION void team_par_for(const iType n, const Operation & op) const {
    for(int i=0; i<n ; i++) {
      op(i);
    }
  }

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

  template< class Operation , typename ValueType>
  KOKKOS_INLINE_FUNCTION void vector_single(const Operation & op, ValueType& bcast) const {
    op();
  }

  template< typename iType, class Operation >
  KOKKOS_INLINE_FUNCTION void vector_par_for(const iType n, const Operation & op) const {
    #ifdef KOKKOS_HAVE_PRAGMA_IVDEP
    #pragma ivdep
    #endif
    for(int i=0; i<n ; i++) {
      op(i);
    }
  }

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

    result = ValueType();

#ifdef KOKKOS_HAVE_PRAGMA_IVDEP
#pragma ivdep
#endif
    for(int i=0; i<n ; i++) {
      ValueType tmp = ValueType();
      op(i,tmp);
      result+=tmp;
    }
  }

  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 {

    ValueType result = init_result;

#ifdef KOKKOS_HAVE_PRAGMA_IVDEP
#pragma ivdep
#endif
    for(int i=0; i<n ; i++) {
      ValueType tmp = init_result;
      op(i,tmp);
      join(result,tmp);
    }
    init_result = result;
  }


  template< typename iType, class Operation, typename ValueType >
  KOKKOS_INLINE_FUNCTION  void vector_par_scan(const iType n, const Operation & op, ValueType& scan_val) const {

    scan_val = ValueType();

#ifdef KOKKOS_HAVE_PRAGMA_IVDEP
#pragma ivdep
#endif
    for(int i=0; i<n ; i++) {
      op(i,scan_val,true);
    }
  }
#endif
  //----------------------------------------
  // Execution space specific:

  SerialTeamVectorMember( int arg_league_rank
                  , int arg_league_size
                  , int arg_shared_size
                  )
  : m_space( ((char *) SerialImpl::Sentinel::singleton().m_scratch) + SerialImpl::Sentinel::singleton().m_reduce_end
           , arg_shared_size )
  , m_league_rank( arg_league_rank )
  , m_league_size( arg_league_size )
  {}
};
} // namespace Impl
} // namespace Kokkos

/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/

namespace Kokkos {

/* 
 * < Kokkos::Serial , WorkArgTag >
 * < WorkArgTag , Impl::enable_if< Impl::is_same< Kokkos::Serial , Kokkos::DefaultExecutionSpace >::value >::type >
 *
 */
template< class Arg0 , class Arg1 >
class TeamPolicy< Arg0 , Arg1 , Kokkos::Serial >
{
private:

  const int m_league_size ;

public:

  typedef Impl::ExecutionPolicyTag   kokkos_tag ;       
  typedef TeamPolicy                 execution_policy ; 
  typedef Kokkos::Serial             execution_space ;  

  typedef typename
    Impl::if_c< ! Impl::is_same< Kokkos::Serial , Arg0 >::value , Arg0 , Arg1 >::type
      work_tag ;

  inline int team_size() const { return 1 ; }
  inline int league_size() const { return m_league_size ; }

  TeamPolicy( execution_space & , int league_size_request , int /* team_size_request */ )
    : m_league_size( league_size_request )
    { }

  TeamPolicy( int league_size_request , int /* team_size_request */ )
    : m_league_size( league_size_request )
    { }

  template< class FunctorType >
  static
  int team_size_max( const FunctorType & ) { return 1 ; }

  typedef Impl::SerialTeamMember  member_type ;
};

} /* namespace Kokkos */

/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/

namespace Kokkos {

template< unsigned int VectorLength , class Arg0 , class Arg1 >
class TeamVectorPolicy< VectorLength , Arg0 , Arg1 , Kokkos::Serial >
{
private:

  const int m_league_size ;

public:

  typedef Impl::ExecutionPolicyTag   kokkos_tag ;       
  typedef TeamVectorPolicy           execution_policy ; 
  typedef Kokkos::Serial             execution_space ;  

  typedef typename
    Impl::if_c< ! Impl::is_same< Kokkos::Serial , Arg0 >::value , Arg0 , Arg1 >::type
      work_tag ;

  inline int team_size() const { return 1 ; }
  inline int league_size() const { return m_league_size ; }

  TeamVectorPolicy( execution_space & , int league_size_request , int /* team_size_request */ )
    : m_league_size( league_size_request )
    { }

  TeamVectorPolicy( int league_size_request , int /* team_size_request */ )
    : m_league_size( league_size_request )
    { }

  template< class FunctorType >
  static
  int team_size_max( const FunctorType & ) { return 1 ; }

  typedef Impl::SerialTeamVectorMember<VectorLength>  member_type ;
};

} /* namespace Kokkos */

/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/

namespace Kokkos {
namespace Impl {

template< class FunctorType , class Arg0 , class Arg1 , class Arg2 >
class ParallelFor< FunctorType , Kokkos::RangePolicy< Arg0 , Arg1 , Arg2 , Kokkos::Serial > >
{
private:

  typedef Kokkos::RangePolicy< Arg0 , Arg1 , Arg2 , Kokkos::Serial > Policy ;

public:
  // work tag is void
  template< class PType >
  inline
  ParallelFor( typename Impl::enable_if<
                 ( Impl::is_same< PType , Policy >::value &&
                   Impl::is_same< typename PType::work_tag , void >::value
                 ), const FunctorType & >::type functor
             , const PType & policy )
    {
      const typename PType::member_type e = policy.end();
      for ( typename PType::member_type i = policy.begin() ; i < e ; ++i ) {
        functor( i );
      }
    }

  // work tag is non-void
  template< class PType >
  inline
  ParallelFor( typename Impl::enable_if<
                 ( Impl::is_same< PType , Policy >::value &&
                   ! Impl::is_same< typename PType::work_tag , void >::value
                 ), const FunctorType & >::type functor
             , const PType & policy )
    {
      const typename PType::member_type e = policy.end();
      for ( typename PType::member_type i = policy.begin() ; i < e ; ++i ) {
        functor( typename PType::work_tag() , i );
      }
    }
};

template< class FunctorType , class Arg0 , class Arg1 , class Arg2 >
class ParallelReduce< FunctorType , Kokkos::RangePolicy< Arg0 , Arg1 , Arg2 , Kokkos::Serial > >
{
public:
  typedef Kokkos::RangePolicy< Arg0 , Arg1 , Arg2 , Kokkos::Serial > Policy ;

  typedef ReduceAdapter< FunctorType >  Reduce ;
  typedef typename Reduce::pointer_type pointer_type ;

  // Work tag is void
  template< class ViewType , class PType >
  ParallelReduce( typename Impl::enable_if<
                    ( Impl::is_view< ViewType >::value &&
                      Impl::is_same< typename ViewType::memory_space , HostSpace >::value &&
                      Impl::is_same< PType , Policy >::value &&
                      Impl::is_same< typename PType::work_tag , void >::value
                    ), const FunctorType & >::type functor
                , const PType     & policy
                , const ViewType  & result
                )
    {
      pointer_type result_ptr = result.ptr_on_device();

      if ( ! result_ptr ) {
        result_ptr = (pointer_type)
          Kokkos::Serial::scratch_memory_resize( Reduce::value_size( functor ) , 0 );
      }

      typename Reduce::reference_type update = Reduce::init( functor , result_ptr );
      
      const typename PType::member_type e = policy.end();
      for ( typename PType::member_type i = policy.begin() ; i < e ; ++i ) {
        functor( i , update );
      }

      Reduce::final( functor , result_ptr );
    }

  // Work tag is non-void
  template< class ViewType , class PType >
  ParallelReduce( typename Impl::enable_if<
                    ( Impl::is_view< ViewType >::value &&
                      Impl::is_same< typename ViewType::memory_space , HostSpace >::value &&
                      Impl::is_same< PType , Policy >::value &&
                      ! Impl::is_same< typename PType::work_tag , void >::value
                    ), const FunctorType & >::type functor
                , const PType     & policy
                , const ViewType  & result
                )
    {
      pointer_type result_ptr = result.ptr_on_device();

      if ( ! result_ptr ) {
        result_ptr = (pointer_type)
          Kokkos::Serial::scratch_memory_resize( Reduce::value_size( functor ) , 0 );
      }

      typename Reduce::reference_type update = Reduce::init( functor , result_ptr );
      
      const typename PType::member_type e = policy.end();
      for ( typename PType::member_type i = policy.begin() ; i < e ; ++i ) {
        functor( typename PType::work_tag() , i , update );
      }

      Reduce::final( functor , result_ptr );
    }
};

template< class FunctorType , class Arg0 , class Arg1 , class Arg2 >
class ParallelScan< FunctorType , Kokkos::RangePolicy< Arg0 , Arg1 , Arg2 , Kokkos::Serial > >
{
private:

  typedef Kokkos::RangePolicy< Arg0 , Arg1 , Arg2 , Kokkos::Serial > Policy ;
  typedef ReduceAdapter< FunctorType >  Reduce ;

public:

  typedef typename Reduce::pointer_type pointer_type ;

  // work tag is void
  template< class PType >
  inline
  ParallelScan( typename Impl::enable_if<
                 ( Impl::is_same< PType , Policy >::value &&
                   Impl::is_same< typename PType::work_tag , void >::value
                 ), const FunctorType & >::type functor
             , const PType & policy )
    {
      pointer_type result_ptr = (pointer_type)
        Kokkos::Serial::scratch_memory_resize( Reduce::value_size( functor ) , 0 );

      typename Reduce::reference_type update = Reduce::init( functor , result_ptr );
      
      const typename PType::member_type e = policy.end();
      for ( typename PType::member_type i = policy.begin() ; i < e ; ++i ) {
        functor( i , update , true );
      }

      Reduce::final( functor , result_ptr );
    }

  // work tag is non-void
  template< class PType >
  inline
  ParallelScan( typename Impl::enable_if<
                 ( Impl::is_same< PType , Policy >::value &&
                   ! Impl::is_same< typename PType::work_tag , void >::value
                 ), const FunctorType & >::type functor
             , const PType & policy )
    {
      pointer_type result_ptr = (pointer_type)
        Kokkos::Serial::scratch_memory_resize( Reduce::value_size( functor ) , 0 );

      typename Reduce::reference_type update = Reduce::init( functor , result_ptr );
      
      const typename PType::member_type e = policy.end();
      for ( typename PType::member_type i = policy.begin() ; i < e ; ++i ) {
        functor( typename PType::work_tag() , i , update , true );
      }

      Reduce::final( functor , result_ptr );
    }
};

} // namespace Impl
} // namespace Kokkos

/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/

namespace Kokkos {
namespace Impl {

template< class FunctorType , class Arg0 , class Arg1 >
class ParallelFor< FunctorType , Kokkos::TeamPolicy< Arg0 , Arg1 , Kokkos::Serial > >
{
private:

  typedef Kokkos::TeamPolicy< Arg0 , Arg1 , Kokkos::Serial > Policy ;

  template< class TagType >
  KOKKOS_FORCEINLINE_FUNCTION static
  void driver( typename Impl::enable_if< Impl::is_same< TagType , void >::value ,
                 const FunctorType & >::type functor
             , const typename Policy::member_type & member )
    { functor( member ); }

  template< class TagType >
  KOKKOS_FORCEINLINE_FUNCTION static
  void driver( typename Impl::enable_if< ! Impl::is_same< TagType , void >::value ,
                 const FunctorType & >::type functor
             , const typename Policy::member_type & member )
    { functor( TagType() , member ); }

public:

  ParallelFor( const FunctorType & functor
             , const Policy      & policy )
    {
      const int shared_size = FunctorTeamShmemSize< FunctorType >::value( functor , policy.team_size() );

      Kokkos::Serial::scratch_memory_resize( 0 , shared_size );

      for ( int ileague = 0 ; ileague < policy.league_size() ; ++ileague ) {
        ParallelFor::template driver< typename Policy::work_tag >
          ( functor , typename Policy::member_type(ileague,policy.league_size(),shared_size) );
        // functor( typename Policy::member_type(ileague,policy.league_size(),shared_size) );
      }
    }
};

template< unsigned int VectorLength , class FunctorType , class Arg0 , class Arg1 >
class ParallelFor< FunctorType , Kokkos::TeamVectorPolicy< VectorLength , Arg0 , Arg1 , Kokkos::Serial > >
{
private:

  typedef Kokkos::TeamVectorPolicy< VectorLength , Arg0 , Arg1 , Kokkos::Serial > Policy ;

  template< class TagType >
  KOKKOS_FORCEINLINE_FUNCTION static
  void driver( typename Impl::enable_if< Impl::is_same< TagType , void >::value ,
                 const FunctorType & >::type functor
             , const typename Policy::member_type & member )
    { functor( member ); }

  template< class TagType >
  KOKKOS_FORCEINLINE_FUNCTION static
  void driver( typename Impl::enable_if< ! Impl::is_same< TagType , void >::value ,
                 const FunctorType & >::type functor
             , const typename Policy::member_type & member )
    { functor( TagType() , member ); }

public:

  ParallelFor( const FunctorType & functor
             , const Policy      & policy )
    {
      const int shared_size = FunctorTeamShmemSize< FunctorType >::value( functor , policy.team_size() );

      Kokkos::Serial::scratch_memory_resize( 0 , shared_size );

      for ( int ileague = 0 ; ileague < policy.league_size() ; ++ileague ) {
        ParallelFor::template driver< typename Policy::work_tag >
          ( functor , typename Policy::member_type(ileague,policy.league_size(),shared_size) );
        // functor( typename Policy::member_type(ileague,policy.league_size(),shared_size) );
      }
    }
};

template< class FunctorType , class Arg0 , class Arg1 >
class ParallelReduce< FunctorType , Kokkos::TeamPolicy< Arg0 , Arg1 , Kokkos::Serial > > 
{
private:

  typedef Kokkos::TeamPolicy< Arg0 , Arg1 , Kokkos::Serial > Policy ;
  typedef ReduceAdapter< FunctorType >  Reduce ;

  template< class TagType >
  KOKKOS_FORCEINLINE_FUNCTION static
  void driver( typename Impl::enable_if< Impl::is_same< TagType , void >::value ,
                 const FunctorType & >::type functor
             , const typename Policy::member_type  & member
             ,       typename Reduce::reference_type update )
    { functor( member , update ); }

  template< class TagType >
  KOKKOS_FORCEINLINE_FUNCTION static
  void driver( typename Impl::enable_if< ! Impl::is_same< TagType , void >::value ,
                 const FunctorType & >::type functor
             , const typename Policy::member_type  & member 
             ,       typename Reduce::reference_type update )
    { functor( TagType() , member , update ); }

public:

  typedef typename Reduce::pointer_type pointer_type ;

  template< class ViewType >
  ParallelReduce( const FunctorType  & functor
                , const Policy       & policy
                , const ViewType     & result
                )
    {
      const int reduce_size = Reduce::value_size( functor );
      const int shared_size = FunctorTeamShmemSize< FunctorType >::value( functor , policy.team_size() );
      void * const scratch_reduce = Kokkos::Serial::scratch_memory_resize( reduce_size , shared_size );

      const pointer_type result_ptr =
        result.ptr_on_device() ? result.ptr_on_device() 
                               : (pointer_type) scratch_reduce ;

      typename Reduce::reference_type update = Reduce::init( functor , result_ptr );
      
      for ( int ileague = 0 ; ileague < policy.league_size() ; ++ileague ) {
        ParallelReduce::template driver< typename Policy::work_tag >
          ( functor , typename Policy::member_type(ileague,policy.league_size(),shared_size) , update );
      }

      Reduce::final( functor , result_ptr );
    }
};

} // namespace Impl
} // namespace Kokkos

#endif /* #define KOKKOS_SERIAL_HPP */

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