Kokkos Core Kernels Package  Version of the Day
Namespaces | Classes | Enumerations | Functions
Kokkos Namespace Reference

Namespaces

 hwloc
 Minimal subset of logical 'hwloc' functionality available from http://www.open-mpi.org/projects/hwloc/.
 

Classes

struct  ALL
 Tag denoting that a subview should capture all of a dimension. More...
 
struct  Array
 Derived from the C++17 'std::array'. Dropping the iterator interface. More...
 
class  Bitset
 A thread safe view to a bitset. More...
 
class  complex
 Partial reimplementation of std::complex that works as the result of a Kokkos::parallel_reduce. More...
 
class  ConstBitset
 
struct  Device
 Memory space for main process and CPU execution spaces. More...
 
class  HostSpace
 Memory management for host memory. More...
 
struct  LayoutLeft
 Memory layout tag indicating left-to-right (Fortran scheme) striding of multi-indices. More...
 
struct  LayoutRight
 Memory layout tag indicating right-to-left (C or lexigraphical scheme) striding of multi-indices. More...
 
struct  LayoutStride
 Memory layout tag indicated arbitrarily strided multi-index mapping into contiguous memory. More...
 
struct  LayoutTileLeft
 Memory layout tag indicating left-to-right (Fortran scheme) striding of multi-indices by tiles. More...
 
struct  pair
 Replacement for std::pair that works on CUDA devices. More...
 
class  Qthread
 Execution space supported by Qthread. More...
 
class  RangePolicy
 Execution policy for work over a range of an integral type. More...
 
class  ScratchMemorySpace
 Scratch memory space associated with an execution space. More...
 
class  StaticCrsGraph
 Compressed row storage array. More...
 
class  TeamPolicy
 Execution policy for parallel work over a league of teams of threads. More...
 
class  UnorderedMap
 Thread-safe, performance-portable lookup table. More...
 
class  UnorderedMapInsertResult
 First element of the return value of UnorderedMap::insert(). More...
 
class  View
 View to an array of data. More...
 
class  ViewTraits
 Traits class for accessing attributes of a View. More...
 

Enumerations

Functions

template<class RealType >
KOKKOS_INLINE_FUNCTION complex< RealType > operator+ (const complex< RealType > &x, const complex< RealType > &y)
 Binary + operator for complex. More...
 
template<class RealType >
KOKKOS_INLINE_FUNCTION complex< RealType > operator+ (const complex< RealType > &x)
 Unary + operator for complex. More...
 
template<class RealType >
KOKKOS_INLINE_FUNCTION complex< RealType > operator- (const complex< RealType > &x, const complex< RealType > &y)
 Binary - operator for complex. More...
 
template<class RealType >
KOKKOS_INLINE_FUNCTION complex< RealType > operator- (const complex< RealType > &x)
 Unary - operator for complex. More...
 
template<class RealType >
KOKKOS_INLINE_FUNCTION complex< RealType > operator* (const complex< RealType > &x, const complex< RealType > &y)
 Binary * operator for complex. More...
 
template<class RealType >
complex< RealType > operator* (const std::complex< RealType > &x, const complex< RealType > &y)
 Binary * operator for std::complex and complex. More...
 
template<class RealType >
KOKKOS_INLINE_FUNCTION complex< RealType > operator* (const RealType &x, const complex< RealType > &y)
 Binary * operator for RealType times complex. More...
 
template<class RealType >
KOKKOS_INLINE_FUNCTION RealType imag (const complex< RealType > &x)
 Imaginary part of a complex number. More...
 
template<class RealType >
KOKKOS_INLINE_FUNCTION RealType real (const complex< RealType > &x)
 Real part of a complex number. More...
 
template<class RealType >
KOKKOS_INLINE_FUNCTION RealType abs (const complex< RealType > &x)
 Absolute value (magnitude) of a complex number. More...
 
template<class RealType >
KOKKOS_INLINE_FUNCTION complex< RealType > conj (const complex< RealType > &x)
 Conjugate of a complex number. More...
 
template<class RealType1 , class RealType2 >
KOKKOS_INLINE_FUNCTION complex< RealType1 > operator/ (const complex< RealType1 > &x, const RealType2 &y)
 Binary operator / for complex and real numbers. More...
 
template<class RealType >
KOKKOS_INLINE_FUNCTION complex< RealType > operator/ (const complex< RealType > &x, const complex< RealType > &y)
 Binary operator / for complex. More...
 
template<class RealType >
KOKKOS_INLINE_FUNCTION bool operator== (const complex< RealType > &x, const complex< RealType > &y)
 Equality operator for two complex numbers. More...
 
template<class RealType >
KOKKOS_INLINE_FUNCTION bool operator== (const std::complex< RealType > &x, const complex< RealType > &y)
 Equality operator for std::complex and Kokkos::complex. More...
 
template<class RealType1 , class RealType2 >
KOKKOS_INLINE_FUNCTION bool operator== (const complex< RealType1 > &x, const RealType2 &y)
 Equality operator for complex and real number. More...
 
template<class RealType >
KOKKOS_INLINE_FUNCTION bool operator== (const RealType &x, const complex< RealType > &y)
 Equality operator for real and complex number. More...
 
template<class RealType >
KOKKOS_INLINE_FUNCTION bool operator!= (const complex< RealType > &x, const complex< RealType > &y)
 Inequality operator for two complex numbers. More...
 
template<class RealType >
KOKKOS_INLINE_FUNCTION bool operator!= (const std::complex< RealType > &x, const complex< RealType > &y)
 Inequality operator for std::complex and Kokkos::complex. More...
 
template<class RealType1 , class RealType2 >
KOKKOS_INLINE_FUNCTION bool operator!= (const complex< RealType1 > &x, const RealType2 &y)
 Inequality operator for complex and real number. More...
 
template<class RealType >
KOKKOS_INLINE_FUNCTION bool operator!= (const RealType &x, const complex< RealType > &y)
 Inequality operator for real and complex number. More...
 
void finalize ()
 Finalize the spaces that were initialized via Kokkos::initialize. More...
 
void finalize_all ()
 Finalize all known execution spaces. More...
 
template<typename iType , class TeamMemberType >
KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct< iType, TeamMemberType > TeamThreadRange (const TeamMemberType &, const iType &count)
 Execution policy for parallel work over a threads within a team. More...
 
template<typename iType , class TeamMemberType >
KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct< iType, TeamMemberType > TeamThreadRange (const TeamMemberType &, const iType &begin, const iType &end)
 Execution policy for parallel work over a threads within a team. More...
 
template<typename iType , class TeamMemberType >
KOKKOS_INLINE_FUNCTION Impl::ThreadVectorRangeBoundariesStruct< iType, TeamMemberType > ThreadVectorRange (const TeamMemberType &, const iType &count)
 Execution policy for a vector parallel loop. More...
 
template<class T1 , class T2 >
KOKKOS_FORCEINLINE_FUNCTION bool operator== (const pair< T1, T2 > &lhs, const pair< T1, T2 > &rhs)
 Equality operator for Kokkos::pair. More...
 
template<class T1 , class T2 >
KOKKOS_FORCEINLINE_FUNCTION bool operator!= (const pair< T1, T2 > &lhs, const pair< T1, T2 > &rhs)
 Inequality operator for Kokkos::pair. More...
 
template<class T1 , class T2 >
KOKKOS_FORCEINLINE_FUNCTION bool operator< (const pair< T1, T2 > &lhs, const pair< T1, T2 > &rhs)
 Less-than operator for Kokkos::pair. More...
 
template<class T1 , class T2 >
KOKKOS_FORCEINLINE_FUNCTION bool operator<= (const pair< T1, T2 > &lhs, const pair< T1, T2 > &rhs)
 Less-than-or-equal-to operator for Kokkos::pair. More...
 
template<class T1 , class T2 >
KOKKOS_FORCEINLINE_FUNCTION bool operator> (const pair< T1, T2 > &lhs, const pair< T1, T2 > &rhs)
 Greater-than operator for Kokkos::pair. More...
 
template<class T1 , class T2 >
KOKKOS_FORCEINLINE_FUNCTION bool operator>= (const pair< T1, T2 > &lhs, const pair< T1, T2 > &rhs)
 Greater-than-or-equal-to operator for Kokkos::pair. More...
 
template<class T1 , class T2 >
KOKKOS_FORCEINLINE_FUNCTION pair< T1, T2 > make_pair (T1 x, T2 y)
 Return a new pair. More...
 
template<class T1 , class T2 >
KOKKOS_FORCEINLINE_FUNCTION pair< T1 &, T2 & > tie (T1 &x, T2 &y)
 Return a pair of references to the input arguments. More...
 
template<class ExecPolicy , class FunctorType >
void parallel_for (const ExecPolicy &policy, const FunctorType &functor, const std::string &str="", typename Impl::enable_if< !Impl::is_integral< ExecPolicy >::value >::type *=0)
 Execute functor in parallel according to the execution policy. More...
 
template<class ExecPolicy , class FunctorType >
void parallel_reduce (const ExecPolicy &policy, const FunctorType &functor, const std::string &str="", typename Impl::enable_if< !Impl::is_integral< ExecPolicy >::value >::type *=0)
 Parallel reduction. More...
 
template<class DT , class DL , class DD , class DM , class DS >
void deep_copy (const View< DT, DL, DD, DM, DS > &dst, typename Impl::enable_if<(Impl::is_same< typename ViewTraits< DT, DL, DD, DM >::non_const_value_type, typename ViewTraits< DT, DL, DD, DM >::value_type >::value), typename ViewTraits< DT, DL, DD, DM >::const_value_type >::type &value)
 Deep copy a value into a view. More...
 
template<class DT , class DL , class DD , class DM , class DS , class ST , class SL , class SD , class SM , class SS >
void deep_copy (const View< DT, DL, DD, DM, DS > &dst, const View< ST, SL, SD, SM, SS > &src, typename Impl::enable_if<(Impl::is_same< typename View< DT, DL, DD, DM, DS >::value_type, typename View< ST, SL, SD, SM, SS >::non_const_value_type >::value &&(unsigned(View< DT, DL, DD, DM, DS >::rank)==unsigned(0))&&(unsigned(View< ST, SL, SD, SM, SS >::rank)==unsigned(0)))>::type *=0)
 A deep copy between views of compatible type, and rank zero. More...
 
template<class DT , class DL , class DD , class DM , class ST , class SL , class SD , class SM >
void deep_copy (const View< DT, DL, DD, DM, Impl::ViewDefault > &dst, const View< ST, SL, SD, SM, Impl::ViewDefault > &src, typename Impl::enable_if<(Impl::is_same< typename View< DT, DL, DD, DM, Impl::ViewDefault >::value_type, typename View< ST, SL, SD, SM, Impl::ViewDefault >::non_const_value_type >::value &&(unsigned(View< DT, DL, DD, DM, Impl::ViewDefault >::rank)==unsigned(View< ST, SL, SD, SM, Impl::ViewDefault >::rank))&&(0< unsigned(View< DT, DL, DD, DM, Impl::ViewDefault >::rank))&&Impl::is_same< typename View< DT, DL, DD, DM, Impl::ViewDefault >::array_layout, typename View< ST, SL, SD, SM, Impl::ViewDefault >::array_layout >::value)>::type *=0)
 A deep copy between views of the default specialization, compatible type, same non-zero rank, same contiguous layout. More...
 
template<class DT , class DL , class DD , class DM , class DS , class ST , class SL , class SD , class SM , class SS >
void deep_copy (const View< DT, DL, DD, DM, DS > &dst, const View< ST, SL, SD, SM, SS > &src, const typename Impl::enable_if<(Impl::is_same< typename View< DT, DL, DD, DM, DS >::value_type, typename View< DT, DL, DD, DM, DS >::non_const_value_type >::value &&Impl::VerifyExecutionCanAccessMemorySpace< typename View< DT, DL, DD, DM, DS >::memory_space, typename View< ST, SL, SD, SM, SS >::memory_space >::value &&(unsigned(View< DT, DL, DD, DM, DS >::rank)==unsigned(View< ST, SL, SD, SM, SS >::rank))&&(0< unsigned(View< DT, DL, DD, DM, DS >::rank))&&((!Impl::is_same< typename View< DT, DL, DD, DM, DS >::array_layout, typename View< ST, SL, SD, SM, SS >::array_layout >::value)||(!Impl::is_same< DS, SS >::value)))>::type *=0)
 Deep copy equal dimension arrays in the same space which have different layouts or specializations. More...
 
template<class ExecSpace , class DT , class DL , class DD , class DM , class DS >
void deep_copy (const ExecSpace &, const View< DT, DL, DD, DM, DS > &dst, typename Impl::enable_if<(Impl::is_same< typename ViewTraits< DT, DL, DD, DM >::non_const_value_type, typename ViewTraits< DT, DL, DD, DM >::value_type >::value), typename ViewTraits< DT, DL, DD, DM >::const_value_type >::type &value)
 Deep copy a value into a view. More...
 
template<class ExecSpace , class DT , class DL , class DD , class DM , class DS , class ST , class SL , class SD , class SM , class SS >
void deep_copy (const ExecSpace &exec, const View< DT, DL, DD, DM, DS > &dst, const View< ST, SL, SD, SM, SS > &src, typename Impl::enable_if<(Impl::is_same< typename View< DT, DL, DD, DM, DS >::value_type, typename View< ST, SL, SD, SM, SS >::non_const_value_type >::value &&(unsigned(View< DT, DL, DD, DM, DS >::rank)==unsigned(0))&&(unsigned(View< ST, SL, SD, SM, SS >::rank)==unsigned(0)))>::type *=0)
 A deep copy between views of compatible type, and rank zero. More...
 
template<class ExecSpace , class DT , class DL , class DD , class DM , class ST , class SL , class SD , class SM >
void deep_copy (const ExecSpace &exec, const View< DT, DL, DD, DM, Impl::ViewDefault > &dst, const View< ST, SL, SD, SM, Impl::ViewDefault > &src, typename Impl::enable_if<(Impl::is_same< typename View< DT, DL, DD, DM, Impl::ViewDefault >::value_type, typename View< ST, SL, SD, SM, Impl::ViewDefault >::non_const_value_type >::value &&(unsigned(View< DT, DL, DD, DM, Impl::ViewDefault >::rank)==unsigned(View< ST, SL, SD, SM, Impl::ViewDefault >::rank))&&(0< unsigned(View< DT, DL, DD, DM, Impl::ViewDefault >::rank))&&Impl::is_same< typename View< DT, DL, DD, DM, Impl::ViewDefault >::array_layout, typename View< ST, SL, SD, SM, Impl::ViewDefault >::array_layout >::value)>::type *=0)
 A deep copy between views of the default specialization, compatible type, same non-zero rank, same contiguous layout. More...
 
template<class ExecSpace , class DT , class DL , class DD , class DM , class DS , class ST , class SL , class SD , class SM , class SS >
void deep_copy (const ExecSpace &, const View< DT, DL, DD, DM, DS > &dst, const View< ST, SL, SD, SM, SS > &src, const typename Impl::enable_if<(Impl::is_same< typename View< DT, DL, DD, DM, DS >::value_type, typename View< DT, DL, DD, DM, DS >::non_const_value_type >::value &&Impl::VerifyExecutionCanAccessMemorySpace< typename View< DT, DL, DD, DM, DS >::memory_space, typename View< ST, SL, SD, SM, SS >::memory_space >::value &&(unsigned(View< DT, DL, DD, DM, DS >::rank)==unsigned(View< ST, SL, SD, SM, SS >::rank))&&(0< unsigned(View< DT, DL, DD, DM, DS >::rank))&&((!Impl::is_same< typename View< DT, DL, DD, DM, DS >::array_layout, typename View< ST, SL, SD, SM, SS >::array_layout >::value)||(!Impl::is_same< DS, SS >::value)))>::type *=0)
 Deep copy equal dimension arrays in the same space which have different layouts or specializations. More...
 
template<class T , class L , class D , class M , class S >
void resize (View< T, L, D, M, S > &v, const typename Impl::enable_if< ViewTraits< T, L, D, M >::is_managed, size_t >::type n0, const size_t n1=0, const size_t n2=0, const size_t n3=0, const size_t n4=0, const size_t n5=0, const size_t n6=0, const size_t n7=0)
 Resize a view with copying old data to new data at the corresponding indices. More...
 
template<class T , class L , class D , class M , class S >
void realloc (View< T, L, D, M, S > &v, const typename Impl::enable_if< ViewTraits< T, L, D, M >::is_managed, size_t >::type n0, const size_t n1=0, const size_t n2=0, const size_t n3=0, const size_t n4=0, const size_t n5=0, const size_t n6=0, const size_t n7=0)
 Reallocate a view without copying old data to new data. More...
 

Detailed Description

Define Kokkos::DefaultExecutionSpace as per configuration option or chosen from the enabled execution spaces in the following order: Kokkos::Cuda, Kokkos::OpenMP, Kokkos::Threads, Kokkos::Serial

Enumeration Type Documentation

Memory access traits for views, an extension point.

These traits should be orthogonal. If there are dependencies then the MemoryTraits template must detect and enforce dependencies.

A zero value is the default for a View, indicating that none of these traits are present.

Definition at line 62 of file Kokkos_MemoryTraits.hpp.

Function Documentation

template<class RealType >
KOKKOS_INLINE_FUNCTION complex<RealType> Kokkos::operator+ ( const complex< RealType > &  x,
const complex< RealType > &  y 
)

Binary + operator for complex.

Definition at line 324 of file Kokkos_Complex.hpp.

template<class RealType >
KOKKOS_INLINE_FUNCTION complex<RealType> Kokkos::operator+ ( const complex< RealType > &  x)

Unary + operator for complex.

Definition at line 332 of file Kokkos_Complex.hpp.

template<class RealType >
KOKKOS_INLINE_FUNCTION complex<RealType> Kokkos::operator- ( const complex< RealType > &  x,
const complex< RealType > &  y 
)

Binary - operator for complex.

Definition at line 340 of file Kokkos_Complex.hpp.

template<class RealType >
KOKKOS_INLINE_FUNCTION complex<RealType> Kokkos::operator- ( const complex< RealType > &  x)

Unary - operator for complex.

Definition at line 348 of file Kokkos_Complex.hpp.

template<class RealType >
KOKKOS_INLINE_FUNCTION complex<RealType> Kokkos::operator* ( const complex< RealType > &  x,
const complex< RealType > &  y 
)

Binary * operator for complex.

Definition at line 356 of file Kokkos_Complex.hpp.

template<class RealType >
complex<RealType> Kokkos::operator* ( const std::complex< RealType > &  x,
const complex< RealType > &  y 
)

Binary * operator for std::complex and complex.

This function exists because GCC 4.7.2 (and perhaps other compilers) are not able to deduce that they can multiply std::complex by Kokkos::complex, by first converting std::complex to Kokkos::complex.

This function cannot be called in a CUDA device function, because std::complex's methods and nonmember functions are not marked as CUDA device functions.

Definition at line 373 of file Kokkos_Complex.hpp.

template<class RealType >
KOKKOS_INLINE_FUNCTION complex<RealType> Kokkos::operator* ( const RealType &  x,
const complex< RealType > &  y 
)

Binary * operator for RealType times complex.

This function exists because the compiler doesn't know that RealType and complex<RealType> commute with respect to operator*.

Definition at line 385 of file Kokkos_Complex.hpp.

template<class RealType >
KOKKOS_INLINE_FUNCTION RealType Kokkos::imag ( const complex< RealType > &  x)

Imaginary part of a complex number.

Definition at line 393 of file Kokkos_Complex.hpp.

template<class RealType >
KOKKOS_INLINE_FUNCTION RealType Kokkos::real ( const complex< RealType > &  x)

Real part of a complex number.

Definition at line 400 of file Kokkos_Complex.hpp.

template<class RealType >
KOKKOS_INLINE_FUNCTION RealType Kokkos::abs ( const complex< RealType > &  x)

Absolute value (magnitude) of a complex number.

Definition at line 407 of file Kokkos_Complex.hpp.

template<class RealType >
KOKKOS_INLINE_FUNCTION complex<RealType> Kokkos::conj ( const complex< RealType > &  x)

Conjugate of a complex number.

Definition at line 415 of file Kokkos_Complex.hpp.

template<class RealType1 , class RealType2 >
KOKKOS_INLINE_FUNCTION complex<RealType1> Kokkos::operator/ ( const complex< RealType1 > &  x,
const RealType2 &  y 
)

Binary operator / for complex and real numbers.

Definition at line 424 of file Kokkos_Complex.hpp.

template<class RealType >
KOKKOS_INLINE_FUNCTION complex<RealType> Kokkos::operator/ ( const complex< RealType > &  x,
const complex< RealType > &  y 
)

Binary operator / for complex.

Definition at line 432 of file Kokkos_Complex.hpp.

template<class RealType >
KOKKOS_INLINE_FUNCTION bool Kokkos::operator== ( const complex< RealType > &  x,
const complex< RealType > &  y 
)

Equality operator for two complex numbers.

Definition at line 458 of file Kokkos_Complex.hpp.

template<class RealType >
KOKKOS_INLINE_FUNCTION bool Kokkos::operator== ( const std::complex< RealType > &  x,
const complex< RealType > &  y 
)

Equality operator for std::complex and Kokkos::complex.

Definition at line 465 of file Kokkos_Complex.hpp.

template<class RealType1 , class RealType2 >
KOKKOS_INLINE_FUNCTION bool Kokkos::operator== ( const complex< RealType1 > &  x,
const RealType2 &  y 
)

Equality operator for complex and real number.

Definition at line 472 of file Kokkos_Complex.hpp.

template<class RealType >
KOKKOS_INLINE_FUNCTION bool Kokkos::operator== ( const RealType &  x,
const complex< RealType > &  y 
)

Equality operator for real and complex number.

Definition at line 479 of file Kokkos_Complex.hpp.

template<class RealType >
KOKKOS_INLINE_FUNCTION bool Kokkos::operator!= ( const complex< RealType > &  x,
const complex< RealType > &  y 
)

Inequality operator for two complex numbers.

Definition at line 486 of file Kokkos_Complex.hpp.

template<class RealType >
KOKKOS_INLINE_FUNCTION bool Kokkos::operator!= ( const std::complex< RealType > &  x,
const complex< RealType > &  y 
)

Inequality operator for std::complex and Kokkos::complex.

Definition at line 493 of file Kokkos_Complex.hpp.

template<class RealType1 , class RealType2 >
KOKKOS_INLINE_FUNCTION bool Kokkos::operator!= ( const complex< RealType1 > &  x,
const RealType2 &  y 
)

Inequality operator for complex and real number.

Definition at line 500 of file Kokkos_Complex.hpp.

template<class RealType >
KOKKOS_INLINE_FUNCTION bool Kokkos::operator!= ( const RealType &  x,
const complex< RealType > &  y 
)

Inequality operator for real and complex number.

Definition at line 507 of file Kokkos_Complex.hpp.

void Kokkos::finalize ( )

Finalize the spaces that were initialized via Kokkos::initialize.

void Kokkos::finalize_all ( )

Finalize all known execution spaces.

template<typename iType , class TeamMemberType >
KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<iType,TeamMemberType> Kokkos::TeamThreadRange ( const TeamMemberType &  ,
const iType &  count 
)

Execution policy for parallel work over a threads within a team.

The range is split over all threads in a team. The Mapping scheme depends on the architecture. This policy is used together with a parallel pattern as a nested layer within a kernel launched with the TeamPolicy. This variant expects a single count. So the range is (0,count].

template<typename iType , class TeamMemberType >
KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<iType,TeamMemberType> Kokkos::TeamThreadRange ( const TeamMemberType &  ,
const iType &  begin,
const iType &  end 
)

Execution policy for parallel work over a threads within a team.

The range is split over all threads in a team. The Mapping scheme depends on the architecture. This policy is used together with a parallel pattern as a nested layer within a kernel launched with the TeamPolicy. This variant expects a begin and end. So the range is (begin,end].

template<typename iType , class TeamMemberType >
KOKKOS_INLINE_FUNCTION Impl::ThreadVectorRangeBoundariesStruct<iType,TeamMemberType> Kokkos::ThreadVectorRange ( const TeamMemberType &  ,
const iType &  count 
)

Execution policy for a vector parallel loop.

The range is split over all vector lanes in a thread. The Mapping scheme depends on the architecture. This policy is used together with a parallel pattern as a nested layer within a kernel launched with the TeamPolicy. This variant expects a single count. So the range is (0,count].

template<class T1 , class T2 >
KOKKOS_FORCEINLINE_FUNCTION bool Kokkos::operator== ( const pair< T1, T2 > &  lhs,
const pair< T1, T2 > &  rhs 
)

Equality operator for Kokkos::pair.

Definition at line 332 of file Kokkos_Pair.hpp.

template<class T1 , class T2 >
KOKKOS_FORCEINLINE_FUNCTION bool Kokkos::operator!= ( const pair< T1, T2 > &  lhs,
const pair< T1, T2 > &  rhs 
)

Inequality operator for Kokkos::pair.

Definition at line 338 of file Kokkos_Pair.hpp.

template<class T1 , class T2 >
KOKKOS_FORCEINLINE_FUNCTION bool Kokkos::operator< ( const pair< T1, T2 > &  lhs,
const pair< T1, T2 > &  rhs 
)

Less-than operator for Kokkos::pair.

Definition at line 344 of file Kokkos_Pair.hpp.

template<class T1 , class T2 >
KOKKOS_FORCEINLINE_FUNCTION bool Kokkos::operator<= ( const pair< T1, T2 > &  lhs,
const pair< T1, T2 > &  rhs 
)

Less-than-or-equal-to operator for Kokkos::pair.

Definition at line 350 of file Kokkos_Pair.hpp.

template<class T1 , class T2 >
KOKKOS_FORCEINLINE_FUNCTION bool Kokkos::operator> ( const pair< T1, T2 > &  lhs,
const pair< T1, T2 > &  rhs 
)

Greater-than operator for Kokkos::pair.

Definition at line 356 of file Kokkos_Pair.hpp.

template<class T1 , class T2 >
KOKKOS_FORCEINLINE_FUNCTION bool Kokkos::operator>= ( const pair< T1, T2 > &  lhs,
const pair< T1, T2 > &  rhs 
)

Greater-than-or-equal-to operator for Kokkos::pair.

Definition at line 362 of file Kokkos_Pair.hpp.

template<class T1 , class T2 >
KOKKOS_FORCEINLINE_FUNCTION pair<T1,T2> Kokkos::make_pair ( T1  x,
T2  y 
)

Return a new pair.

This is a "nonmember constructor" for Kokkos::pair. It works just like std::make_pair.

Definition at line 371 of file Kokkos_Pair.hpp.

template<class T1 , class T2 >
KOKKOS_FORCEINLINE_FUNCTION pair<T1 &,T2 &> Kokkos::tie ( T1 &  x,
T2 &  y 
)

Return a pair of references to the input arguments.

This compares to std::tie (new in C++11). You can use it to assign to two variables at once, from the result of a function that returns a pair. For example (__device__ and __host__ attributes omitted for brevity):

// Declaration of the function to call.
// First return value: operation count.
// Second return value: whether all operations succeeded.
Kokkos::pair<int, bool> someFunction ();
// Code that uses Kokkos::tie.
int myFunction () {
int count = 0;
bool success = false;
// This assigns to both count and success.
Kokkos::tie (count, success) = someFunction ();
if (! success) {
// ... Some operation failed;
// take corrective action ...
}
return count;
}

The line that uses tie() could have been written like this:

Kokkos::pair<int, bool> result = someFunction ();
count = result.first;
success = result.second;

Using tie() saves two lines of code and avoids a copy of each element of the pair. The latter could be significant if one or both elements of the pair are more substantial objects than int or bool.

Definition at line 415 of file Kokkos_Pair.hpp.

template<class ExecPolicy , class FunctorType >
void Kokkos::parallel_for ( const ExecPolicy &  policy,
const FunctorType &  functor,
const std::string &  str = "",
typename Impl::enable_if< !Impl::is_integral< ExecPolicy >::value >::type *  = 0 
)
inline

Execute functor in parallel according to the execution policy.

A "functor" is a class containing the function to execute in parallel, data needed for that execution, and an optional execution_space typedef. Here is an example functor for parallel_for:

class FunctorType {
public:
typedef ... execution_space ;
void operator() ( WorkType iwork ) const ;
};

In the above example, WorkType is any integer type for which a valid conversion from size_t to IntType exists. Its operator() method defines the operation to parallelize, over the range of integer indices iwork=[0,work_count-1]. This compares to a single iteration iwork of a for loop. If execution_space is not defined DefaultExecutionSpace will be used.

Definition at line 197 of file Kokkos_Parallel.hpp.

template<class ExecPolicy , class FunctorType >
void Kokkos::parallel_reduce ( const ExecPolicy &  policy,
const FunctorType &  functor,
const std::string &  str = "",
typename Impl::enable_if< !Impl::is_integral< ExecPolicy >::value >::type *  = 0 
)
inline

Parallel reduction.

Example of a parallel_reduce functor for a POD (plain old data) value type:

class FunctorType { // For POD value type
public:
typedef ... execution_space ;
typedef <podType> value_type ;
void operator()( <intType> iwork , <podType> & update ) const ;
void init( <podType> & update ) const ;
void join( volatile <podType> & update ,
volatile const <podType> & input ) const ;
typedef true_type has_final ;
void final( <podType> & update ) const ;
};

Example of a parallel_reduce functor for an array of POD (plain old data) values:

class FunctorType { // For array of POD value
public:
typedef ... execution_space ;
typedef <podType> value_type[] ;
void operator()( <intType> , <podType> update[] ) const ;
void init( <podType> update[] ) const ;
void join( volatile <podType> update[] ,
volatile const <podType> input[] ) const ;
typedef true_type has_final ;
void final( <podType> update[] ) const ;
};

Definition at line 314 of file Kokkos_Parallel.hpp.

template<class DT , class DL , class DD , class DM , class DS >
void Kokkos::deep_copy ( const View< DT, DL, DD, DM, DS > &  dst,
typename Impl::enable_if<(Impl::is_same< typename ViewTraits< DT, DL, DD, DM >::non_const_value_type, typename ViewTraits< DT, DL, DD, DM >::value_type >::value), typename ViewTraits< DT, DL, DD, DM >::const_value_type >::type &  value 
)
inline

Deep copy a value into a view.

Definition at line 1405 of file Kokkos_View.hpp.

template<class DT , class DL , class DD , class DM , class DS , class ST , class SL , class SD , class SM , class SS >
void Kokkos::deep_copy ( const View< DT, DL, DD, DM, DS > &  dst,
const View< ST, SL, SD, SM, SS > &  src,
typename Impl::enable_if<(Impl::is_same< typename View< DT, DL, DD, DM, DS >::value_type, typename View< ST, SL, SD, SM, SS >::non_const_value_type >::value &&(unsigned(View< DT, DL, DD, DM, DS >::rank)==unsigned(0))&&(unsigned(View< ST, SL, SD, SM, SS >::rank)==unsigned(0)))>::type *  = 0 
)
inline

A deep copy between views of compatible type, and rank zero.

Definition at line 1430 of file Kokkos_View.hpp.

template<class DT , class DL , class DD , class DM , class ST , class SL , class SD , class SM >
void Kokkos::deep_copy ( const View< DT, DL, DD, DM, Impl::ViewDefault > &  dst,
const View< ST, SL, SD, SM, Impl::ViewDefault > &  src 
)
inline

A deep copy between views of the default specialization, compatible type, same non-zero rank, same contiguous layout.

Definition at line 1461 of file Kokkos_View.hpp.

template<class DT , class DL , class DD , class DM , class DS , class ST , class SL , class SD , class SM , class SS >
void Kokkos::deep_copy ( const View< DT, DL, DD, DM, DS > &  dst,
const View< ST, SL, SD, SM, SS > &  src 
)
inline

Deep copy equal dimension arrays in the same space which have different layouts or specializations.

Definition at line 1535 of file Kokkos_View.hpp.

template<class ExecSpace , class DT , class DL , class DD , class DM , class DS >
void Kokkos::deep_copy ( const ExecSpace &  ,
const View< DT, DL, DD, DM, DS > &  dst,
typename Impl::enable_if<(Impl::is_same< typename ViewTraits< DT, DL, DD, DM >::non_const_value_type, typename ViewTraits< DT, DL, DD, DM >::value_type >::value), typename ViewTraits< DT, DL, DD, DM >::const_value_type >::type &  value 
)
inline

Deep copy a value into a view.

Definition at line 1580 of file Kokkos_View.hpp.

template<class ExecSpace , class DT , class DL , class DD , class DM , class DS , class ST , class SL , class SD , class SM , class SS >
void Kokkos::deep_copy ( const ExecSpace &  exec,
const View< DT, DL, DD, DM, DS > &  dst,
const View< ST, SL, SD, SM, SS > &  src,
typename Impl::enable_if<(Impl::is_same< typename View< DT, DL, DD, DM, DS >::value_type, typename View< ST, SL, SD, SM, SS >::non_const_value_type >::value &&(unsigned(View< DT, DL, DD, DM, DS >::rank)==unsigned(0))&&(unsigned(View< ST, SL, SD, SM, SS >::rank)==unsigned(0)))>::type *  = 0 
)
inline

A deep copy between views of compatible type, and rank zero.

Definition at line 1606 of file Kokkos_View.hpp.

template<class ExecSpace , class DT , class DL , class DD , class DM , class ST , class SL , class SD , class SM >
void Kokkos::deep_copy ( const ExecSpace &  exec,
const View< DT, DL, DD, DM, Impl::ViewDefault > &  dst,
const View< ST, SL, SD, SM, Impl::ViewDefault > &  src 
)
inline

A deep copy between views of the default specialization, compatible type, same non-zero rank, same contiguous layout.

Definition at line 1639 of file Kokkos_View.hpp.

template<class ExecSpace , class DT , class DL , class DD , class DM , class DS , class ST , class SL , class SD , class SM , class SS >
void Kokkos::deep_copy ( const ExecSpace &  ,
const View< DT, DL, DD, DM, DS > &  dst,
const View< ST, SL, SD, SM, SS > &  src 
)
inline

Deep copy equal dimension arrays in the same space which have different layouts or specializations.

Definition at line 1715 of file Kokkos_View.hpp.

template<class T , class L , class D , class M , class S >
void Kokkos::resize ( View< T, L, D, M, S > &  v,
const typename Impl::enable_if< ViewTraits< T, L, D, M >::is_managed, size_t >::type  n0,
const size_t  n1 = 0,
const size_t  n2 = 0,
const size_t  n3 = 0,
const size_t  n4 = 0,
const size_t  n5 = 0,
const size_t  n6 = 0,
const size_t  n7 = 0 
)
inline

Resize a view with copying old data to new data at the corresponding indices.

Definition at line 1839 of file Kokkos_View.hpp.

template<class T , class L , class D , class M , class S >
void Kokkos::realloc ( View< T, L, D, M, S > &  v,
const typename Impl::enable_if< ViewTraits< T, L, D, M >::is_managed, size_t >::type  n0,
const size_t  n1 = 0,
const size_t  n2 = 0,
const size_t  n3 = 0,
const size_t  n4 = 0,
const size_t  n5 = 0,
const size_t  n6 = 0,
const size_t  n7 = 0 
)
inline

Reallocate a view without copying old data to new data.

Definition at line 1865 of file Kokkos_View.hpp.