/usr/include/viennacl/traits/handle.hpp is in libviennacl-dev 1.7.1+dfsg1-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 | #ifndef VIENNACL_TRAITS_HANDLE_HPP_
#define VIENNACL_TRAITS_HANDLE_HPP_
/* =========================================================================
Copyright (c) 2010-2016, Institute for Microelectronics,
Institute for Analysis and Scientific Computing,
TU Wien.
Portions of this software are copyright by UChicago Argonne, LLC.
-----------------
ViennaCL - The Vienna Computing Library
-----------------
Project Head: Karl Rupp rupp@iue.tuwien.ac.at
(A list of authors and contributors can be found in the manual)
License: MIT (X11), see file LICENSE in the base directory
============================================================================= */
/** @file viennacl/traits/handle.hpp
@brief Extracts the underlying OpenCL handle from a vector, a matrix, an expression etc.
*/
#include <string>
#include <fstream>
#include <sstream>
#include "viennacl/forwards.h"
#include "viennacl/backend/mem_handle.hpp"
namespace viennacl
{
namespace traits
{
//
// Generic memory handle
//
/** @brief Returns the generic memory handle of an object. Non-const version. */
template<typename T>
viennacl::backend::mem_handle & handle(T & obj)
{
return obj.handle();
}
/** @brief Returns the generic memory handle of an object. Const-version. */
template<typename T>
viennacl::backend::mem_handle const & handle(T const & obj)
{
return obj.handle();
}
/** \cond */
inline char handle(char val) { return val; } //for unification purposes when passing CPU-scalars to kernels
inline short handle(short val) { return val; } //for unification purposes when passing CPU-scalars to kernels
inline int handle(int val) { return val; } //for unification purposes when passing CPU-scalars to kernels
inline long handle(long val) { return val; } //for unification purposes when passing CPU-scalars to kernels
inline float handle(float val) { return val; } //for unification purposes when passing CPU-scalars to kernels
inline double handle(double val) { return val; } //for unification purposes when passing CPU-scalars to kernels
template<typename LHS, typename RHS, typename OP>
viennacl::backend::mem_handle & handle(viennacl::scalar_expression< const LHS, const RHS, OP> & obj)
{
return handle(obj.lhs());
}
template<typename LHS, typename RHS, typename OP>
viennacl::backend::mem_handle const & handle(viennacl::matrix_expression<LHS, RHS, OP> const & obj);
template<typename LHS, typename RHS, typename OP>
viennacl::backend::mem_handle const & handle(viennacl::vector_expression<LHS, RHS, OP> const & obj);
template<typename LHS, typename RHS, typename OP>
viennacl::backend::mem_handle const & handle(viennacl::scalar_expression< const LHS, const RHS, OP> const & obj)
{
return handle(obj.lhs());
}
// proxy objects require extra care (at the moment)
template<typename T>
viennacl::backend::mem_handle & handle(viennacl::vector_base<T> & obj)
{
return obj.handle();
}
template<typename T>
viennacl::backend::mem_handle const & handle(viennacl::vector_base<T> const & obj)
{
return obj.handle();
}
template<typename T>
viennacl::backend::mem_handle & handle(viennacl::matrix_range<T> & obj)
{
return obj.get().handle();
}
template<typename T>
viennacl::backend::mem_handle const & handle(viennacl::matrix_range<T> const & obj)
{
return obj.get().handle();
}
template<typename T>
viennacl::backend::mem_handle & handle(viennacl::matrix_slice<T> & obj)
{
return obj.get().handle();
}
template<typename T>
viennacl::backend::mem_handle const & handle(viennacl::matrix_slice<T> const & obj)
{
return obj.get().handle();
}
template<typename LHS, typename RHS, typename OP>
viennacl::backend::mem_handle const & handle(viennacl::vector_expression<LHS, RHS, OP> const & obj)
{
return handle(obj.lhs());
}
template<typename LHS, typename RHS, typename OP>
viennacl::backend::mem_handle const & handle(viennacl::matrix_expression<LHS, RHS, OP> const & obj)
{
return handle(obj.lhs());
}
/** \endcond */
//
// RAM handle extraction
//
/** @brief Generic helper routine for extracting the RAM handle of a ViennaCL object. Non-const version. */
template<typename T>
typename viennacl::backend::mem_handle::ram_handle_type & ram_handle(T & obj)
{
return viennacl::traits::handle(obj).ram_handle();
}
/** @brief Generic helper routine for extracting the RAM handle of a ViennaCL object. Const version. */
template<typename T>
typename viennacl::backend::mem_handle::ram_handle_type const & ram_handle(T const & obj)
{
return viennacl::traits::handle(obj).ram_handle();
}
/** \cond */
inline viennacl::backend::mem_handle::ram_handle_type & ram_handle(viennacl::backend::mem_handle & h)
{
return h.ram_handle();
}
inline viennacl::backend::mem_handle::ram_handle_type const & ram_handle(viennacl::backend::mem_handle const & h)
{
return h.ram_handle();
}
/** \endcond */
//
// OpenCL handle extraction
//
#ifdef VIENNACL_WITH_OPENCL
/** @brief Generic helper routine for extracting the OpenCL handle of a ViennaCL object. Non-const version. */
template<typename T>
viennacl::ocl::handle<cl_mem> & opencl_handle(T & obj)
{
return viennacl::traits::handle(obj).opencl_handle();
}
/** @brief Generic helper routine for extracting the OpenCL handle of a ViennaCL object. Const version. */
template<typename T>
viennacl::ocl::handle<cl_mem> const & opencl_handle(T const & obj)
{
return viennacl::traits::handle(obj).opencl_handle();
}
inline cl_char opencl_handle(char val) { return val; } //for unification purposes when passing CPU-scalars to kernels
inline cl_short opencl_handle(short val) { return val; } //for unification purposes when passing CPU-scalars to kernels
inline cl_int opencl_handle(int val) { return val; } //for unification purposes when passing CPU-scalars to kernels
inline cl_long opencl_handle(long val) { return val; } //for unification purposes when passing CPU-scalars to kernels
inline cl_uchar opencl_handle(unsigned char val) { return val; } //for unification purposes when passing CPU-scalars to kernels
inline cl_ushort opencl_handle(unsigned short val) { return val; } //for unification purposes when passing CPU-scalars to kernels
inline cl_uint opencl_handle(unsigned int val) { return val; } //for unification purposes when passing CPU-scalars to kernels
inline cl_ulong opencl_handle(unsigned long val) { return val; } //for unification purposes when passing CPU-scalars to kernels
inline float opencl_handle(float val) { return val; } //for unification purposes when passing CPU-scalars to kernels
inline double opencl_handle(double val) { return val; } //for unification purposes when passing CPU-scalars to kernels
// for user-provided matrix-vector routines:
template<typename LHS, typename NumericT>
viennacl::ocl::handle<cl_mem> const & opencl_handle(viennacl::vector_expression<LHS, const vector_base<NumericT>, op_prod> const & obj)
{
return viennacl::traits::handle(obj.rhs()).opencl_handle();
}
template<typename T>
viennacl::ocl::context & opencl_context(T const & obj)
{
return const_cast<viennacl::ocl::context &>(opencl_handle(obj).context());
}
#endif
//
// OpenCL context extraction
//
//
// Active handle ID
//
/** @brief Returns an ID for the currently active memory domain of an object */
template<typename T>
viennacl::memory_types active_handle_id(T const & obj)
{
return handle(obj).get_active_handle_id();
}
/** \cond */
template<typename T>
viennacl::memory_types active_handle_id(circulant_matrix<T> const &) { return OPENCL_MEMORY; }
template<typename T>
viennacl::memory_types active_handle_id(hankel_matrix<T> const &) { return OPENCL_MEMORY; }
template<typename T>
viennacl::memory_types active_handle_id(toeplitz_matrix<T> const &) { return OPENCL_MEMORY; }
template<typename T>
viennacl::memory_types active_handle_id(vandermonde_matrix<T> const &) { return OPENCL_MEMORY; }
template<typename LHS, typename RHS, typename OP>
viennacl::memory_types active_handle_id(viennacl::vector_expression<LHS, RHS, OP> const &);
template<typename LHS, typename RHS, typename OP>
viennacl::memory_types active_handle_id(viennacl::scalar_expression<LHS, RHS, OP> const & obj)
{
return active_handle_id(obj.lhs());
}
template<typename LHS, typename RHS, typename OP>
viennacl::memory_types active_handle_id(viennacl::vector_expression<LHS, RHS, OP> const & obj)
{
return active_handle_id(obj.lhs());
}
template<typename LHS, typename RHS, typename OP>
viennacl::memory_types active_handle_id(viennacl::matrix_expression<LHS, RHS, OP> const & obj)
{
return active_handle_id(obj.lhs());
}
// for user-provided matrix-vector routines:
template<typename LHS, typename NumericT>
viennacl::memory_types active_handle_id(viennacl::vector_expression<LHS, const vector_base<NumericT>, op_prod> const & obj)
{
return active_handle_id(obj.rhs());
}
/** \endcond */
} //namespace traits
} //namespace viennacl
#endif
|