ViennaCL - The Vienna Computing Library  1.5.2
viennacl/traits/handle.hpp
Go to the documentation of this file.
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