collective.hpp

Go to the documentation of this file.
00001 /****
00002 ***** Copyright 2010 Intel Corporation All Rights Reserved.
00003 *****
00004 ***** The source code, information and material contained herein are owned by Intel Corporation or its suppliers  *****
00005 ***** or licensors, and title to such Material remains with Intel Corporation or its suppliers or licensors.      *****
00006 ***** The Material contains proprietary information of Intel or its suppliers and licensors. The Material is      *****
00007 ***** protected by worldwide copyright laws and treaty provisions. No part of the Material may be used, copied,   *****
00008 ***** reproduced, modified, published, uploaded, posted, transmitted, distributed or disclosed in any way without *****
00009 ***** Intel's prior express written permission.
00010 *****
00011 ***** No license under any patent, copyright or other intellectual property rights in the material is granted to  *****
00012 ***** or conferred upon you, either expressly, by implication, inducement, estoppel or otherwise. Any license     *****
00013 ***** under such intellectual property rights must be express and approved by Intel in writing.
00014 ****/
00015 
00016 /**** Copyright Ends ****/
00017 
00018 //
00019 // This file was automatically generated and should not be edited directly.
00020 //
00021 
00022 #ifndef ARBB_CPP_COLLECTIVE_HPP
00023 #define ARBB_CPP_COLLECTIVE_HPP
00024 
00025 #include "namespace.hpp"
00026 #include <arbb_vmapi.h>
00027 #include "detail/error_details.hpp"
00028 #include "detail/enable_if.hpp"
00029 #include "detail/function.hpp"
00030 #include "detail/scalar_traits.hpp"
00031 #include "detail/type_traits.hpp"
00032 #include "scalar.hpp"
00033 #include "type_traits.hpp"
00034 
00035 
00036 
00037 namespace ARBB_CPP_NS {
00038 
00041 
00043 
00044 namespace detail {
00045 
00046 template <typename T>
00047 struct collective_enabled {
00048   typedef container_traits<T> traits;
00049   enum { value = traits::is_container && is_scalar<typename traits::element_type>::value };
00050 };
00051 
00052 template <typename T>
00053 struct collective_val_enabled {
00054   typedef container_traits<T> traits;
00055   enum { value = traits::is_container && (is_scalar<typename traits::element_type>::value && is_scalar_boolean<typename traits::element_type>::value == 0) };
00056 };
00057 
00058 template <typename T>
00059 struct collective_fp_enabled {
00060   typedef container_traits<T> traits;
00061   enum { value = traits::is_container && is_scalar_fp<typename traits::element_type>::value };
00062 };
00063 
00064 template <typename T>
00065 struct collective_int_enabled {
00066   typedef container_traits<T> traits;
00067   enum { value = traits::is_container && is_scalar_int<typename traits::element_type>::value };
00068 };
00069 
00070 template <typename T>
00071 struct collective_bool_enabled {
00072   typedef container_traits<T> traits;
00073   enum { value = traits::is_container && is_scalar_boolean<typename traits::element_type>::value };
00074 };
00075 
00076 template <typename T> struct reduced { typedef T type; };
00077 template <typename T> struct reduced<dense<T, 1> > { typedef T type; };
00078 template <typename T> struct reduced<dense<T, 2> > { typedef dense<T, 1> type; };
00079 template <typename T> struct reduced<dense<T, 3> > { typedef dense<T, 2> type; };
00080 template <typename T> struct reduced<nested<T> > { typedef dense<T, 1> type; };
00081 
00082 template <typename T>
00083 typename reduced<T>::type
00084 reduce_op(arbb_opcode_t op, const T& source, unsigned int level_)
00085 {
00086   if (detail::capturing_closure::in_map()) {
00087     throw invalid_op_within_map("reduction operation cannot be used within a map");
00088   }
00089 
00090   typedef typename reduced<T>::type R;
00091   R result;
00092   usize level(level_);
00093   unsigned int num_inputs = container_traits<R>::is_container ? 2 : 1;
00094   const arbb_variable_t outputs[] = { result.vm_variable() };
00095   const arbb_variable_t inputs[] = { *source.containers_begin(), level.vm_variable() };
00096   arbb_op_dynamic(function::current(), op, 1, outputs, num_inputs, inputs, 0, throw_on_error_details());
00097   return result;
00098 }
00099 
00100 template <typename T, std::size_t D>
00101 typename reduced<dense<T, D> >::type
00102 reduce_op(arbb_opcode_t op, const dense<T, D>& source,
00103           typename reduced<dense<usize, D> >::type& loc,
00104           unsigned int level_)
00105 {
00106   if (detail::capturing_closure::in_map()) {
00107     throw invalid_op_within_map("reduction operation cannot be used within a map");
00108   }
00109 
00110   typedef typename reduced<dense<T, D> >::type R;
00111   R result;
00112   usize level(level_);
00113   unsigned int num_inputs = container_traits<R>::is_container ? 2 : 1;
00114   const arbb_variable_t outputs[] = { result.vm_variable(), loc.vm_variable() };
00115   const arbb_variable_t inputs[] = { source.vm_variable(), level.vm_variable() };
00116   arbb_op_dynamic(function::current(), op, 2, outputs, num_inputs, inputs, 0, throw_on_error_details());
00117   return result;
00118 }
00119 
00120 template <typename T>
00121 T scan_op(arbb_opcode_t op, const T& source, unsigned int level_)
00122 {
00123   if (detail::capturing_closure::in_map()) {
00124     throw invalid_op_within_map("scan operation cannot be used within a map");
00125   }
00126 
00127   T result;
00128   usize direction = 0;
00129   usize level = level_;
00130   const arbb_variable_t outputs[] = { result.vm_variable() };
00131   const arbb_variable_t inputs[] = { *source.containers_begin(), direction.vm_variable(), level.vm_variable() };
00132   arbb_op(function::current(), op, outputs, inputs, 0, throw_on_error_details());
00133   return result;
00134 }
00135 
00136 } // namespace detail
00137 
00139 
00146 template <typename T>
00147 typename detail::disable_if<!detail::collective_val_enabled<T>::value, typename detail::reduced<T>::type>::type
00148 add_reduce(const T& source, unsigned int level = 0)
00149 {
00150   return detail::reduce_op(arbb_op_add_reduce, source, level);
00151 }
00152 
00159 template <typename T>
00160 typename detail::disable_if<!detail::collective_val_enabled<T>::value, typename detail::reduced<T>::type>::type
00161 mul_reduce(const T& source, unsigned int level = 0)
00162 {
00163   return detail::reduce_op(arbb_op_mul_reduce, source, level);
00164 }
00165 
00171 template <typename T>
00172 typename detail::disable_if<!detail::collective_enabled<T>::value, typename detail::reduced<T>::type>::type
00173 min_reduce(const T& source, unsigned int level = 0)
00174 {
00175   return detail::reduce_op(arbb_op_min_reduce, source, level);
00176 }
00177 
00183 template <typename T>
00184 typename detail::disable_if<!detail::collective_enabled<T>::value, typename detail::reduced<T>::type>::type
00185 max_reduce(const T& source, unsigned int level = 0)
00186 {
00187   return detail::reduce_op(arbb_op_max_reduce, source, level);
00188 }
00189 
00195 template <typename T>
00196 typename detail::disable_if<!detail::collective_bool_enabled<T>::value, typename detail::reduced<T>::type>::type
00197 and_reduce(const T& source, unsigned int level = 0)
00198 {
00199   return detail::reduce_op(arbb_op_and_reduce, source, level);
00200 }
00201 
00207 template <typename T>
00208 typename detail::disable_if<!detail::collective_bool_enabled<T>::value, typename detail::reduced<T>::type>::type
00209 ior_reduce(const T& source, unsigned int level = 0)
00210 {
00211   return detail::reduce_op(arbb_op_ior_reduce, source, level);
00212 }
00213 
00219 template <typename T>
00220 typename detail::disable_if<!detail::collective_bool_enabled<T>::value, typename detail::reduced<T>::type>::type
00221 xor_reduce(const T& source, unsigned int level = 0)
00222 {
00223   return detail::reduce_op(arbb_op_xor_reduce, source, level);
00224 }
00225 
00227 template <typename T>
00228 typename detail::disable_if<!detail::collective_bool_enabled<T>::value, boolean>::type
00229 any(const T& source)
00230 {
00231   return ior_reduce(source.flatten());
00232 }
00233 
00235 template <typename T>
00236 typename detail::disable_if<!detail::collective_bool_enabled<T>::value, boolean>::type
00237 all(const T& source)
00238 {
00239   return and_reduce(source.flatten());
00240 }
00241 
00243 template <typename T>
00244 typename detail::disable_if<!detail::collective_enabled<T>::value, typename detail::container_traits<T>::element_type>::type
00245 sum(const T& source)
00246 {
00247   return add_reduce(source.flatten());
00248 }
00249 
00252 template <typename T, std::size_t D>
00253 typename detail::disable_if<!detail::collective_enabled<dense<T, D> >::value, typename detail::reduced<dense<T, D> >::type>::type
00254 min_reduce(const dense<T, D>& source,
00255            typename detail::reduced<dense<usize, D> >::type& loc,
00256            unsigned int level = 0)
00257 {
00258   return detail::reduce_op(arbb_op_min_reduce_loc, source, loc, level);
00259 }
00260 
00263 template <typename T, std::size_t D>
00264 typename detail::disable_if<!detail::collective_enabled<dense<T, D> >::value, typename detail::reduced<dense<T, D> >::type>::type
00265 max_reduce(const dense<T, D>& source,
00266            typename detail::reduced<dense<usize, D> >::type& loc,
00267            unsigned int level = 0)
00268 {
00269   return detail::reduce_op(arbb_op_max_reduce_loc, source, loc, level);
00270 }
00271 
00272 
00279 template <typename T>
00280 typename detail::disable_if<!detail::collective_val_enabled<T>::value, T>::type
00281 add_scan(const T& source, unsigned int level = 0)
00282 {
00283   return detail::scan_op(arbb_op_add_scan, source, level);
00284 }
00285 
00292 template <typename T>
00293 typename detail::disable_if<!detail::collective_val_enabled<T>::value, T>::type
00294 add_iscan(const T& source, unsigned int level = 0)
00295 {
00296   return source + add_scan(source, level);
00297 }
00298 
00305 template <typename T>
00306 typename detail::disable_if<!detail::collective_val_enabled<T>::value, T>::type
00307 mul_scan(const T& source, unsigned int level = 0)
00308 {
00309   return detail::scan_op(arbb_op_mul_scan, source, level);
00310 }
00311 
00318 template <typename T>
00319 typename detail::disable_if<!detail::collective_val_enabled<T>::value, T>::type
00320 mul_iscan(const T& source, unsigned int level = 0)
00321 {
00322   return source * mul_scan(source, level);
00323 }
00324 
00331 template <typename T>
00332 typename detail::disable_if<!detail::collective_val_enabled<T>::value, T>::type
00333 min_scan(const T& source, unsigned int level = 0)
00334 {
00335   return detail::scan_op(arbb_op_min_scan, source, level);
00336 }
00337 
00344 template <typename T>
00345 typename detail::disable_if<!detail::collective_val_enabled<T>::value, T>::type
00346 min_iscan(const T& source, unsigned int level = 0)
00347 {
00348   return min(source, min_scan(source, level));
00349 }
00350 
00357 template <typename T>
00358 typename detail::disable_if<!detail::collective_val_enabled<T>::value, T>::type
00359 max_scan(const T& source, unsigned int level = 0)
00360 {
00361   return detail::scan_op(arbb_op_max_scan, source, level);
00362 }
00363 
00370 template <typename T>
00371 typename detail::disable_if<!detail::collective_val_enabled<T>::value, T>::type
00372 max_iscan(const T& source, unsigned int level = 0)
00373 {
00374   return max(source, max_scan(source, level));
00375 }
00376 
00382 template <typename T>
00383 typename detail::disable_if<!detail::collective_bool_enabled<T>::value, T>::type
00384 and_scan(const T& source, unsigned int level = 0)
00385 {
00386   return detail::scan_op(arbb_op_and_scan, source, level);
00387 }
00388 
00394 template <typename T>
00395 typename detail::disable_if<!detail::collective_bool_enabled<T>::value, T>::type
00396 and_iscan(const T& source, unsigned int level = 0)
00397 {
00398   return source && and_scan(source, level);
00399 }
00400 
00406 template <typename T>
00407 typename detail::disable_if<!detail::collective_bool_enabled<T>::value, T>::type
00408 ior_scan(const T& source, unsigned int level = 0)
00409 {
00410   return detail::scan_op(arbb_op_ior_scan, source, level);
00411 }
00412 
00418 template <typename T>
00419 typename detail::disable_if<!detail::collective_bool_enabled<T>::value, T>::type
00420 ior_iscan(const T& source, unsigned int level = 0)
00421 {
00422   return source || ior_scan(source, level);
00423 }
00424 
00430 template <typename T>
00431 typename detail::disable_if<!detail::collective_bool_enabled<T>::value, T>::type
00432 xor_scan(const T& source, unsigned int level = 0)
00433 {
00434   return detail::scan_op(arbb_op_xor_scan, source, level);
00435 }
00436 
00442 template <typename T>
00443 typename detail::disable_if<!detail::collective_bool_enabled<T>::value, T>::type
00444 xor_iscan(const T& source, unsigned int level = 0)
00445 {
00446   return source != xor_scan(source, level);
00447 }
00448 
00450 
00451 
00452 } // namespace ARBB_CPP_NS
00453 
00454 
00455 
00456 #endif // ARBB_CPP_COLLECTIVE_HPP
00457 
00458 

Submit feedback on this help topic

Copyright © 2010, Intel Corporation. All rights reserved.