[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]
vigra/multi_opencl.hxx | ![]() |
00001 /************************************************************************/ 00002 /* */ 00003 /* Copyright 1998-2004 by Ullrich Koethe */ 00004 /* Copyright 2011-2011 by Michael Tesch */ 00005 /* */ 00006 /* This file is part of the VIGRA computer vision library. */ 00007 /* The VIGRA Website is */ 00008 /* http://hci.iwr.uni-heidelberg.de/vigra/ */ 00009 /* Please direct questions, bug reports, and contributions to */ 00010 /* ullrich.koethe@iwr.uni-heidelberg.de or */ 00011 /* vigra@informatik.uni-hamburg.de */ 00012 /* */ 00013 /* Permission is hereby granted, free of charge, to any person */ 00014 /* obtaining a copy of this software and associated documentation */ 00015 /* files (the "Software"), to deal in the Software without */ 00016 /* restriction, including without limitation the rights to use, */ 00017 /* copy, modify, merge, publish, distribute, sublicense, and/or */ 00018 /* sell copies of the Software, and to permit persons to whom the */ 00019 /* Software is furnished to do so, subject to the following */ 00020 /* conditions: */ 00021 /* */ 00022 /* The above copyright notice and this permission notice shall be */ 00023 /* included in all copies or substantial portions of the */ 00024 /* Software. */ 00025 /* */ 00026 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */ 00027 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */ 00028 /* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */ 00029 /* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */ 00030 /* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */ 00031 /* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */ 00032 /* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */ 00033 /* OTHER DEALINGS IN THE SOFTWARE. */ 00034 /* */ 00035 /************************************************************************/ 00036 00037 #ifndef VIGRA_OPENCL_HXX 00038 #define VIGRA_OPENCL_HXX 00039 00040 #include "numerictraits.hxx" 00041 00042 #ifdef __APPLE__ 00043 #include <OpenCL/opencl.h> 00044 #else 00045 #include <CL/opencl.h> 00046 #endif 00047 00048 namespace vigra { 00049 00050 /********************************************************/ 00051 /* */ 00052 /* NumericTraits */ 00053 /* */ 00054 /********************************************************/ 00055 00056 #ifndef NO_PARTIAL_TEMPLATE_SPECIALIZATION 00057 00058 #define VIGRA_OPENCL_VECTYPEN_INTEGER_TRAITS(basetype, n) \ 00059 template<> \ 00060 struct NumericTraits< basetype##n > \ 00061 { \ 00062 typedef basetype##n Type; \ 00063 typedef Type Promote; \ 00064 typedef Type UnsignedPromote; \ 00065 typedef Type RealPromote; \ 00066 typedef std::complex<Type> ComplexPromote; \ 00067 typedef basetype ValueType; \ 00068 \ 00069 typedef VigraFalseType isIntegral; \ 00070 typedef VigraFalseType isScalar; \ 00071 typedef typename NumericTraits<ValueType>::isSigned isSigned; \ 00072 typedef VigraFalseType isOrdered; \ 00073 typedef typename NumericTraits<ValueType>::isComplex isComplex; \ 00074 \ 00075 static Type zero() { Type x; bzero(&x, sizeof(x)); return x; } \ 00076 static Type one() { Type x = {{1}}; return x; } \ 00077 static Type nonZero() { return one(); } \ 00078 \ 00079 static Promote toPromote(Type const & v) { return v; } \ 00080 static Type fromPromote(Promote const & v) { return v; } \ 00081 static Type fromRealPromote(RealPromote v) { return v; } \ 00082 } 00083 00084 #define VIGRA_OPENCL_VECTYPEN_REAL_TRAITS(basetype, n) \ 00085 template<> \ 00086 struct NumericTraits< basetype##n > \ 00087 { \ 00088 typedef basetype##n Type; \ 00089 typedef Type Promote; \ 00090 typedef Type UnsignedPromote; \ 00091 typedef Type RealPromote; \ 00092 typedef std::complex<Type> ComplexPromote; \ 00093 typedef basetype ValueType; \ 00094 \ 00095 typedef VigraFalseType isIntegral; \ 00096 typedef VigraFalseType isScalar; \ 00097 typedef typename NumericTraits<ValueType>::isSigned isSigned; \ 00098 typedef VigraFalseType isOrdered; \ 00099 typedef typename NumericTraits<ValueType>::isComplex isComplex; \ 00100 \ 00101 static Type zero() { Type x; bzero(&x, sizeof(x)); return x; } \ 00102 static Type one() { Type x = {{1}}; return x; } \ 00103 static Type nonZero() { return one(); } \ 00104 static Type epsilon() { Type x; x.x = NumericTraits<ValueType>::epsilon(); return x; } \ 00105 static Type smallestPositive() { Type x; x.x = NumericTraits<ValueType>::smallestPositive(); return x; } \ 00106 \ 00107 static Promote toPromote(Type const & v) { return v; } \ 00108 static Type fromPromote(Promote const & v) { return v; } \ 00109 static Type fromRealPromote(RealPromote v) { return v; } \ 00110 } 00111 00112 /// \todo - fix one() - maybe with .hi and .lo accessors? 00113 00114 #define VIGRA_OPENCL_VECN_TRAITS(n) \ 00115 VIGRA_OPENCL_VECTYPEN_INTEGER_TRAITS(cl_char, n); \ 00116 VIGRA_OPENCL_VECTYPEN_INTEGER_TRAITS(cl_uchar, n); \ 00117 VIGRA_OPENCL_VECTYPEN_INTEGER_TRAITS(cl_short, n); \ 00118 VIGRA_OPENCL_VECTYPEN_INTEGER_TRAITS(cl_ushort, n); \ 00119 VIGRA_OPENCL_VECTYPEN_INTEGER_TRAITS(cl_int, n); \ 00120 VIGRA_OPENCL_VECTYPEN_INTEGER_TRAITS(cl_uint, n); \ 00121 VIGRA_OPENCL_VECTYPEN_INTEGER_TRAITS(cl_long, n); \ 00122 VIGRA_OPENCL_VECTYPEN_INTEGER_TRAITS(cl_ulong, n); \ 00123 VIGRA_OPENCL_VECTYPEN_REAL_TRAITS(cl_float, n); \ 00124 VIGRA_OPENCL_VECTYPEN_REAL_TRAITS(cl_double, n); 00125 00126 VIGRA_OPENCL_VECN_TRAITS(2); 00127 VIGRA_OPENCL_VECN_TRAITS(3); 00128 //VIGRA_OPENCL_VECN_TRAITS(4); // cl_type4 is the same as cl_type3 00129 VIGRA_OPENCL_VECN_TRAITS(8); 00130 VIGRA_OPENCL_VECN_TRAITS(16); 00131 00132 #undef VIGRA_OPENCL_VECTYPEN_INTEGER_TRAITS 00133 #undef VIGRA_OPENCL_VECTYPEN_REAL_TRAITS 00134 #undef VIGRA_OPENCL_VECN_TRAITS 00135 00136 /** \todo looks like the windows CL/cl_platform.h does signed/unsigned 00137 * strangely, so that the signed properties may not have the right 00138 * NumericalTraits::isSigned -- not sure if there's a reason for that. 00139 */ 00140 00141 00142 #endif // NO_PARTIAL_TEMPLATE_SPECIALIZATION 00143 00144 /********************************************************/ 00145 /* */ 00146 /* SquareRootTraits */ 00147 /* */ 00148 /********************************************************/ 00149 00150 /********************************************************/ 00151 /* */ 00152 /* NormTraits */ 00153 /* */ 00154 /********************************************************/ 00155 00156 #if 0 00157 template<> 00158 struct NormTraits<fftw_complex> 00159 { 00160 typedef fftw_complex Type; 00161 typedef fftw_real SquaredNormType; 00162 typedef fftw_real NormType; 00163 }; 00164 00165 template<class Real> 00166 struct NormTraits<FFTWComplex<Real> > 00167 { 00168 typedef FFTWComplex<Real> Type; 00169 typedef typename Type::SquaredNormType SquaredNormType; 00170 typedef typename Type::NormType NormType; 00171 }; 00172 #endif 00173 00174 /********************************************************/ 00175 /* */ 00176 /* PromoteTraits */ 00177 /* */ 00178 /********************************************************/ 00179 00180 #if 0 00181 template<class T> 00182 struct CanSkipInitialization<std::complex<T> > 00183 { 00184 typedef typename CanSkipInitialization<T>::type type; 00185 static const bool value = type::asBool; 00186 }; 00187 #endif 00188 00189 /********************************************************/ 00190 /* */ 00191 /* multi_math */ 00192 /* */ 00193 /********************************************************/ 00194 00195 namespace multi_math { 00196 00197 /// \todo ! 00198 00199 /** OpenCL 1.1 [6.2] - Convert operators */ 00200 /** OpenCL 1.1 [6.3] - Scalar/vector math operators */ 00201 00202 /** OpenCL 1.1 [6.11.2] - Math Built-in Functions */ 00203 /** OpenCL 1.1 [6.11.3] - Integer Built-in Functions */ 00204 /** OpenCL 1.1 [6.11.4] - Common Built-in Functions */ 00205 /** OpenCL 1.1 [6.11.5] - Geometric Built-in Functions */ 00206 /** OpenCL 1.1 [6.11.6] - Relational Built-in Functions */ 00207 /** OpenCL 1.1 [6.11.7] - Vector Data Load/Store Built-in Functions */ 00208 00209 /** OpenCL 1.1 [6.11.12] - Misc Vector Built-in Functions */ 00210 00211 /** OpenCL 1.1 [6.11.12] - Image Read and Write Built-in Functions */ 00212 00213 00214 } // namespace multi_math 00215 00216 /********************************************************/ 00217 /* */ 00218 /* Channel Accessors */ 00219 /* */ 00220 /********************************************************/ 00221 00222 /** \addtogroup DataAccessors 00223 */ 00224 //@{ 00225 /** \defgroup OpenCL-Accessors Accessors for OpenCL types 00226 00227 Encapsulate access to members of OpenCL vector types. 00228 00229 00230 <b>\#include</b> <vigra/multi_opencl.hxx> 00231 00232 OpenCL 1.1 [6.1.7] - Vector Components 00233 00234 - cl_TYPE2Accessor_x 00235 - cl_TYPE2Accessor_y 00236 - cl_TYPE2Accessor_s0 00237 - cl_TYPE2Accessor_s1 00238 00239 - cl_TYPE2WriteAccessor_x 00240 - cl_TYPE2WriteAccessor_y 00241 - cl_TYPE2WriteAccessor_s0 00242 - cl_TYPE2WriteAccessor_s1 00243 00244 - cl_TYPE3Accessor_x 00245 - cl_TYPE3Accessor_y 00246 - cl_TYPE3Accessor_z 00247 - cl_TYPE3Accessor_s0 00248 - cl_TYPE3Accessor_s1 00249 - cl_TYPE3Accessor_s2 00250 00251 - cl_TYPE3WriteAccessor_x 00252 - cl_TYPE3WriteAccessor_y 00253 - cl_TYPE3WriteAccessor_z 00254 - cl_TYPE3WriteAccessor_s0 00255 - cl_TYPE3WriteAccessor_s1 00256 - ... 00257 00258 where TYPE is one of {char, uchar, short, ushort, int, uint, long, ulong, float, double } 00259 00260 For example: 00261 00262 \code 00263 00264 #include <vigra/multi_opencl.hxx> 00265 00266 MultiArrayView<2, cl_double3 > dataView = ...; 00267 00268 vigra::FindMinMax<double> minmax; 00269 vigra::inspectMultiArray(srcMultiArrayRange(dataView, cl_double3Accessor_z()), minmax); 00270 std::cout << "range of .z: " << minmax.min << " - " << minmax.max; 00271 00272 \endcode 00273 */ 00274 //@{ 00275 /** 00276 \class cl_charNAccessor_COMP 00277 00278 access the first component. 00279 00280 \class cl_TYPE3WriteAccessor_s1 00281 00282 access the second component. 00283 00284 \class cl_TYPE3WriteAccessor_s2 00285 00286 access the third component. 00287 */ 00288 00289 //@} 00290 //@} 00291 00292 #define VIGRA_OPENCL_TYPE_ACCESSOR(basetype, n, NTH) \ 00293 class basetype##n##Accessor_##NTH \ 00294 { \ 00295 public: \ 00296 /** The accessor's value type. */ \ 00297 typedef NumericTraits< basetype##n >::ValueType value_type; \ 00298 \ 00299 /** Read component at iterator position. */ \ 00300 template <class ITERATOR> \ 00301 value_type operator()(ITERATOR const & i) const { \ 00302 return (*i).NTH; \ 00303 } \ 00304 \ 00305 /** Read component at offset from iterator position. */ \ 00306 template <class ITERATOR, class DIFFERENCE> \ 00307 value_type operator()(ITERATOR const & i, DIFFERENCE d) const { \ 00308 return i[d].NTH; \ 00309 } \ 00310 \ 00311 /** Write component at iterator position from a scalar. */ \ 00312 template <class ITERATOR> \ 00313 void set(value_type const & v, ITERATOR const & i) const { \ 00314 (*i).NTH = v; \ 00315 } \ 00316 \ 00317 /** Write component at offset from iterator position from a scalar. */ \ 00318 template <class ITERATOR, class DIFFERENCE> \ 00319 void set(value_type const & v, ITERATOR const & i, DIFFERENCE d) const { \ 00320 i[d].NTH = v; \ 00321 } \ 00322 \ 00323 /** Write component at iterator position into a scalar. */ \ 00324 template <class R, class ITERATOR> \ 00325 void set(FFTWComplex<R> const & v, ITERATOR const & i) const { \ 00326 *i = v.NTH; \ 00327 } \ 00328 \ 00329 /** Write component at offset from iterator position into a scalar. */ \ 00330 template <class R, class ITERATOR, class DIFFERENCE> \ 00331 void set(FFTWComplex<R> const & v, ITERATOR const & i, DIFFERENCE d) const { \ 00332 i[d] = v.NTH; \ 00333 } \ 00334 }; \ 00335 class basetype##n##WriteAccessor_##NTH \ 00336 : public basetype##n##Accessor_##NTH \ 00337 { \ 00338 public: \ 00339 /** The accessor's value type. */ \ 00340 typedef NumericTraits< basetype##n >::ValueType value_type; \ 00341 \ 00342 /** Write component at iterator position. */ \ 00343 template <class ITERATOR> \ 00344 void set(value_type const & v, ITERATOR const & i) const { \ 00345 (*i).NTH = v; \ 00346 } \ 00347 \ 00348 /** Write component at offset from iterator position. */ \ 00349 template <class ITERATOR, class DIFFERENCE> \ 00350 void set(value_type const & v, ITERATOR const & i, DIFFERENCE d) const { \ 00351 i[d].NTH = v; \ 00352 } \ 00353 } 00354 00355 #define VIGRA_OPENCL_TYPE2_ACCESSORS(basetype) \ 00356 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 2, s0); \ 00357 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 2, s1); \ 00358 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 2, x); \ 00359 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 2, y); 00360 00361 #define VIGRA_OPENCL_TYPE3_ACCESSORS(basetype) \ 00362 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 3, s0); \ 00363 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 3, s1); \ 00364 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 3, s2); \ 00365 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 3, x); \ 00366 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 3, y); \ 00367 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 3, z); 00368 00369 #define VIGRA_OPENCL_TYPE4_ACCESSORS(basetype) \ 00370 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 4, s0); \ 00371 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 4, s1); \ 00372 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 4, s2); \ 00373 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 4, s3); \ 00374 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 4, x); \ 00375 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 4, y); \ 00376 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 4, z); \ 00377 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 4, w); 00378 00379 #define VIGRA_OPENCL_TYPE8_ACCESSORS(basetype) \ 00380 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 8, s0); \ 00381 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 8, s1); \ 00382 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 8, s2); \ 00383 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 8, s3); \ 00384 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 8, s4); \ 00385 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 8, s5); \ 00386 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 8, s6); \ 00387 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 8, s7); \ 00388 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 8, s8); 00389 00390 #define VIGRA_OPENCL_TYPE16_ACCESSORS(basetype) \ 00391 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 16, s0); \ 00392 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 16, s1); \ 00393 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 16, s2); \ 00394 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 16, s3); \ 00395 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 16, s4); \ 00396 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 16, s5); \ 00397 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 16, s6); \ 00398 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 16, s7); \ 00399 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 16, s8); \ 00400 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 16, sa); \ 00401 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 16, sb); \ 00402 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 16, sc); \ 00403 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 16, sd); \ 00404 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 16, se); \ 00405 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 16, sf); \ 00406 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 16, sA); \ 00407 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 16, sB); \ 00408 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 16, sC); \ 00409 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 16, sD); \ 00410 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 16, sE); \ 00411 VIGRA_OPENCL_TYPE_ACCESSOR(basetype, 16, sF); 00412 00413 /// \todo figure out half (.hi .lo, .even .odd) and other odd-sized accessors 00414 00415 #define VIGRA_OPENCL_ACCESSORS(basetype) \ 00416 VIGRA_OPENCL_TYPE2_ACCESSORS(basetype); \ 00417 VIGRA_OPENCL_TYPE3_ACCESSORS(basetype); \ 00418 VIGRA_OPENCL_TYPE4_ACCESSORS(basetype); \ 00419 VIGRA_OPENCL_TYPE8_ACCESSORS(basetype); \ 00420 VIGRA_OPENCL_TYPE16_ACCESSORS(basetype); 00421 00422 VIGRA_OPENCL_ACCESSORS(cl_char); 00423 VIGRA_OPENCL_ACCESSORS(cl_uchar); 00424 VIGRA_OPENCL_ACCESSORS(cl_short); 00425 VIGRA_OPENCL_ACCESSORS(cl_ushort); 00426 VIGRA_OPENCL_ACCESSORS(cl_int); 00427 VIGRA_OPENCL_ACCESSORS(cl_uint); 00428 VIGRA_OPENCL_ACCESSORS(cl_long); 00429 VIGRA_OPENCL_ACCESSORS(cl_ulong); 00430 VIGRA_OPENCL_ACCESSORS(cl_float); 00431 VIGRA_OPENCL_ACCESSORS(cl_double); 00432 00433 #undef VIGRA_OPENCL_TYPE_ACCESSOR 00434 #undef VIGRA_OPENCL_TYPE2_ACCESSORS 00435 #undef VIGRA_OPENCL_TYPE3_ACCESSORS 00436 #undef VIGRA_OPENCL_TYPE4_ACCESSORS 00437 #undef VIGRA_OPENCL_TYPE8_ACCESSORS 00438 #undef VIGRA_OPENCL_TYPE16_ACCESSORS 00439 #undef VIGRA_OPENCL_ACCESSORS 00440 00441 } // namespace vigra 00442 00443 #endif // VIGRA_OPENCL_HXX
© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de) |
html generated using doxygen and Python
|