ViennaCL - The Vienna Computing Library
1.5.2
|
00001 #ifndef VIENNACL_TRAITS_HANDLE_HPP_ 00002 #define VIENNACL_TRAITS_HANDLE_HPP_ 00003 00004 /* ========================================================================= 00005 Copyright (c) 2010-2014, Institute for Microelectronics, 00006 Institute for Analysis and Scientific Computing, 00007 TU Wien. 00008 Portions of this software are copyright by UChicago Argonne, LLC. 00009 00010 ----------------- 00011 ViennaCL - The Vienna Computing Library 00012 ----------------- 00013 00014 Project Head: Karl Rupp rupp@iue.tuwien.ac.at 00015 00016 (A list of authors and contributors can be found in the PDF manual) 00017 00018 License: MIT (X11), see file LICENSE in the base directory 00019 ============================================================================= */ 00020 00025 #include <string> 00026 #include <fstream> 00027 #include <sstream> 00028 #include "viennacl/forwards.h" 00029 00030 #include "viennacl/backend/mem_handle.hpp" 00031 00032 namespace viennacl 00033 { 00034 namespace traits 00035 { 00036 // 00037 // Generic memory handle 00038 // 00040 template <typename T> 00041 viennacl::backend::mem_handle & handle(T & obj) 00042 { 00043 return obj.handle(); 00044 } 00045 00047 template <typename T> 00048 viennacl::backend::mem_handle const & handle(T const & obj) 00049 { 00050 return obj.handle(); 00051 } 00052 00054 inline char handle(char val) { return val; } //for unification purposes when passing CPU-scalars to kernels 00055 inline short handle(short val) { return val; } //for unification purposes when passing CPU-scalars to kernels 00056 inline int handle(int val) { return val; } //for unification purposes when passing CPU-scalars to kernels 00057 inline long handle(long val) { return val; } //for unification purposes when passing CPU-scalars to kernels 00058 inline float handle(float val) { return val; } //for unification purposes when passing CPU-scalars to kernels 00059 inline double handle(double val) { return val; } //for unification purposes when passing CPU-scalars to kernels 00060 00061 template <typename LHS, typename RHS, typename OP> 00062 viennacl::backend::mem_handle & handle(viennacl::scalar_expression< const LHS, const RHS, OP> & obj) 00063 { 00064 return handle(obj.lhs()); 00065 } 00066 00067 template <typename LHS, typename RHS, typename OP> 00068 viennacl::backend::mem_handle const & handle(viennacl::matrix_expression<LHS, RHS, OP> const & obj); 00069 00070 template <typename LHS, typename RHS, typename OP> 00071 viennacl::backend::mem_handle const & handle(viennacl::vector_expression<LHS, RHS, OP> const & obj); 00072 00073 template <typename LHS, typename RHS, typename OP> 00074 viennacl::backend::mem_handle const & handle(viennacl::scalar_expression< const LHS, const RHS, OP> const & obj) 00075 { 00076 return handle(obj.lhs()); 00077 } 00078 00079 // proxy objects require extra care (at the moment) 00080 template <typename T> 00081 viennacl::backend::mem_handle & handle(viennacl::vector_base<T> & obj) 00082 { 00083 return obj.handle(); 00084 } 00085 00086 template <typename T> 00087 viennacl::backend::mem_handle const & handle(viennacl::vector_base<T> const & obj) 00088 { 00089 return obj.handle(); 00090 } 00091 00092 00093 00094 template <typename T> 00095 viennacl::backend::mem_handle & handle(viennacl::matrix_range<T> & obj) 00096 { 00097 return obj.get().handle(); 00098 } 00099 00100 template <typename T> 00101 viennacl::backend::mem_handle const & handle(viennacl::matrix_range<T> const & obj) 00102 { 00103 return obj.get().handle(); 00104 } 00105 00106 00107 template <typename T> 00108 viennacl::backend::mem_handle & handle(viennacl::matrix_slice<T> & obj) 00109 { 00110 return obj.get().handle(); 00111 } 00112 00113 template <typename T> 00114 viennacl::backend::mem_handle const & handle(viennacl::matrix_slice<T> const & obj) 00115 { 00116 return obj.get().handle(); 00117 } 00118 00119 template <typename LHS, typename RHS, typename OP> 00120 viennacl::backend::mem_handle const & handle(viennacl::vector_expression<LHS, RHS, OP> const & obj) 00121 { 00122 return handle(obj.lhs()); 00123 } 00124 00125 template <typename LHS, typename RHS, typename OP> 00126 viennacl::backend::mem_handle const & handle(viennacl::matrix_expression<LHS, RHS, OP> const & obj) 00127 { 00128 return handle(obj.lhs()); 00129 } 00130 00133 // 00134 // RAM handle extraction 00135 // 00137 template <typename T> 00138 typename viennacl::backend::mem_handle::ram_handle_type & ram_handle(T & obj) 00139 { 00140 return viennacl::traits::handle(obj).ram_handle(); 00141 } 00142 00144 template <typename T> 00145 typename viennacl::backend::mem_handle::ram_handle_type const & ram_handle(T const & obj) 00146 { 00147 return viennacl::traits::handle(obj).ram_handle(); 00148 } 00149 00151 inline viennacl::backend::mem_handle::ram_handle_type & ram_handle(viennacl::backend::mem_handle & h) 00152 { 00153 return h.ram_handle(); 00154 } 00155 00156 inline viennacl::backend::mem_handle::ram_handle_type const & ram_handle(viennacl::backend::mem_handle const & h) 00157 { 00158 return h.ram_handle(); 00159 } 00162 // 00163 // OpenCL handle extraction 00164 // 00165 #ifdef VIENNACL_WITH_OPENCL 00166 00167 template <typename T> 00168 viennacl::ocl::handle<cl_mem> & opencl_handle(T & obj) 00169 { 00170 return viennacl::traits::handle(obj).opencl_handle(); 00171 } 00172 00174 template <typename T> 00175 viennacl::ocl::handle<cl_mem> const & opencl_handle(T const & obj) 00176 { 00177 return viennacl::traits::handle(obj).opencl_handle(); 00178 } 00179 00180 inline cl_char opencl_handle(char val) { return val; } //for unification purposes when passing CPU-scalars to kernels 00181 inline cl_short opencl_handle(short val) { return val; } //for unification purposes when passing CPU-scalars to kernels 00182 inline cl_int opencl_handle(int val) { return val; } //for unification purposes when passing CPU-scalars to kernels 00183 inline cl_long opencl_handle(long val) { return val; } //for unification purposes when passing CPU-scalars to kernels 00184 inline cl_uchar opencl_handle(unsigned char val) { return val; } //for unification purposes when passing CPU-scalars to kernels 00185 inline cl_ushort opencl_handle(unsigned short val) { return val; } //for unification purposes when passing CPU-scalars to kernels 00186 inline cl_uint opencl_handle(unsigned int val) { return val; } //for unification purposes when passing CPU-scalars to kernels 00187 inline cl_ulong opencl_handle(unsigned long val) { return val; } //for unification purposes when passing CPU-scalars to kernels 00188 inline float opencl_handle(float val) { return val; } //for unification purposes when passing CPU-scalars to kernels 00189 inline double opencl_handle(double val) { return val; } //for unification purposes when passing CPU-scalars to kernels 00190 00191 00192 #endif 00193 00194 00195 00196 // 00197 // Active handle ID 00198 // 00200 template <typename T> 00201 viennacl::memory_types active_handle_id(T const & obj) 00202 { 00203 return handle(obj).get_active_handle_id(); 00204 } 00205 00207 template <typename T> 00208 viennacl::memory_types active_handle_id(circulant_matrix<T> const &) { return OPENCL_MEMORY; } 00209 00210 template <typename T> 00211 viennacl::memory_types active_handle_id(hankel_matrix<T> const &) { return OPENCL_MEMORY; } 00212 00213 template <typename T> 00214 viennacl::memory_types active_handle_id(toeplitz_matrix<T> const &) { return OPENCL_MEMORY; } 00215 00216 template <typename T> 00217 viennacl::memory_types active_handle_id(vandermonde_matrix<T> const &) { return OPENCL_MEMORY; } 00218 00219 template <typename LHS, typename RHS, typename OP> 00220 viennacl::memory_types active_handle_id(viennacl::vector_expression<LHS, RHS, OP> const &); 00221 00222 template <typename LHS, typename RHS, typename OP> 00223 viennacl::memory_types active_handle_id(viennacl::scalar_expression<LHS, RHS, OP> const & obj) 00224 { 00225 return active_handle_id(obj.lhs()); 00226 } 00227 00228 template <typename LHS, typename RHS, typename OP> 00229 viennacl::memory_types active_handle_id(viennacl::vector_expression<LHS, RHS, OP> const & obj) 00230 { 00231 return active_handle_id(obj.lhs()); 00232 } 00233 00234 template <typename LHS, typename RHS, typename OP> 00235 viennacl::memory_types active_handle_id(viennacl::matrix_expression<LHS, RHS, OP> const & obj) 00236 { 00237 return active_handle_id(obj.lhs()); 00238 } 00241 } //namespace traits 00242 } //namespace viennacl 00243 00244 00245 #endif