48 template<
class T,
class Enable =
void>
49 struct is_reducer_type {
55 struct is_reducer_type<T,typename std::enable_if<
56 std::is_same<typename std::remove_cv<T>::type,
57 typename std::remove_cv<typename T::reducer_type>::type>::value
62 namespace Experimental {
65 template<
class Scalar,
class Space = HostSpace>
69 typedef Sum reducer_type;
70 typedef Scalar value_type;
74 value_type init_value;
77 result_view_type result;
79 template<class ValueType, bool is_arithmetic = std::is_arithmetic<ValueType>::value >
82 template<
class ValueType >
83 struct InitWrapper<ValueType,true> {
84 static ValueType value() {
85 return static_cast<value_type
>(0);
89 template<
class ValueType >
90 struct InitWrapper<ValueType,false> {
91 static ValueType value() {
98 Sum(value_type& result_):
99 init_value(InitWrapper<value_type>::value()),result(&result_) {}
100 Sum(
const result_view_type& result_):
101 init_value(InitWrapper<value_type>::value()),result(result_) {}
102 Sum(value_type& result_,
const value_type& init_value_):
103 init_value(init_value_),result(&result_) {}
104 Sum(
const result_view_type& result_,
const value_type& init_value_):
105 init_value(init_value_),result(result_) {}
108 KOKKOS_INLINE_FUNCTION
109 void join(value_type& dest,
const value_type& src)
const {
113 KOKKOS_INLINE_FUNCTION
114 void join(
volatile value_type& dest,
const volatile value_type& src)
const {
119 KOKKOS_INLINE_FUNCTION
120 void init( value_type& val)
const {
124 result_view_type result_view()
const {
129 template<
class Scalar,
class Space = HostSpace>
133 typedef Prod reducer_type;
134 typedef Scalar value_type;
138 value_type init_value;
141 result_view_type result;
143 template<class ValueType, bool is_arithmetic = std::is_arithmetic<ValueType>::value >
146 template<
class ValueType >
147 struct InitWrapper<ValueType,true> {
148 static ValueType value() {
149 return static_cast<value_type
>(1);
153 template<
class ValueType >
154 struct InitWrapper<ValueType,false> {
155 static ValueType value() {
162 Prod(value_type& result_):
163 init_value(InitWrapper<value_type>::value()),result(&result_) {}
164 Prod(
const result_view_type& result_):
165 init_value(InitWrapper<value_type>::value()),result(result_) {}
166 Prod(value_type& result_,
const value_type& init_value_):
167 init_value(init_value_),result(&result_) {}
168 Prod(
const result_view_type& result_,
const value_type& init_value_):
169 init_value(init_value_),result(result_) {}
172 KOKKOS_INLINE_FUNCTION
173 void join(value_type& dest,
const value_type& src)
const {
177 KOKKOS_INLINE_FUNCTION
178 void join(
volatile value_type& dest,
const volatile value_type& src)
const {
183 KOKKOS_INLINE_FUNCTION
184 void init( value_type& val)
const {
188 result_view_type result_view()
const {
193 template<
class Scalar,
class Space = HostSpace>
197 typedef Min reducer_type;
198 typedef typename std::remove_cv<Scalar>::type value_type;
202 value_type init_value;
205 result_view_type result;
207 template<class ValueType, bool is_arithmetic = std::is_arithmetic<ValueType>::value >
210 template<
class ValueType >
211 struct InitWrapper<ValueType,true> {
212 static ValueType value() {
213 return std::numeric_limits<value_type>::max();
217 template<
class ValueType >
218 struct InitWrapper<ValueType,false> {
219 static ValueType value() {
226 Min(value_type& result_):
227 init_value(InitWrapper<value_type>::value()),result(&result_) {}
228 Min(
const result_view_type& result_):
229 init_value(InitWrapper<value_type>::value()),result(result_) {}
230 Min(value_type& result_,
const value_type& init_value_):
231 init_value(init_value_),result(&result_) {}
232 Min(
const result_view_type& result_,
const value_type& init_value_):
233 init_value(init_value_),result(result_) {}
236 KOKKOS_INLINE_FUNCTION
237 void join(value_type& dest,
const value_type& src)
const {
242 KOKKOS_INLINE_FUNCTION
243 void join(
volatile value_type& dest,
const volatile value_type& src)
const {
249 KOKKOS_INLINE_FUNCTION
250 void init( value_type& val)
const {
254 result_view_type result_view()
const {
259 template<
class Scalar,
class Space = HostSpace>
263 typedef Max reducer_type;
264 typedef typename std::remove_cv<Scalar>::type value_type;
268 value_type init_value;
271 result_view_type result;
273 template<class ValueType, bool is_arithmetic = std::is_arithmetic<ValueType>::value >
276 template<
class ValueType >
277 struct InitWrapper<ValueType,true> {
278 static ValueType value() {
279 return std::numeric_limits<value_type>::min();
283 template<
class ValueType >
284 struct InitWrapper<ValueType,false> {
285 static ValueType value() {
292 Max(value_type& result_):
293 init_value(InitWrapper<value_type>::value()),result(&result_) {}
294 Max(
const result_view_type& result_):
295 init_value(InitWrapper<value_type>::value()),result(result_) {}
296 Max(value_type& result_,
const value_type& init_value_):
297 init_value(init_value_),result(&result_) {}
298 Max(
const result_view_type& result_,
const value_type& init_value_):
299 init_value(init_value_),result(result_) {}
302 KOKKOS_INLINE_FUNCTION
303 void join(value_type& dest,
const value_type& src)
const {
308 KOKKOS_INLINE_FUNCTION
309 void join(
volatile value_type& dest,
const volatile value_type& src)
const {
315 KOKKOS_INLINE_FUNCTION
316 void init( value_type& val)
const {
320 result_view_type result_view()
const {
325 template<
class Scalar,
class Space = HostSpace>
329 typedef LAnd reducer_type;
330 typedef Scalar value_type;
335 result_view_type result;
339 LAnd(value_type& result_):result(&result_) {}
340 LAnd(
const result_view_type& result_):result(result_) {}
343 KOKKOS_INLINE_FUNCTION
344 void join(value_type& dest,
const value_type& src)
const {
348 KOKKOS_INLINE_FUNCTION
349 void join(
volatile value_type& dest,
const volatile value_type& src)
const {
354 KOKKOS_INLINE_FUNCTION
355 void init( value_type& val)
const {
359 result_view_type result_view()
const {
364 template<
class Scalar,
class Space = HostSpace>
368 typedef LOr reducer_type;
369 typedef Scalar value_type;
374 result_view_type result;
378 LOr(value_type& result_):result(&result_) {}
379 LOr(
const result_view_type& result_):result(result_) {}
382 KOKKOS_INLINE_FUNCTION
383 void join(value_type& dest,
const value_type& src)
const {
387 KOKKOS_INLINE_FUNCTION
388 void join(
volatile value_type& dest,
const volatile value_type& src)
const {
393 KOKKOS_INLINE_FUNCTION
394 void init( value_type& val)
const {
398 result_view_type result_view()
const {
403 template<
class Scalar,
class Space = HostSpace>
407 typedef LXor reducer_type;
408 typedef Scalar value_type;
413 result_view_type result;
417 LXor(value_type& result_):result(&result_) {}
418 LXor(
const result_view_type& result_):result(result_) {}
421 KOKKOS_INLINE_FUNCTION
422 void join(value_type& dest,
const value_type& src)
const {
423 dest = dest? (!src) : src;
426 KOKKOS_INLINE_FUNCTION
427 void join(
volatile value_type& dest,
const volatile value_type& src)
const {
428 dest = dest? (!src) : src;
432 KOKKOS_INLINE_FUNCTION
433 void init( value_type& val)
const {
437 result_view_type result_view()
const {
442 template<
class Scalar,
class Space = HostSpace>
446 typedef BAnd reducer_type;
447 typedef typename std::remove_cv<Scalar>::type value_type;
451 value_type init_value;
454 result_view_type result;
458 BAnd(value_type& result_):
459 init_value(value_type() | (~value_type())),result(&result_) {}
460 BAnd(
const result_view_type& result_):
461 init_value(value_type() | (~value_type())),result(result_) {}
464 KOKKOS_INLINE_FUNCTION
465 void join(value_type& dest,
const value_type& src)
const {
469 KOKKOS_INLINE_FUNCTION
470 void join(
volatile value_type& dest,
const volatile value_type& src)
const {
475 KOKKOS_INLINE_FUNCTION
476 void init( value_type& val)
const {
480 result_view_type result_view()
const {
485 template<
class Scalar,
class Space = HostSpace>
489 typedef BOr reducer_type;
490 typedef typename std::remove_cv<Scalar>::type value_type;
494 value_type init_value;
497 result_view_type result;
501 BOr(value_type& result_):
502 init_value(value_type() & (~value_type())),result(&result_) {}
503 BOr(
const result_view_type& result_):
504 init_value(value_type() & (~value_type())),result(result_) {}
507 KOKKOS_INLINE_FUNCTION
508 void join(value_type& dest,
const value_type& src)
const {
512 KOKKOS_INLINE_FUNCTION
513 void join(
volatile value_type& dest,
const volatile value_type& src)
const {
518 KOKKOS_INLINE_FUNCTION
519 void init( value_type& val)
const {
523 result_view_type result_view()
const {
528 template<
class Scalar,
class Space = HostSpace>
532 typedef BXor reducer_type;
533 typedef typename std::remove_cv<Scalar>::type value_type;
537 value_type init_value;
540 result_view_type result;
544 BXor(value_type& result_):
545 init_value(value_type() & (~value_type())),result(&result_) {}
546 BXor(
const result_view_type& result_):
547 init_value(value_type() & (~value_type())),result(result_) {}
550 KOKKOS_INLINE_FUNCTION
551 void join(value_type& dest,
const value_type& src)
const {
555 KOKKOS_INLINE_FUNCTION
556 void join(
volatile value_type& dest,
const volatile value_type& src)
const {
561 KOKKOS_INLINE_FUNCTION
562 void init( value_type& val)
const {
566 result_view_type result_view()
const {
571 template<
class Scalar,
class Index>
572 struct ValLocScalar {
576 KOKKOS_INLINE_FUNCTION
577 void operator = (
const ValLocScalar& rhs) {
582 KOKKOS_INLINE_FUNCTION
583 void operator = (
const volatile ValLocScalar& rhs)
volatile {
589 template<
class Scalar,
class Index,
class Space = HostSpace>
592 typedef typename std::remove_cv<Scalar>::type scalar_type;
593 typedef typename std::remove_cv<Index>::type index_type;
597 typedef MinLoc reducer_type;
598 typedef ValLocScalar<scalar_type,index_type> value_type;
602 scalar_type init_value;
605 result_view_type result;
607 template<class ValueType, bool is_arithmetic = std::is_arithmetic<ValueType>::value >
610 template<
class ValueType >
611 struct InitWrapper<ValueType,true> {
612 static ValueType value() {
613 return std::numeric_limits<scalar_type>::max();
617 template<
class ValueType >
618 struct InitWrapper<ValueType,false> {
619 static ValueType value() {
620 return scalar_type();
626 MinLoc(value_type& result_):
627 init_value(InitWrapper<scalar_type>::value()),result(&result_) {}
628 MinLoc(
const result_view_type& result_):
629 init_value(InitWrapper<scalar_type>::value()),result(result_) {}
630 MinLoc(value_type& result_,
const scalar_type& init_value_):
631 init_value(init_value_),result(&result_) {}
632 MinLoc(
const result_view_type& result_,
const scalar_type& init_value_):
633 init_value(init_value_),result(result_) {}
637 KOKKOS_INLINE_FUNCTION
638 void join(value_type& dest,
const value_type& src)
const {
639 if ( src.val < dest.val )
643 KOKKOS_INLINE_FUNCTION
644 void join(
volatile value_type& dest,
const volatile value_type& src)
const {
645 if ( src.val < dest.val )
650 KOKKOS_INLINE_FUNCTION
651 void init( value_type& val)
const {
652 val.val = init_value;
655 result_view_type result_view()
const {
660 template<
class Scalar,
class Index,
class Space = HostSpace>
663 typedef typename std::remove_cv<Scalar>::type scalar_type;
664 typedef typename std::remove_cv<Index>::type index_type;
668 typedef MaxLoc reducer_type;
669 typedef ValLocScalar<scalar_type,index_type> value_type;
673 scalar_type init_value;
676 result_view_type result;
678 template<class ValueType, bool is_arithmetic = std::is_arithmetic<ValueType>::value >
681 template<
class ValueType >
682 struct InitWrapper<ValueType,true> {
683 static ValueType value() {
684 return std::numeric_limits<scalar_type>::min();
688 template<
class ValueType >
689 struct InitWrapper<ValueType,false> {
690 static ValueType value() {
691 return scalar_type();
697 MaxLoc(value_type& result_):
698 init_value(InitWrapper<scalar_type>::value()),result(&result_) {}
699 MaxLoc(
const result_view_type& result_):
700 init_value(InitWrapper<scalar_type>::value()),result(result_) {}
701 MaxLoc(value_type& result_,
const scalar_type& init_value_):
702 init_value(init_value_),result(&result_) {}
703 MaxLoc(
const result_view_type& result_,
const scalar_type& init_value_):
704 init_value(init_value_),result(result_) {}
707 KOKKOS_INLINE_FUNCTION
708 void join(value_type& dest,
const value_type& src)
const {
709 if ( src.val > dest.val )
713 KOKKOS_INLINE_FUNCTION
714 void join(
volatile value_type& dest,
const volatile value_type& src)
const {
715 if ( src.val > dest.val )
720 KOKKOS_INLINE_FUNCTION
721 void init( value_type& val)
const {
722 val.val = init_value;
725 result_view_type result_view()
const {
730 template<
class Scalar>
731 struct MinMaxScalar {
732 Scalar min_val,max_val;
734 KOKKOS_INLINE_FUNCTION
735 void operator = (
const MinMaxScalar& rhs) {
736 min_val = rhs.min_val;
737 max_val = rhs.max_val;
740 KOKKOS_INLINE_FUNCTION
741 void operator = (
const volatile MinMaxScalar& rhs)
volatile {
742 min_val = rhs.min_val;
743 max_val = rhs.max_val;
747 template<
class Scalar,
class Space = HostSpace>
750 typedef typename std::remove_cv<Scalar>::type scalar_type;
754 typedef MinMax reducer_type;
755 typedef MinMaxScalar<scalar_type> value_type;
759 scalar_type min_init_value;
760 scalar_type max_init_value;
763 result_view_type result;
765 template<class ValueType, bool is_arithmetic = std::is_arithmetic<ValueType>::value >
766 struct MinInitWrapper;
768 template<
class ValueType >
769 struct MinInitWrapper<ValueType,true> {
770 static ValueType value() {
771 return std::numeric_limits<scalar_type>::max();
775 template<
class ValueType >
776 struct MinInitWrapper<ValueType,false> {
777 static ValueType value() {
778 return scalar_type();
782 template<class ValueType, bool is_arithmetic = std::is_arithmetic<ValueType>::value >
783 struct MaxInitWrapper;
785 template<
class ValueType >
786 struct MaxInitWrapper<ValueType,true> {
787 static ValueType value() {
788 return std::numeric_limits<scalar_type>::min();
792 template<
class ValueType >
793 struct MaxInitWrapper<ValueType,false> {
794 static ValueType value() {
795 return scalar_type();
801 MinMax(value_type& result_):
802 min_init_value(MinInitWrapper<scalar_type>::value()),max_init_value(MaxInitWrapper<scalar_type>::value()),result(&result_) {}
803 MinMax(
const result_view_type& result_):
804 min_init_value(MinInitWrapper<scalar_type>::value()),max_init_value(MaxInitWrapper<scalar_type>::value()),result(result_) {}
805 MinMax(value_type& result_,
const scalar_type& min_init_value_,
const scalar_type& max_init_value_):
806 min_init_value(min_init_value_),max_init_value(max_init_value_),result(&result_) {}
807 MinMax(
const result_view_type& result_,
const scalar_type& min_init_value_,
const scalar_type& max_init_value_):
808 min_init_value(min_init_value_),max_init_value(max_init_value_),result(result_) {}
811 KOKKOS_INLINE_FUNCTION
812 void join(value_type& dest,
const value_type& src)
const {
813 if ( src.min_val < dest.min_val ) {
814 dest.min_val = src.min_val;
816 if ( src.max_val > dest.max_val ) {
817 dest.max_val = src.max_val;
821 KOKKOS_INLINE_FUNCTION
822 void join(
volatile value_type& dest,
const volatile value_type& src)
const {
823 if ( src.min_val < dest.min_val ) {
824 dest.min_val = src.min_val;
826 if ( src.max_val > dest.max_val ) {
827 dest.max_val = src.max_val;
832 KOKKOS_INLINE_FUNCTION
833 void init( value_type& val)
const {
834 val.min_val = min_init_value;
835 val.max_val = max_init_value;
838 result_view_type result_view()
const {
843 template<
class Scalar,
class Index>
844 struct MinMaxLocScalar {
845 Scalar min_val,max_val;
846 Index min_loc,max_loc;
848 KOKKOS_INLINE_FUNCTION
849 void operator = (
const MinMaxLocScalar& rhs) {
850 min_val = rhs.min_val;
851 min_loc = rhs.min_loc;
852 max_val = rhs.max_val;
853 max_loc = rhs.max_loc;
856 KOKKOS_INLINE_FUNCTION
857 void operator = (
const volatile MinMaxLocScalar& rhs)
volatile {
858 min_val = rhs.min_val;
859 min_loc = rhs.min_loc;
860 max_val = rhs.max_val;
861 max_loc = rhs.max_loc;
865 template<
class Scalar,
class Index,
class Space = HostSpace>
868 typedef typename std::remove_cv<Scalar>::type scalar_type;
869 typedef typename std::remove_cv<Index>::type index_type;
873 typedef MinMaxLoc reducer_type;
874 typedef MinMaxLocScalar<scalar_type,index_type> value_type;
878 scalar_type min_init_value;
879 scalar_type max_init_value;
882 result_view_type result;
884 template<class ValueType, bool is_arithmetic = std::is_arithmetic<ValueType>::value >
885 struct MinInitWrapper;
887 template<
class ValueType >
888 struct MinInitWrapper<ValueType,true> {
889 static ValueType value() {
890 return std::numeric_limits<scalar_type>::max();
894 template<
class ValueType >
895 struct MinInitWrapper<ValueType,false> {
896 static ValueType value() {
897 return scalar_type();
901 template<class ValueType, bool is_arithmetic = std::is_arithmetic<ValueType>::value >
902 struct MaxInitWrapper;
904 template<
class ValueType >
905 struct MaxInitWrapper<ValueType,true> {
906 static ValueType value() {
907 return std::numeric_limits<scalar_type>::min();
911 template<
class ValueType >
912 struct MaxInitWrapper<ValueType,false> {
913 static ValueType value() {
914 return scalar_type();
920 MinMaxLoc(value_type& result_):
921 min_init_value(MinInitWrapper<scalar_type>::value()),max_init_value(MaxInitWrapper<scalar_type>::value()),result(&result_) {}
922 MinMaxLoc(
const result_view_type& result_):
923 min_init_value(MinInitWrapper<scalar_type>::value()),max_init_value(MaxInitWrapper<scalar_type>::value()),result(result_) {}
924 MinMaxLoc(value_type& result_,
const scalar_type& min_init_value_,
const scalar_type& max_init_value_):
925 min_init_value(min_init_value_),max_init_value(max_init_value_),result(&result_) {}
926 MinMaxLoc(
const result_view_type& result_,
const scalar_type& min_init_value_,
const scalar_type& max_init_value_):
927 min_init_value(min_init_value_),max_init_value(max_init_value_),result(result_) {}
930 KOKKOS_INLINE_FUNCTION
931 void join(value_type& dest,
const value_type& src)
const {
932 if ( src.min_val < dest.min_val ) {
933 dest.min_val = src.min_val;
934 dest.min_loc = src.min_loc;
936 if ( src.max_val > dest.max_val ) {
937 dest.max_val = src.max_val;
938 dest.max_loc = src.max_loc;
942 KOKKOS_INLINE_FUNCTION
943 void join(
volatile value_type& dest,
const volatile value_type& src)
const {
944 if ( src.min_val < dest.min_val ) {
945 dest.min_val = src.min_val;
946 dest.min_loc = src.min_loc;
948 if ( src.max_val > dest.max_val ) {
949 dest.max_val = src.max_val;
950 dest.max_loc = src.max_loc;
955 KOKKOS_INLINE_FUNCTION
956 void init( value_type& val)
const {
957 val.min_val = min_init_value;
958 val.max_val = max_init_value;
961 result_view_type result_view()
const {
972 template<
class T,
class ReturnType ,
class ValueTraits>
973 struct ParallelReduceReturnValue;
975 template<
class ReturnType ,
class FunctorType >
976 struct ParallelReduceReturnValue<typename std::enable_if<Kokkos::is_view<ReturnType>::value>::type, ReturnType, FunctorType> {
977 typedef ReturnType return_type;
978 typedef InvalidType reducer_type;
980 typedef typename return_type::value_type value_type_scalar;
981 typedef typename return_type::value_type value_type_array[];
983 typedef typename if_c<return_type::rank==0,value_type_scalar,value_type_array>::type value_type;
985 static return_type& return_value(ReturnType& return_val,
const FunctorType&) {
990 template<
class ReturnType ,
class FunctorType>
991 struct ParallelReduceReturnValue<typename std::enable_if<
992 !Kokkos::is_view<ReturnType>::value &&
993 (!std::is_array<ReturnType>::value && !std::is_pointer<ReturnType>::value) &&
994 !Kokkos::is_reducer_type<ReturnType>::value
995 >::type, ReturnType, FunctorType> {
998 , Kokkos::MemoryUnmanaged
1001 typedef InvalidType reducer_type;
1003 typedef typename return_type::value_type value_type;
1005 static return_type return_value(ReturnType& return_val,
const FunctorType&) {
1006 return return_type(&return_val);
1010 template<
class ReturnType ,
class FunctorType>
1011 struct ParallelReduceReturnValue<typename std::enable_if<
1012 (is_array<ReturnType>::value || std::is_pointer<ReturnType>::value)
1013 >::type, ReturnType, FunctorType> {
1016 , Kokkos::MemoryUnmanaged
1019 typedef InvalidType reducer_type;
1021 typedef typename return_type::value_type value_type[];
1023 static return_type return_value(ReturnType& return_val,
1024 const FunctorType& functor) {
1025 return return_type(return_val,functor.value_count);
1029 template<
class ReturnType ,
class FunctorType>
1030 struct ParallelReduceReturnValue<typename std::enable_if<
1031 Kokkos::is_reducer_type<ReturnType>::value
1032 >::type, ReturnType, FunctorType> {
1033 typedef ReturnType return_type;
1034 typedef ReturnType reducer_type;
1035 typedef typename return_type::value_type value_type;
1037 static return_type return_value(ReturnType& return_val,
1038 const FunctorType& functor) {
1045 template<
class T,
class ReturnType ,
class FunctorType>
1046 struct ParallelReducePolicyType;
1048 template<
class PolicyType ,
class FunctorType >
1049 struct ParallelReducePolicyType<typename std::enable_if<Kokkos::Impl::is_execution_policy<PolicyType>::value>::type, PolicyType,FunctorType> {
1051 typedef PolicyType policy_type;
1052 static PolicyType policy(
const PolicyType& policy_) {
1057 template<
class PolicyType ,
class FunctorType >
1058 struct ParallelReducePolicyType<typename std::enable_if<std::is_integral<PolicyType>::value>::type, PolicyType,FunctorType> {
1060 Impl::FunctorPolicyExecutionSpace< FunctorType , void >::execution_space
1065 static policy_type policy(
const PolicyType& policy_) {
1066 return policy_type(0,policy_);
1073 template<
class FunctorType,
class ExecPolicy,
class ValueType,
class ExecutionSpace>
1074 struct ParallelReduceFunctorType {
1075 typedef FunctorType functor_type;
1076 static const functor_type& functor(
const functor_type& functor) {
1084 template<
class PolicyType,
class FunctorType,
class ReturnType >
1085 struct ParallelReduceAdaptor {
1086 typedef Impl::ParallelReduceReturnValue<void,ReturnType,FunctorType> return_value_adapter;
1087 #ifdef KOKKOS_IMPL_NEED_FUNCTOR_WRAPPER 1088 typedef Impl::ParallelReduceFunctorType<FunctorType,PolicyType,
1089 typename return_value_adapter::value_type,
1090 typename PolicyType::execution_space> functor_adaptor;
1093 void execute(
const std::string& label,
1094 const PolicyType& policy,
1095 const FunctorType& functor,
1096 ReturnType& return_value) {
1097 #if (KOKKOS_ENABLE_PROFILING) 1099 if(Kokkos::Profiling::profileLibraryLoaded()) {
1100 Kokkos::Profiling::beginParallelReduce(
"" == label ?
typeid(FunctorType).name() : label, 0, &kpID);
1104 Kokkos::Impl::shared_allocation_tracking_claim_and_disable();
1105 #ifdef KOKKOS_IMPL_NEED_FUNCTOR_WRAPPER 1106 Impl::ParallelReduce<typename functor_adaptor::functor_type, PolicyType, typename return_value_adapter::reducer_type >
1107 closure(functor_adaptor::functor(functor),
1109 return_value_adapter::return_value(return_value,functor));
1111 Impl::ParallelReduce<FunctorType, PolicyType, typename return_value_adapter::reducer_type >
1114 return_value_adapter::return_value(return_value,functor));
1116 Kokkos::Impl::shared_allocation_tracking_release_and_enable();
1119 #if (KOKKOS_ENABLE_PROFILING) 1120 if(Kokkos::Profiling::profileLibraryLoaded()) {
1121 Kokkos::Profiling::endParallelReduce(kpID);
1177 template<
class PolicyType,
class FunctorType,
class ReturnType >
1180 const PolicyType& policy,
1181 const FunctorType& functor,
1182 ReturnType& return_value,
1183 typename Impl::enable_if<
1184 Kokkos::Impl::is_execution_policy<PolicyType>::value
1186 Impl::ParallelReduceAdaptor<PolicyType,FunctorType,ReturnType>::execute(label,policy,functor,return_value);
1189 template<
class PolicyType,
class FunctorType,
class ReturnType >
1192 const FunctorType& functor,
1193 ReturnType& return_value,
1194 typename Impl::enable_if<
1195 Kokkos::Impl::is_execution_policy<PolicyType>::value
1197 Impl::ParallelReduceAdaptor<PolicyType,FunctorType,ReturnType>::execute(
"",policy,functor,return_value);
1200 template<
class FunctorType,
class ReturnType >
1203 const FunctorType& functor,
1204 ReturnType& return_value) {
1205 typedef typename Impl::ParallelReducePolicyType<void,size_t,FunctorType>::policy_type policy_type;
1206 Impl::ParallelReduceAdaptor<policy_type,FunctorType,ReturnType>::execute(
"",policy_type(0,policy),functor,return_value);
1209 template<
class FunctorType,
class ReturnType >
1212 const size_t& policy,
1213 const FunctorType& functor,
1214 ReturnType& return_value) {
1215 typedef typename Impl::ParallelReducePolicyType<void,size_t,FunctorType>::policy_type policy_type;
1216 Impl::ParallelReduceAdaptor<policy_type,FunctorType,ReturnType>::execute(label,policy_type(0,policy),functor,return_value);
1221 template<
class PolicyType,
class FunctorType,
class ReturnType >
1224 const PolicyType& policy,
1225 const FunctorType& functor,
1226 const ReturnType& return_value,
1227 typename Impl::enable_if<
1228 Kokkos::Impl::is_execution_policy<PolicyType>::value
1230 Impl::ParallelReduceAdaptor<PolicyType,FunctorType,const ReturnType>::execute(label,policy,functor,return_value);
1233 template<
class PolicyType,
class FunctorType,
class ReturnType >
1236 const FunctorType& functor,
1237 const ReturnType& return_value,
1238 typename Impl::enable_if<
1239 Kokkos::Impl::is_execution_policy<PolicyType>::value
1241 ReturnType return_value_impl = return_value;
1242 Impl::ParallelReduceAdaptor<PolicyType,FunctorType,ReturnType>::execute(
"",policy,functor,return_value_impl);
1245 template<
class FunctorType,
class ReturnType >
1248 const FunctorType& functor,
1249 const ReturnType& return_value) {
1250 typedef typename Impl::ParallelReducePolicyType<void,size_t,FunctorType>::policy_type policy_type;
1251 ReturnType return_value_impl = return_value;
1252 Impl::ParallelReduceAdaptor<policy_type,FunctorType,ReturnType>::execute(
"",policy_type(0,policy),functor,return_value_impl);
1255 template<
class FunctorType,
class ReturnType >
1258 const size_t& policy,
1259 const FunctorType& functor,
1260 const ReturnType& return_value) {
1261 typedef typename Impl::ParallelReducePolicyType<void,size_t,FunctorType>::policy_type policy_type;
1262 ReturnType return_value_impl = return_value;
1263 Impl::ParallelReduceAdaptor<policy_type,FunctorType,ReturnType>::execute(label,policy_type(0,policy),functor,return_value_impl);
1268 template<
class PolicyType,
class FunctorType>
1271 const PolicyType& policy,
1272 const FunctorType& functor,
1273 typename Impl::enable_if<
1274 Kokkos::Impl::is_execution_policy<PolicyType>::value
1276 typedef Kokkos::Impl::FunctorValueTraits< FunctorType , void > ValueTraits ;
1277 typedef typename Kokkos::Impl::if_c< (ValueTraits::StaticValueSize != 0)
1278 ,
typename ValueTraits::value_type
1279 ,
typename ValueTraits::pointer_type
1280 >::type value_type ;
1284 , Kokkos::MemoryUnmanaged
1286 result_view_type result_view ;
1288 Impl::ParallelReduceAdaptor<PolicyType,FunctorType,result_view_type>::execute(label,policy,functor,result_view);
1291 template<
class PolicyType,
class FunctorType >
1294 const FunctorType& functor,
1295 typename Impl::enable_if<
1296 Kokkos::Impl::is_execution_policy<PolicyType>::value
1298 typedef Kokkos::Impl::FunctorValueTraits< FunctorType , void > ValueTraits ;
1299 typedef typename Kokkos::Impl::if_c< (ValueTraits::StaticValueSize != 0)
1300 ,
typename ValueTraits::value_type
1301 ,
typename ValueTraits::pointer_type
1302 >::type value_type ;
1306 , Kokkos::MemoryUnmanaged
1308 result_view_type result_view ;
1310 Impl::ParallelReduceAdaptor<PolicyType,FunctorType,result_view_type>::execute(
"",policy,functor,result_view);
1313 template<
class FunctorType >
1316 const FunctorType& functor) {
1317 typedef typename Impl::ParallelReducePolicyType<void,size_t,FunctorType>::policy_type policy_type;
1318 typedef Kokkos::Impl::FunctorValueTraits< FunctorType , void > ValueTraits ;
1319 typedef typename Kokkos::Impl::if_c< (ValueTraits::StaticValueSize != 0)
1320 ,
typename ValueTraits::value_type
1321 ,
typename ValueTraits::pointer_type
1322 >::type value_type ;
1326 , Kokkos::MemoryUnmanaged
1328 result_view_type result_view ;
1330 Impl::ParallelReduceAdaptor<policy_type,FunctorType,result_view_type>::execute(
"",policy_type(0,policy),functor,result_view);
1333 template<
class FunctorType>
1336 const size_t& policy,
1337 const FunctorType& functor) {
1338 typedef typename Impl::ParallelReducePolicyType<void,size_t,FunctorType>::policy_type policy_type;
1339 typedef Kokkos::Impl::FunctorValueTraits< FunctorType , void > ValueTraits ;
1340 typedef typename Kokkos::Impl::if_c< (ValueTraits::StaticValueSize != 0)
1341 ,
typename ValueTraits::value_type
1342 ,
typename ValueTraits::pointer_type
1343 >::type value_type ;
1347 , Kokkos::MemoryUnmanaged
1349 result_view_type result_view ;
1351 Impl::ParallelReduceAdaptor<policy_type,FunctorType,result_view_type>::execute(label,policy_type(0,policy),functor,result_view);
void parallel_reduce(const std::string &label, const PolicyType &policy, const FunctorType &functor, ReturnType &return_value, typename Impl::enable_if< Kokkos::Impl::is_execution_policy< PolicyType >::value >::type *=0)
Parallel reduction.
View to an array of data.
Memory management for host memory.
Execution policy for work over a range of an integral type.