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
Copyright © 2010, Intel Corporation. All rights reserved.