utiltools/X86MAC64/cuda/include/surface_functions.h

   1 /*
   2  * Copyright 1993-2012 NVIDIA Corporation.  All rights reserved.
   3  *
   4  * NOTICE TO LICENSEE:
   5  *
   6  * This source code and/or documentation ("Licensed Deliverables") are
   7  * subject to NVIDIA intellectual property rights under U.S. and
   8  * international Copyright laws.
   9  *
  10  * These Licensed Deliverables contained herein is PROPRIETARY and
  11  * CONFIDENTIAL to NVIDIA and is being provided under the terms and
  12  * conditions of a form of NVIDIA software license agreement by and
  13  * between NVIDIA and Licensee ("License Agreement") or electronically
  14  * accepted by Licensee.  Notwithstanding any terms or conditions to
  15  * the contrary in the License Agreement, reproduction or disclosure
  16  * of the Licensed Deliverables to any third party without the express
  17  * written consent of NVIDIA is prohibited.
  18  *
  19  * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
  20  * LICENSE AGREEMENT, NVIDIA MAKES NO REPRESENTATION ABOUT THE
  21  * SUITABILITY OF THESE LICENSED DELIVERABLES FOR ANY PURPOSE.  IT IS
  22  * PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY OF ANY KIND.
  23  * NVIDIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THESE LICENSED
  24  * DELIVERABLES, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY,
  25  * NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
  26  * NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
  27  * LICENSE AGREEMENT, IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY
  28  * SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, OR ANY
  29  * DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  30  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  31  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  32  * OF THESE LICENSED DELIVERABLES.
  33  *
  34  * U.S. Government End Users.  These Licensed Deliverables are a
  35  * "commercial item" as that term is defined at 48 C.F.R. 2.101 (OCT
  36  * 1995), consisting of "commercial computer software" and "commercial
  37  * computer software documentation" as such terms are used in 48
  38  * C.F.R. 12.212 (SEPT 1995) and is provided to the U.S. Government
  39  * only as a commercial end item.  Consistent with 48 C.F.R.12.212 and
  40  * 48 C.F.R. 227.7202-1 through 227.7202-4 (JUNE 1995), all
  41  * U.S. Government End Users acquire the Licensed Deliverables with
  42  * only those rights set forth herein.
  43  *
  44  * Any use of the Licensed Deliverables in individual and commercial
  45  * software must include, in the user documentation and internal
  46  * comments to the code, the above Disclaimer and U.S. Government End
  47  * Users Notice.
  48  */
  49
  50 #if !defined(__SURFACE_FUNCTIONS_H__)
  51 #define __SURFACE_FUNCTIONS_H__
  52
  53 #if defined(__cplusplus) && defined(__CUDACC__)
  54
  55 /*******************************************************************************
  56 *                                                                              *
  57 *                                                                              *
  58 *                                                                              *
  59 *******************************************************************************/
  60
  61 #include "builtin_types.h"
  62 #include "cuda_surface_types.h"
  63 #include "host_defines.h"
  64 #include "surface_types.h"
  65 #include "vector_functions.h"
  66 #include "vector_types.h"
  67
  68 /*******************************************************************************
  69 *                                                                              *
  70 *                                                                              *
  71 *                                                                              *
  72 *******************************************************************************/
  73 extern __device__ __device_builtin__ uchar1     __surf1Dreadc1(surface<void, cudaSurfaceType1D> t, int x, enum cudaSurfaceBoundaryMode mode);
  74 extern __device__ __device_builtin__ uchar2     __surf1Dreadc2(surface<void, cudaSurfaceType1D> t, int x, enum cudaSurfaceBoundaryMode mode);
  75 extern __device__ __device_builtin__ uchar4     __surf1Dreadc4(surface<void, cudaSurfaceType1D> t, int x, enum cudaSurfaceBoundaryMode mode);
  76 extern __device__ __device_builtin__ ushort1    __surf1Dreads1(surface<void, cudaSurfaceType1D> t, int x, enum cudaSurfaceBoundaryMode mode);
  77 extern __device__ __device_builtin__ ushort2    __surf1Dreads2(surface<void, cudaSurfaceType1D> t, int x, enum cudaSurfaceBoundaryMode mode);
  78 extern __device__ __device_builtin__ ushort4    __surf1Dreads4(surface<void, cudaSurfaceType1D> t, int x, enum cudaSurfaceBoundaryMode mode);
  79 extern __device__ __device_builtin__ uint1      __surf1Dreadu1(surface<void, cudaSurfaceType1D> t, int x, enum cudaSurfaceBoundaryMode mode);
  80 extern __device__ __device_builtin__ uint2      __surf1Dreadu2(surface<void, cudaSurfaceType1D> t, int x, enum cudaSurfaceBoundaryMode mode);
  81 extern __device__ __device_builtin__ uint4      __surf1Dreadu4(surface<void, cudaSurfaceType1D> t, int x, enum cudaSurfaceBoundaryMode mode);
  82 extern __device__ __device_builtin__ ulonglong1 __surf1Dreadl1(surface<void, cudaSurfaceType1D> t, int x, enum cudaSurfaceBoundaryMode mode);
  83 extern __device__ __device_builtin__ ulonglong2 __surf1Dreadl2(surface<void, cudaSurfaceType1D> t, int x, enum cudaSurfaceBoundaryMode mode);
  84
  85 #if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 200
  86
  87 #define __surfModeSwitch(surf, x, mode, type)                                                   \
  88         ((mode == cudaBoundaryModeZero)  ? __surf1Dread##type(surf, x, cudaBoundaryModeZero ) : \
  89          (mode == cudaBoundaryModeClamp) ? __surf1Dread##type(surf, x, cudaBoundaryModeClamp) : \
  90                                            __surf1Dread##type(surf, x, cudaBoundaryModeTrap ))
  91
  92 #else /* CUDA_ARCH && __CUDA_ARCH__ >= 200 */
  93
  94 #define __surfModeSwitch(surf, x, mode, type) \
  95          __surf1Dread##type(surf, x, cudaBoundaryModeTrap)
  96
  97 #endif /* CUDA_ARCH && __CUDA_ARCH__ >= 200 */
  98
  99 template<class T>
 100 static __forceinline__ __device__ void surf1Dread(T *res, surface<void, cudaSurfaceType1D> surf, int x, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
 101 {
 102   (s ==  1) ? (void)(*(uchar1 *)res = __surfModeSwitch(surf, x, mode, c1)) :
 103   (s ==  2) ? (void)(*(ushort1*)res = __surfModeSwitch(surf, x, mode, s1)) :
 104   (s ==  4) ? (void)(*(uint1  *)res = __surfModeSwitch(surf, x, mode, u1)) :
 105   (s ==  8) ? (void)(*(uint2  *)res = __surfModeSwitch(surf, x, mode, u2)) :
 106   (s == 16) ? (void)(*(uint4  *)res = __surfModeSwitch(surf, x, mode, u4)) :
 107               (void)0;
 108 }
 109
 110 template<class T>
 111 static __forceinline__ __device__ T surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
 112 {
 113   T tmp;
 114
 115   surf1Dread(&tmp, surf, x, (int)sizeof(T), mode);
 116
 117   return tmp;
 118 }
 119
 120 template<class T>
 121 static __forceinline__ __device__ void surf1Dread(T *res, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
 122 {
 123   *res = surf1Dread<T>(surf, x, mode);
 124 }
 125
 126 template<>
 127 __forceinline__ __device__ char surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 128 {
 129   return (char)__surfModeSwitch(surf, x, mode, c1).x;
 130 }
 131
 132 template<>
 133 __forceinline__ __device__ signed char surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 134 {
 135   return (signed char)__surfModeSwitch(surf, x, mode, c1).x;
 136 }
 137
 138 template<>
 139 __forceinline__ __device__ unsigned char surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 140 {
 141   return __surfModeSwitch(surf, x, mode, c1).x;
 142 }
 143
 144 template<>
 145 __forceinline__ __device__ char1 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 146 {
 147   return make_char1((signed char)__surfModeSwitch(surf, x, mode, c1).x);
 148 }
 149
 150 template<>
 151 __forceinline__ __device__ uchar1 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 152 {
 153   return __surfModeSwitch(surf, x, mode, c1);
 154 }
 155
 156 template<>
 157 __forceinline__ __device__ char2 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 158 {
 159   uchar2 tmp = __surfModeSwitch(surf, x, mode, c2);
 160
 161   return make_char2((signed char)tmp.x, (signed char)tmp.y);
 162 }
 163
 164 template<>
 165 __forceinline__ __device__ uchar2 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 166 {
 167   return __surfModeSwitch(surf, x, mode, c2);
 168 }
 169
 170 template<>
 171 __forceinline__ __device__ char4 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 172 {
 173   uchar4 tmp = __surfModeSwitch(surf, x, mode, c4);
 174
 175   return make_char4((signed char)tmp.x, (signed char)tmp.y, (signed char)tmp.z, (signed char)tmp.w);
 176 }
 177
 178 template<>
 179 __forceinline__ __device__ uchar4 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 180 {
 181   return __surfModeSwitch(surf, x, mode, c4);
 182 }
 183
 184 template<>
 185 __forceinline__ __device__ short surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 186 {
 187   return (short)__surfModeSwitch(surf, x, mode, s1).x;
 188 }
 189
 190 template<>
 191 __forceinline__ __device__ unsigned short surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 192 {
 193   return __surfModeSwitch(surf, x, mode, s1).x;
 194 }
 195
 196 template<>
 197 __forceinline__ __device__ short1 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 198 {
 199   return make_short1((signed short)__surfModeSwitch(surf, x, mode, s1).x);
 200 }
 201
 202 template<>
 203 __forceinline__ __device__ ushort1 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 204 {
 205   return __surfModeSwitch(surf, x, mode, s1);
 206 }
 207
 208 template<>
 209 __forceinline__ __device__ short2 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 210 {
 211   ushort2 tmp = __surfModeSwitch(surf, x, mode, s2);
 212
 213   return make_short2((signed short)tmp.x, (signed short)tmp.y);
 214 }
 215
 216 template<>
 217 __forceinline__ __device__ ushort2 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 218 {
 219   return __surfModeSwitch(surf, x, mode, s2);
 220 }
 221
 222 template<>
 223 __forceinline__ __device__ short4 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 224 {
 225   ushort4 tmp = __surfModeSwitch(surf, x, mode, s4);
 226
 227   return make_short4((signed short)tmp.x, (signed short)tmp.y, (signed short)tmp.z, (signed short)tmp.w);
 228 }
 229
 230 template<>
 231 __forceinline__ __device__ ushort4 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 232 {
 233   return __surfModeSwitch(surf, x, mode, s4);
 234 }
 235
 236 template<>
 237 __forceinline__ __device__ int surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 238 {
 239   return (int)__surfModeSwitch(surf, x, mode, u1).x;
 240 }
 241
 242 template<>
 243 __forceinline__ __device__ unsigned int surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 244 {
 245   return __surfModeSwitch(surf, x, mode, u1).x;
 246 }
 247
 248 template<>
 249 __forceinline__ __device__ int1 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 250 {
 251   return make_int1((signed int)__surfModeSwitch(surf, x, mode, u1).x);
 252 }
 253
 254 template<>
 255 __forceinline__ __device__ uint1 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 256 {
 257   return __surfModeSwitch(surf, x, mode, u1);
 258 }
 259
 260 template<>
 261 __forceinline__ __device__ int2 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 262 {
 263   uint2 tmp = __surfModeSwitch(surf, x, mode, u2);
 264
 265   return make_int2((int)tmp.x, (int)tmp.y);
 266 }
 267
 268 template<>
 269 __forceinline__ __device__ uint2 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 270 {
 271   return __surfModeSwitch(surf, x, mode, u2);
 272 }
 273
 274 template<>
 275 __forceinline__ __device__ int4 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 276 {
 277   uint4 tmp = __surfModeSwitch(surf, x, mode, u4);
 278
 279   return make_int4((int)tmp.x, (int)tmp.y, (int)tmp.z, (int)tmp.w);
 280 }
 281
 282 template<>
 283 __forceinline__ __device__ uint4 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 284 {
 285   return __surfModeSwitch(surf, x, mode, u4);
 286 }
 287
 288 template<>
 289 __forceinline__ __device__ long long int surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 290 {
 291   return (long long int)__surfModeSwitch(surf, x, mode, l1).x;
 292 }
 293
 294 template<>
 295 __forceinline__ __device__ unsigned long long int surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 296 {
 297   return __surfModeSwitch(surf, x, mode, l1).x;
 298 }
 299
 300 template<>
 301 __forceinline__ __device__ longlong1 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 302 {
 303   return make_longlong1((long long int)__surfModeSwitch(surf, x, mode, l1).x);
 304 }
 305
 306 template<>
 307 __forceinline__ __device__ ulonglong1 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 308 {
 309   return __surfModeSwitch(surf, x, mode, l1);
 310 }
 311
 312 template<>
 313 __forceinline__ __device__ longlong2 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 314 {
 315   ulonglong2 tmp = __surfModeSwitch(surf, x, mode, l2);
 316
 317   return make_longlong2((long long int)tmp.x, (long long int)tmp.y);
 318 }
 319
 320 template<>
 321 __forceinline__ __device__ ulonglong2 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 322 {
 323   return __surfModeSwitch(surf, x, mode, l2);
 324 }
 325
 326 #if !defined(__LP64__)
 327
 328 template<>
 329 __forceinline__ __device__ long int surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 330 {
 331   return (long int)__surfModeSwitch(surf, x, mode, u1).x;
 332 }
 333
 334 template<>
 335 __forceinline__ __device__ unsigned long int surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 336 {
 337   return (unsigned long int)__surfModeSwitch(surf, x, mode, u1).x;
 338 }
 339
 340 template<>
 341 __forceinline__ __device__ long1 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 342 {
 343   return make_long1((long int)__surfModeSwitch(surf, x, mode, u1).x);
 344 }
 345
 346 template<>
 347 __forceinline__ __device__ ulong1 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 348 {
 349   return make_ulong1((unsigned long int)__surfModeSwitch(surf, x, mode, u1).x);
 350 }
 351
 352 template<>
 353 __forceinline__ __device__ long2 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 354 {
 355   uint2 tmp = __surfModeSwitch(surf, x, mode, u2);
 356
 357   return make_long2((long int)tmp.x, (long int)tmp.y);
 358 }
 359
 360 template<>
 361 __forceinline__ __device__ ulong2 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 362 {
 363   uint2 tmp = __surfModeSwitch(surf, x, mode, u2);
 364
 365   return make_ulong2((unsigned long int)tmp.x, (unsigned long int)tmp.y);
 366 }
 367
 368 template<>
 369 __forceinline__ __device__ long4 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 370 {
 371   uint4 tmp = __surfModeSwitch(surf, x, mode, u4);
 372
 373   return make_long4((long int)tmp.x, (long int)tmp.y, (long int)tmp.z, (long int)tmp.w);
 374 }
 375
 376 template<>
 377 __forceinline__ __device__ ulong4 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 378 {
 379   uint4 tmp = __surfModeSwitch(surf, x, mode, u4);
 380
 381   return make_ulong4((unsigned long int)tmp.x, (unsigned long int)tmp.y, (unsigned long int)tmp.z, (unsigned long int)tmp.w);
 382 }
 383
 384 #endif /* !__LP64__ */
 385
 386 template<>
 387 __forceinline__ __device__ float surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 388 {
 389   return __int_as_float((int)__surfModeSwitch(surf, x, mode, u1).x);
 390 }
 391
 392 template<>
 393 __forceinline__ __device__ float1 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 394 {
 395   return make_float1(__int_as_float((int)__surfModeSwitch(surf, x, mode, u1).x));
 396 }
 397
 398 template<>
 399 __forceinline__ __device__ float2 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 400 {
 401   uint2 tmp = __surfModeSwitch(surf, x, mode, u2);
 402
 403   return make_float2(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y));
 404 }
 405
 406 template<>
 407 __forceinline__ __device__ float4 surf1Dread(surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode)
 408 {
 409   uint4 tmp = __surfModeSwitch(surf, x, mode, u4);
 410
 411   return make_float4(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y), __int_as_float((int)tmp.z), __int_as_float((int)tmp.w));
 412 }
 413
 414 #undef __surfModeSwitch
 415
 416 /*******************************************************************************
 417 *                                                                              *
 418 *                                                                              *
 419 *                                                                              *
 420 *******************************************************************************/
 421 extern __device__ __device_builtin__ uchar1     __surf2Dreadc1(surface<void, cudaSurfaceType2D> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
 422 extern __device__ __device_builtin__ uchar2     __surf2Dreadc2(surface<void, cudaSurfaceType2D> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
 423 extern __device__ __device_builtin__ uchar4     __surf2Dreadc4(surface<void, cudaSurfaceType2D> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
 424 extern __device__ __device_builtin__ ushort1    __surf2Dreads1(surface<void, cudaSurfaceType2D> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
 425 extern __device__ __device_builtin__ ushort2    __surf2Dreads2(surface<void, cudaSurfaceType2D> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
 426 extern __device__ __device_builtin__ ushort4    __surf2Dreads4(surface<void, cudaSurfaceType2D> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
 427 extern __device__ __device_builtin__ uint1      __surf2Dreadu1(surface<void, cudaSurfaceType2D> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
 428 extern __device__ __device_builtin__ uint2      __surf2Dreadu2(surface<void, cudaSurfaceType2D> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
 429 extern __device__ __device_builtin__ uint4      __surf2Dreadu4(surface<void, cudaSurfaceType2D> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
 430 extern __device__ __device_builtin__ ulonglong1 __surf2Dreadl1(surface<void, cudaSurfaceType2D> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
 431 extern __device__ __device_builtin__ ulonglong2 __surf2Dreadl2(surface<void, cudaSurfaceType2D> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
 432
 433 #if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 200
 434
 435 #define __surfModeSwitch(surf, x, y, mode, type)                                                   \
 436         ((mode == cudaBoundaryModeZero)  ? __surf2Dread##type(surf, x, y, cudaBoundaryModeZero ) : \
 437          (mode == cudaBoundaryModeClamp) ? __surf2Dread##type(surf, x, y, cudaBoundaryModeClamp) : \
 438                                            __surf2Dread##type(surf, x, y, cudaBoundaryModeTrap ))
 439
 440 #else /* __CUDA_ARCH__ && __CUDA_ARCH__ >= 200 */
 441
 442 #define __surfModeSwitch(surf, x, y, mode, type) \
 443         __surf2Dread##type(surf, x, y, cudaBoundaryModeTrap)
 444
 445 #endif /* __CUDA_ARCH__ && __CUDA_ARCH__ >= 200 */
 446
 447 template<class T>
 448 static __forceinline__ __device__ void surf2Dread(T *res, surface<void, cudaSurfaceType2D> surf, int x, int y, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
 449 {
 450   (s ==  1) ? (void)(*(uchar1 *)res = __surfModeSwitch(surf, x, y, mode, c1)) :
 451   (s ==  2) ? (void)(*(ushort1*)res = __surfModeSwitch(surf, x, y, mode, s1)) :
 452   (s ==  4) ? (void)(*(uint1  *)res = __surfModeSwitch(surf, x, y, mode, u1)) :
 453   (s ==  8) ? (void)(*(uint2  *)res = __surfModeSwitch(surf, x, y, mode, u2)) :
 454   (s == 16) ? (void)(*(uint4  *)res = __surfModeSwitch(surf, x, y, mode, u4)) :
 455               (void)0;
 456 }
 457
 458 template<class T>
 459 static __forceinline__ __device__ T surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
 460 {
 461   T tmp;
 462
 463   surf2Dread(&tmp, surf, x, y, (int)sizeof(T), mode);
 464
 465   return tmp;
 466 }
 467
 468 template<class T>
 469 static __forceinline__ __device__ void surf2Dread(T *res, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
 470 {
 471   *res = surf2Dread<T>(surf, x, y, mode);
 472 }
 473
 474 template<>
 475 __forceinline__ __device__ char surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 476 {
 477   return (char)__surfModeSwitch(surf, x, y, mode, c1).x;
 478 }
 479
 480 template<>
 481 __forceinline__ __device__ signed char surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 482 {
 483   return (signed char)__surfModeSwitch(surf, x, y, mode, c1).x;
 484 }
 485
 486 template<>
 487 __forceinline__ __device__ unsigned char surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 488 {
 489   return __surfModeSwitch(surf, x, y, mode, c1).x;
 490 }
 491
 492 template<>
 493 __forceinline__ __device__ char1 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 494 {
 495   return make_char1((signed char)__surfModeSwitch(surf, x, y, mode, c1).x);
 496 }
 497
 498 template<>
 499 __forceinline__ __device__ uchar1 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 500 {
 501   return __surfModeSwitch(surf, x, y, mode, c1);
 502 }
 503
 504 template<>
 505 __forceinline__ __device__ char2 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 506 {
 507   uchar2 tmp = __surfModeSwitch(surf, x, y, mode, c2);
 508
 509   return make_char2((signed char)tmp.x, (signed char)tmp.y);
 510 }
 511
 512 template<>
 513 __forceinline__ __device__ uchar2 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 514 {
 515   return __surfModeSwitch(surf, x, y, mode, c2);
 516 }
 517
 518 template<>
 519 __forceinline__ __device__ char4 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 520 {
 521   uchar4 tmp = __surfModeSwitch(surf, x, y, mode, c4);
 522
 523   return make_char4((signed char)tmp.x, (signed char)tmp.y, (signed char)tmp.z, (signed char)tmp.w);
 524 }
 525
 526 template<>
 527 __forceinline__ __device__ uchar4 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 528 {
 529   return __surfModeSwitch(surf, x, y, mode, c4);
 530 }
 531
 532 template<>
 533 __forceinline__ __device__ short surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 534 {
 535   return (short)__surfModeSwitch(surf, x, y, mode, s1).x;
 536 }
 537
 538 template<>
 539 __forceinline__ __device__ unsigned short surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 540 {
 541   return __surfModeSwitch(surf, x, y, mode, s1).x;
 542 }
 543
 544 template<>
 545 __forceinline__ __device__ short1 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 546 {
 547   return make_short1((signed short)__surfModeSwitch(surf, x, y, mode, s1).x);
 548 }
 549
 550 template<>
 551 __forceinline__ __device__ ushort1 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 552 {
 553   return __surfModeSwitch(surf, x, y, mode, s1);
 554 }
 555
 556 template<>
 557 __forceinline__ __device__ short2 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 558 {
 559   ushort2 tmp = __surfModeSwitch(surf, x, y, mode, s2);
 560
 561   return make_short2((signed short)tmp.x, (signed short)tmp.y);
 562 }
 563
 564 template<>
 565 __forceinline__ __device__ ushort2 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 566 {
 567   return __surfModeSwitch(surf, x, y, mode, s2);
 568 }
 569
 570 template<>
 571 __forceinline__ __device__ short4 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 572 {
 573   ushort4 tmp = __surfModeSwitch(surf, x, y, mode, s4);
 574
 575   return make_short4((signed short)tmp.x, (signed short)tmp.y, (signed short)tmp.z, (signed short)tmp.w);
 576 }
 577
 578 template<>
 579 __forceinline__ __device__ ushort4 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 580 {
 581   return __surfModeSwitch(surf, x, y, mode, s4);
 582 }
 583
 584 template<>
 585 __forceinline__ __device__ int surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 586 {
 587   return (int)__surfModeSwitch(surf, x, y, mode, u1).x;
 588 }
 589
 590 template<>
 591 __forceinline__ __device__ unsigned int surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 592 {
 593   return __surfModeSwitch(surf, x, y, mode, u1).x;
 594 }
 595
 596 template<>
 597 __forceinline__ __device__ int1 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 598 {
 599   return make_int1((signed int)__surfModeSwitch(surf, x, y, mode, u1).x);
 600 }
 601
 602 template<>
 603 __forceinline__ __device__ uint1 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 604 {
 605   return __surfModeSwitch(surf, x, y, mode, u1);
 606 }
 607
 608 template<>
 609 __forceinline__ __device__ int2 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 610 {
 611   uint2 tmp = __surfModeSwitch(surf, x, y, mode, u2);
 612
 613   return make_int2((int)tmp.x, (int)tmp.y);
 614 }
 615
 616 template<>
 617 __forceinline__ __device__ uint2 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 618 {
 619   return __surfModeSwitch(surf, x, y, mode, u2);
 620 }
 621
 622 template<>
 623 __forceinline__ __device__ int4 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 624 {
 625   uint4 tmp = __surfModeSwitch(surf, x, y, mode, u4);
 626
 627   return make_int4((int)tmp.x, (int)tmp.y, (int)tmp.z, (int)tmp.w);
 628 }
 629
 630 template<>
 631 __forceinline__ __device__ uint4 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 632 {
 633   return __surfModeSwitch(surf, x, y, mode, u4);
 634 }
 635
 636 template<>
 637 __forceinline__ __device__ long long int surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 638 {
 639   return (long long int)__surfModeSwitch(surf, x, y, mode, l1).x;
 640 }
 641
 642 template<>
 643 __forceinline__ __device__ unsigned long long int surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 644 {
 645   return __surfModeSwitch(surf, x, y, mode, l1).x;
 646 }
 647
 648 template<>
 649 __forceinline__ __device__ longlong1 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 650 {
 651   return make_longlong1((long long int)__surfModeSwitch(surf, x, y, mode, l1).x);
 652 }
 653
 654 template<>
 655 __forceinline__ __device__ ulonglong1 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 656 {
 657   return __surfModeSwitch(surf, x, y, mode, l1);
 658 }
 659
 660 template<>
 661 __forceinline__ __device__ longlong2 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 662 {
 663   ulonglong2 tmp = __surfModeSwitch(surf, x, y, mode, l2);
 664
 665   return make_longlong2((long long int)tmp.x, (long long int)tmp.y);
 666 }
 667
 668 template<>
 669 __forceinline__ __device__ ulonglong2 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 670 {
 671   return __surfModeSwitch(surf, x, y, mode, l2);
 672 }
 673
 674 #if !defined(__LP64__)
 675
 676 template<>
 677 __forceinline__ __device__ long int surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 678 {
 679   return (long int)__surfModeSwitch(surf, x, y, mode, u1).x;
 680 }
 681
 682 template<>
 683 __forceinline__ __device__ unsigned long int surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 684 {
 685   return (unsigned long int)__surfModeSwitch(surf, x, y, mode, u1).x;
 686 }
 687
 688 template<>
 689 __forceinline__ __device__ long1 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 690 {
 691   return make_long1((long int)__surfModeSwitch(surf, x, y, mode, u1).x);
 692 }
 693
 694 template<>
 695 __forceinline__ __device__ ulong1 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 696 {
 697   return make_ulong1((unsigned long int)__surfModeSwitch(surf, x, y, mode, u1).x);
 698 }
 699
 700 template<>
 701 __forceinline__ __device__ long2 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 702 {
 703   uint2 tmp = __surfModeSwitch(surf, x, y, mode, u2);
 704
 705   return make_long2((long int)tmp.x, (long int)tmp.y);
 706 }
 707
 708 template<>
 709 __forceinline__ __device__ ulong2 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 710 {
 711   uint2 tmp = __surfModeSwitch(surf, x, y, mode, u2);
 712
 713   return make_ulong2((unsigned long int)tmp.x, (unsigned long int)tmp.y);
 714 }
 715
 716 template<>
 717 __forceinline__ __device__ long4 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 718 {
 719   uint4 tmp = __surfModeSwitch(surf, x, y, mode, u4);
 720
 721   return make_long4((long int)tmp.x, (long int)tmp.y, (long int)tmp.z, (long int)tmp.w);
 722 }
 723
 724 template<>
 725 __forceinline__ __device__ ulong4 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 726 {
 727   uint4 tmp = __surfModeSwitch(surf, x, y, mode, u4);
 728
 729   return make_ulong4((unsigned long int)tmp.x, (unsigned long int)tmp.y, (unsigned long int)tmp.z, (unsigned long int)tmp.w);
 730 }
 731
 732 #endif /* !__LP64__ */
 733
 734 template<>
 735 __forceinline__ __device__ float surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 736 {
 737   return __int_as_float((int)__surfModeSwitch(surf, x, y, mode, u1).x);
 738 }
 739
 740 template<>
 741 __forceinline__ __device__ float1 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 742 {
 743   return make_float1(__int_as_float((int)__surfModeSwitch(surf, x, y, mode, u1).x));
 744 }
 745
 746 template<>
 747 __forceinline__ __device__ float2 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 748 {
 749   uint2 tmp = __surfModeSwitch(surf, x, y, mode, u2);
 750
 751   return make_float2(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y));
 752 }
 753
 754 template<>
 755 __forceinline__ __device__ float4 surf2Dread(surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
 756 {
 757   uint4 tmp = __surfModeSwitch(surf, x, y, mode, u4);
 758
 759   return make_float4(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y), __int_as_float((int)tmp.z), __int_as_float((int)tmp.w));
 760 }
 761
 762 #undef __surfModeSwitch
 763
 764 /*******************************************************************************
 765 *                                                                              *
 766 *                                                                              *
 767 *                                                                              *
 768 *******************************************************************************/
 769 extern __device__ __device_builtin__ uchar1     __surf3Dreadc1(surface<void, cudaSurfaceType3D> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
 770 extern __device__ __device_builtin__ uchar2     __surf3Dreadc2(surface<void, cudaSurfaceType3D> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
 771 extern __device__ __device_builtin__ uchar4     __surf3Dreadc4(surface<void, cudaSurfaceType3D> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
 772 extern __device__ __device_builtin__ ushort1    __surf3Dreads1(surface<void, cudaSurfaceType3D> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
 773 extern __device__ __device_builtin__ ushort2    __surf3Dreads2(surface<void, cudaSurfaceType3D> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
 774 extern __device__ __device_builtin__ ushort4    __surf3Dreads4(surface<void, cudaSurfaceType3D> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
 775 extern __device__ __device_builtin__ uint1      __surf3Dreadu1(surface<void, cudaSurfaceType3D> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
 776 extern __device__ __device_builtin__ uint2      __surf3Dreadu2(surface<void, cudaSurfaceType3D> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
 777 extern __device__ __device_builtin__ uint4      __surf3Dreadu4(surface<void, cudaSurfaceType3D> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
 778 extern __device__ __device_builtin__ ulonglong1 __surf3Dreadl1(surface<void, cudaSurfaceType3D> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
 779 extern __device__ __device_builtin__ ulonglong2 __surf3Dreadl2(surface<void, cudaSurfaceType3D> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
 780
 781 #if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 200
 782
 783 #define __surfModeSwitch(surf, x, y, z, mode, type)                                                   \
 784         ((mode == cudaBoundaryModeZero)  ? __surf3Dread##type(surf, x, y, z, cudaBoundaryModeZero ) : \
 785          (mode == cudaBoundaryModeClamp) ? __surf3Dread##type(surf, x, y, z, cudaBoundaryModeClamp) : \
 786                                            __surf3Dread##type(surf, x, y, z, cudaBoundaryModeTrap ))
 787
 788 #else /* CUDA_ARCH && __CUDA_ARCH__ >= 200 */
 789
 790 #define __surfModeSwitch(surf, x, y, z, mode, type) \
 791          __surf3Dread##type(surf, x, y, z, cudaBoundaryModeTrap)
 792
 793 #endif /* CUDA_ARCH && __CUDA_ARCH__ >= 200 */
 794
 795 template<class T>
 796 static __forceinline__ __device__ void surf3Dread(T *res, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
 797 {
 798   (s ==  1) ? (void)(*(uchar1 *)res = __surfModeSwitch(surf, x, y, z, mode, c1)) :
 799   (s ==  2) ? (void)(*(ushort1*)res = __surfModeSwitch(surf, x, y, z, mode, s1)) :
 800   (s ==  4) ? (void)(*(uint1  *)res = __surfModeSwitch(surf, x, y, z, mode, u1)) :
 801   (s ==  8) ? (void)(*(uint2  *)res = __surfModeSwitch(surf, x, y, z, mode, u2)) :
 802   (s == 16) ? (void)(*(uint4  *)res = __surfModeSwitch(surf, x, y, z, mode, u4)) :
 803               (void)0;
 804 }
 805
 806 template<class T>
 807 static __forceinline__ __device__ T surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
 808 {
 809   T tmp;
 810
 811   surf3Dread(&tmp, surf, x, y, z, (int)sizeof(T), mode);
 812
 813   return tmp;
 814 }
 815
 816 template<class T>
 817 static __forceinline__ __device__ void surf3Dread(T *res, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
 818 {
 819   *res = surf3Dread<T>(surf, x, y, z, mode);
 820 }
 821
 822 template<>
 823 __forceinline__ __device__ char surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 824 {
 825   return (char)__surfModeSwitch(surf, x, y, z, mode, c1).x;
 826 }
 827
 828 template<>
 829 __forceinline__ __device__ signed char surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 830 {
 831   return (signed char)__surfModeSwitch(surf, x, y, z, mode, c1).x;
 832 }
 833
 834 template<>
 835 __forceinline__ __device__ unsigned char surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 836 {
 837   return __surfModeSwitch(surf, x, y, z, mode, c1).x;
 838 }
 839
 840 template<>
 841 __forceinline__ __device__ char1 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 842 {
 843   return make_char1((signed char)__surfModeSwitch(surf, x, y, z, mode, c1).x);
 844 }
 845
 846 template<>
 847 __forceinline__ __device__ uchar1 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 848 {
 849   return __surfModeSwitch(surf, x, y, z, mode, c1);
 850 }
 851
 852 template<>
 853 __forceinline__ __device__ char2 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 854 {
 855   uchar2 tmp = __surfModeSwitch(surf, x, y, z, mode, c2);
 856
 857   return make_char2((signed char)tmp.x, (signed char)tmp.y);
 858 }
 859
 860 template<>
 861 __forceinline__ __device__ uchar2 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 862 {
 863   return __surfModeSwitch(surf, x, y, z, mode, c2);
 864 }
 865
 866 template<>
 867 __forceinline__ __device__ char4 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 868 {
 869   uchar4 tmp = __surfModeSwitch(surf, x, y, z, mode, c4);
 870
 871   return make_char4((signed char)tmp.x, (signed char)tmp.y, (signed char)tmp.z, (signed char)tmp.w);
 872 }
 873
 874 template<>
 875 __forceinline__ __device__ uchar4 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 876 {
 877   return __surfModeSwitch(surf, x, y, z, mode, c4);
 878 }
 879
 880 template<>
 881 __forceinline__ __device__ short surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 882 {
 883   return (short)__surfModeSwitch(surf, x, y, z, mode, s1).x;
 884 }
 885
 886 template<>
 887 __forceinline__ __device__ unsigned short surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 888 {
 889   return __surfModeSwitch(surf, x, y, z, mode, s1).x;
 890 }
 891
 892 template<>
 893 __forceinline__ __device__ short1 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 894 {
 895   return make_short1((signed short)__surfModeSwitch(surf, x, y, z, mode, s1).x);
 896 }
 897
 898 template<>
 899 __forceinline__ __device__ ushort1 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 900 {
 901   return __surfModeSwitch(surf, x, y, z, mode, s1);
 902 }
 903
 904 template<>
 905 __forceinline__ __device__ short2 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 906 {
 907   ushort2 tmp = __surfModeSwitch(surf, x, y, z, mode, s2);
 908
 909   return make_short2((signed short)tmp.x, (signed short)tmp.y);
 910 }
 911
 912 template<>
 913 __forceinline__ __device__ ushort2 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 914 {
 915   return __surfModeSwitch(surf, x, y, z, mode, s2);
 916 }
 917
 918 template<>
 919 __forceinline__ __device__ short4 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 920 {
 921   ushort4 tmp = __surfModeSwitch(surf, x, y, z, mode, s4);
 922
 923   return make_short4((signed short)tmp.x, (signed short)tmp.y, (signed short)tmp.z, (signed short)tmp.w);
 924 }
 925
 926 template<>
 927 __forceinline__ __device__ ushort4 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 928 {
 929   return __surfModeSwitch(surf, x, y, z, mode, s4);
 930 }
 931
 932 template<>
 933 __forceinline__ __device__ int surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 934 {
 935   return (int)__surfModeSwitch(surf, x, y, z, mode, u1).x;
 936 }
 937
 938 template<>
 939 __forceinline__ __device__ unsigned int surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 940 {
 941   return __surfModeSwitch(surf, x, y, z, mode, u1).x;
 942 }
 943
 944 template<>
 945 __forceinline__ __device__ int1 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 946 {
 947   return make_int1((signed int)__surfModeSwitch(surf, x, y, z, mode, u1).x);
 948 }
 949
 950 template<>
 951 __forceinline__ __device__ uint1 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 952 {
 953   return __surfModeSwitch(surf, x, y, z, mode, u1);
 954 }
 955
 956 template<>
 957 __forceinline__ __device__ int2 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 958 {
 959   uint2 tmp = __surfModeSwitch(surf, x, y, z, mode, u2);
 960
 961   return make_int2((int)tmp.x, (int)tmp.y);
 962 }
 963
 964 template<>
 965 __forceinline__ __device__ uint2 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 966 {
 967   return __surfModeSwitch(surf, x, y, z, mode, u2);
 968 }
 969
 970 template<>
 971 __forceinline__ __device__ int4 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 972 {
 973   uint4 tmp = __surfModeSwitch(surf, x, y, z, mode, u4);
 974
 975   return make_int4((int)tmp.x, (int)tmp.y, (int)tmp.z, (int)tmp.w);
 976 }
 977
 978 template<>
 979 __forceinline__ __device__ uint4 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 980 {
 981   return __surfModeSwitch(surf, x, y, z, mode, u4);
 982 }
 983
 984 template<>
 985 __forceinline__ __device__ long long int surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 986 {
 987   return (long long int)__surfModeSwitch(surf, x, y, z, mode, l1).x;
 988 }
 989
 990 template<>
 991 __forceinline__ __device__ unsigned long long int surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 992 {
 993   return __surfModeSwitch(surf, x, y, z, mode, l1).x;
 994 }
 995
 996 template<>
 997 __forceinline__ __device__ longlong1 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
 998 {
 999   return make_longlong1((long long int)__surfModeSwitch(surf, x, y, z, mode, l1).x);
1000 }
1001
1002 template<>
1003 __forceinline__ __device__ ulonglong1 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
1004 {
1005   return __surfModeSwitch(surf, x, y, z, mode, l1);
1006 }
1007
1008 template<>
1009 __forceinline__ __device__ longlong2 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
1010 {
1011   ulonglong2 tmp = __surfModeSwitch(surf, x, y, z, mode, l2);
1012
1013   return make_longlong2((long long int)tmp.x, (long long int)tmp.y);
1014 }
1015
1016 template<>
1017 __forceinline__ __device__ ulonglong2 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
1018 {
1019   return __surfModeSwitch(surf, x, y, z, mode, l2);
1020 }
1021
1022 #if !defined(__LP64__)
1023
1024 template<>
1025 __forceinline__ __device__ long int surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
1026 {
1027   return (long int)__surfModeSwitch(surf, x, y, z, mode, u1).x;
1028 }
1029
1030 template<>
1031 __forceinline__ __device__ unsigned long int surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
1032 {
1033   return (unsigned long int)__surfModeSwitch(surf, x, y, z, mode, u1).x;
1034 }
1035
1036 template<>
1037 __forceinline__ __device__ long1 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
1038 {
1039   return make_long1((long int)__surfModeSwitch(surf, x, y, z, mode, u1).x);
1040 }
1041
1042 template<>
1043 __forceinline__ __device__ ulong1 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
1044 {
1045   return make_ulong1((unsigned long int)__surfModeSwitch(surf, x, y, z, mode, u1).x);
1046 }
1047
1048 template<>
1049 __forceinline__ __device__ long2 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
1050 {
1051   uint2 tmp = __surfModeSwitch(surf, x, y, z, mode, u2);
1052
1053   return make_long2((long int)tmp.x, (long int)tmp.y);
1054 }
1055
1056 template<>
1057 __forceinline__ __device__ ulong2 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
1058 {
1059   uint2 tmp = __surfModeSwitch(surf, x, y, z, mode, u2);
1060
1061   return make_ulong2((unsigned long int)tmp.x, (unsigned long int)tmp.y);
1062 }
1063
1064 template<>
1065 __forceinline__ __device__ long4 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
1066 {
1067   uint4 tmp = __surfModeSwitch(surf, x, y, z, mode, u4);
1068
1069   return make_long4((long int)tmp.x, (long int)tmp.y, (long int)tmp.z, (long int)tmp.w);
1070 }
1071
1072 template<>
1073 __forceinline__ __device__ ulong4 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
1074 {
1075   uint4 tmp = __surfModeSwitch(surf, x, y, z, mode, u4);
1076
1077   return make_ulong4((unsigned long int)tmp.x, (unsigned long int)tmp.y, (unsigned long int)tmp.z, (unsigned long int)tmp.w);
1078 }
1079
1080 #endif /* !__LP64__ */
1081
1082 template<>
1083 __forceinline__ __device__ float surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
1084 {
1085   return __int_as_float((int)__surfModeSwitch(surf, x, y, z, mode, u1).x);
1086 }
1087
1088 template<>
1089 __forceinline__ __device__ float1 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
1090 {
1091   return make_float1(__int_as_float((int)__surfModeSwitch(surf, x, y, z, mode, u1).x));
1092 }
1093
1094 template<>
1095 __forceinline__ __device__ float2 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
1096 {
1097   uint2 tmp = __surfModeSwitch(surf, x, y, z, mode, u2);
1098
1099   return make_float2(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y));
1100 }
1101
1102 template<>
1103 __forceinline__ __device__ float4 surf3Dread(surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
1104 {
1105   uint4 tmp = __surfModeSwitch(surf, x, y, z, mode, u4);
1106
1107   return make_float4(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y), __int_as_float((int)tmp.z), __int_as_float((int)tmp.w));
1108 }
1109
1110 #undef __surfModeSwitch
1111
1112 /*******************************************************************************
1113 *                                                                              *
1114 *                                                                              *
1115 *                                                                              *
1116 *******************************************************************************/
1117 extern __device__ __device_builtin__ uchar1     __surf1DLayeredreadc1(surface<void, cudaSurfaceType1DLayered> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
1118 extern __device__ __device_builtin__ uchar2     __surf1DLayeredreadc2(surface<void, cudaSurfaceType1DLayered> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
1119 extern __device__ __device_builtin__ uchar4     __surf1DLayeredreadc4(surface<void, cudaSurfaceType1DLayered> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
1120 extern __device__ __device_builtin__ ushort1    __surf1DLayeredreads1(surface<void, cudaSurfaceType1DLayered> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
1121 extern __device__ __device_builtin__ ushort2    __surf1DLayeredreads2(surface<void, cudaSurfaceType1DLayered> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
1122 extern __device__ __device_builtin__ ushort4    __surf1DLayeredreads4(surface<void, cudaSurfaceType1DLayered> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
1123 extern __device__ __device_builtin__ uint1      __surf1DLayeredreadu1(surface<void, cudaSurfaceType1DLayered> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
1124 extern __device__ __device_builtin__ uint2      __surf1DLayeredreadu2(surface<void, cudaSurfaceType1DLayered> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
1125 extern __device__ __device_builtin__ uint4      __surf1DLayeredreadu4(surface<void, cudaSurfaceType1DLayered> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
1126 extern __device__ __device_builtin__ ulonglong1 __surf1DLayeredreadl1(surface<void, cudaSurfaceType1DLayered> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
1127 extern __device__ __device_builtin__ ulonglong2 __surf1DLayeredreadl2(surface<void, cudaSurfaceType1DLayered> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
1128
1129 #if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 200
1130
1131 #define __surfModeSwitch(surf, x, layer, mode, type)                                                   \
1132         ((mode == cudaBoundaryModeZero)  ? __surf1DLayeredread##type(surf, x, layer, cudaBoundaryModeZero ) : \
1133          (mode == cudaBoundaryModeClamp) ? __surf1DLayeredread##type(surf, x, layer, cudaBoundaryModeClamp) : \
1134                                            __surf1DLayeredread##type(surf, x, layer, cudaBoundaryModeTrap ))
1135
1136 #else /* CUDA_ARCH && __CUDA_ARCH__ >= 200 */
1137
1138 #define __surfModeSwitch(surf, x, layer, mode, type) \
1139          __surf1DLayeredread##type(surf, x, layer, cudaBoundaryModeTrap)
1140
1141 #endif /* CUDA_ARCH && __CUDA_ARCH__ >= 200 */
1142
1143 template<class T>
1144 static __forceinline__ __device__ void surf1DLayeredread(T *res, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
1145 {
1146   (s ==  1) ? (void)(*(uchar1 *)res = __surfModeSwitch(surf, x, layer, mode, c1)) :
1147   (s ==  2) ? (void)(*(ushort1*)res = __surfModeSwitch(surf, x, layer, mode, s1)) :
1148   (s ==  4) ? (void)(*(uint1  *)res = __surfModeSwitch(surf, x, layer, mode, u1)) :
1149   (s ==  8) ? (void)(*(uint2  *)res = __surfModeSwitch(surf, x, layer, mode, u2)) :
1150   (s == 16) ? (void)(*(uint4  *)res = __surfModeSwitch(surf, x, layer, mode, u4)) :
1151               (void)0;
1152 }
1153
1154 template<class T>
1155 static __forceinline__ __device__ T surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
1156 {
1157   T tmp;
1158
1159   surf1DLayeredread(&tmp, surf, x, layer, (int)sizeof(T), mode);
1160
1161   return tmp;
1162 }
1163
1164 template<class T>
1165 static __forceinline__ __device__ void surf1DLayeredread(T *res, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
1166 {
1167   *res = surf1DLayeredread<T>(surf, x, layer, mode);
1168 }
1169
1170 template<>
1171 __forceinline__ __device__ char surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1172 {
1173   return (char)__surfModeSwitch(surf, x, layer, mode, c1).x;
1174 }
1175
1176 template<>
1177 __forceinline__ __device__ signed char surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1178 {
1179   return (signed char)__surfModeSwitch(surf, x, layer, mode, c1).x;
1180 }
1181
1182 template<>
1183 __forceinline__ __device__ unsigned char surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1184 {
1185   return __surfModeSwitch(surf, x, layer, mode, c1).x;
1186 }
1187
1188 template<>
1189 __forceinline__ __device__ char1 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1190 {
1191   return make_char1((signed char)__surfModeSwitch(surf, x, layer, mode, c1).x);
1192 }
1193
1194 template<>
1195 __forceinline__ __device__ uchar1 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1196 {
1197   return __surfModeSwitch(surf, x, layer, mode, c1);
1198 }
1199
1200 template<>
1201 __forceinline__ __device__ char2 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1202 {
1203   uchar2 tmp = __surfModeSwitch(surf, x, layer, mode, c2);
1204
1205   return make_char2((signed char)tmp.x, (signed char)tmp.y);
1206 }
1207
1208 template<>
1209 __forceinline__ __device__ uchar2 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1210 {
1211   return __surfModeSwitch(surf, x, layer, mode, c2);
1212 }
1213
1214 template<>
1215 __forceinline__ __device__ char4 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1216 {
1217   uchar4 tmp = __surfModeSwitch(surf, x, layer, mode, c4);
1218
1219   return make_char4((signed char)tmp.x, (signed char)tmp.y, (signed char)tmp.z, (signed char)tmp.w);
1220 }
1221
1222 template<>
1223 __forceinline__ __device__ uchar4 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1224 {
1225   return __surfModeSwitch(surf, x, layer, mode, c4);
1226 }
1227
1228 template<>
1229 __forceinline__ __device__ short surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1230 {
1231   return (short)__surfModeSwitch(surf, x, layer, mode, s1).x;
1232 }
1233
1234 template<>
1235 __forceinline__ __device__ unsigned short surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1236 {
1237   return __surfModeSwitch(surf, x, layer, mode, s1).x;
1238 }
1239
1240 template<>
1241 __forceinline__ __device__ short1 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1242 {
1243   return make_short1((signed short)__surfModeSwitch(surf, x, layer, mode, s1).x);
1244 }
1245
1246 template<>
1247 __forceinline__ __device__ ushort1 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1248 {
1249   return __surfModeSwitch(surf, x, layer, mode, s1);
1250 }
1251
1252 template<>
1253 __forceinline__ __device__ short2 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1254 {
1255   ushort2 tmp = __surfModeSwitch(surf, x, layer, mode, s2);
1256
1257   return make_short2((signed short)tmp.x, (signed short)tmp.y);
1258 }
1259
1260 template<>
1261 __forceinline__ __device__ ushort2 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1262 {
1263   return __surfModeSwitch(surf, x, layer, mode, s2);
1264 }
1265
1266 template<>
1267 __forceinline__ __device__ short4 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1268 {
1269   ushort4 tmp = __surfModeSwitch(surf, x, layer, mode, s4);
1270
1271   return make_short4((signed short)tmp.x, (signed short)tmp.y, (signed short)tmp.z, (signed short)tmp.w);
1272 }
1273
1274 template<>
1275 __forceinline__ __device__ ushort4 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1276 {
1277   return __surfModeSwitch(surf, x, layer, mode, s4);
1278 }
1279
1280 template<>
1281 __forceinline__ __device__ int surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1282 {
1283   return (int)__surfModeSwitch(surf, x, layer, mode, u1).x;
1284 }
1285
1286 template<>
1287 __forceinline__ __device__ unsigned int surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1288 {
1289   return __surfModeSwitch(surf, x, layer, mode, u1).x;
1290 }
1291
1292 template<>
1293 __forceinline__ __device__ int1 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1294 {
1295   return make_int1((signed int)__surfModeSwitch(surf, x, layer, mode, u1).x);
1296 }
1297
1298 template<>
1299 __forceinline__ __device__ uint1 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1300 {
1301   return __surfModeSwitch(surf, x, layer, mode, u1);
1302 }
1303
1304 template<>
1305 __forceinline__ __device__ int2 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1306 {
1307   uint2 tmp = __surfModeSwitch(surf, x, layer, mode, u2);
1308
1309   return make_int2((int)tmp.x, (int)tmp.y);
1310 }
1311
1312 template<>
1313 __forceinline__ __device__ uint2 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1314 {
1315   return __surfModeSwitch(surf, x, layer, mode, u2);
1316 }
1317
1318 template<>
1319 __forceinline__ __device__ int4 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1320 {
1321   uint4 tmp = __surfModeSwitch(surf, x, layer, mode, u4);
1322
1323   return make_int4((int)tmp.x, (int)tmp.y, (int)tmp.z, (int)tmp.w);
1324 }
1325
1326 template<>
1327 __forceinline__ __device__ uint4 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1328 {
1329   return __surfModeSwitch(surf, x, layer, mode, u4);
1330 }
1331
1332 template<>
1333 __forceinline__ __device__ long long int surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1334 {
1335   return (long long int)__surfModeSwitch(surf, x, layer, mode, l1).x;
1336 }
1337
1338 template<>
1339 __forceinline__ __device__ unsigned long long int surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1340 {
1341   return __surfModeSwitch(surf, x, layer, mode, l1).x;
1342 }
1343
1344 template<>
1345 __forceinline__ __device__ longlong1 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1346 {
1347   return make_longlong1((long long int)__surfModeSwitch(surf, x, layer, mode, l1).x);
1348 }
1349
1350 template<>
1351 __forceinline__ __device__ ulonglong1 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1352 {
1353   return __surfModeSwitch(surf, x, layer, mode, l1);
1354 }
1355
1356 template<>
1357 __forceinline__ __device__ longlong2 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1358 {
1359   ulonglong2 tmp = __surfModeSwitch(surf, x, layer, mode, l2);
1360
1361   return make_longlong2((long long int)tmp.x, (long long int)tmp.y);
1362 }
1363
1364 template<>
1365 __forceinline__ __device__ ulonglong2 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1366 {
1367   return __surfModeSwitch(surf, x, layer, mode, l2);
1368 }
1369
1370 #if !defined(__LP64__)
1371
1372 template<>
1373 __forceinline__ __device__ long int surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1374 {
1375   return (long int)__surfModeSwitch(surf, x, layer, mode, u1).x;
1376 }
1377
1378 template<>
1379 __forceinline__ __device__ unsigned long int surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1380 {
1381   return (unsigned long int)__surfModeSwitch(surf, x, layer, mode, u1).x;
1382 }
1383
1384 template<>
1385 __forceinline__ __device__ long1 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1386 {
1387   return make_long1((long int)__surfModeSwitch(surf, x, layer, mode, u1).x);
1388 }
1389
1390 template<>
1391 __forceinline__ __device__ ulong1 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1392 {
1393   return make_ulong1((unsigned long int)__surfModeSwitch(surf, x, layer, mode, u1).x);
1394 }
1395
1396 template<>
1397 __forceinline__ __device__ long2 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1398 {
1399   uint2 tmp = __surfModeSwitch(surf, x, layer, mode, u2);
1400
1401   return make_long2((long int)tmp.x, (long int)tmp.y);
1402 }
1403
1404 template<>
1405 __forceinline__ __device__ ulong2 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1406 {
1407   uint2 tmp = __surfModeSwitch(surf, x, layer, mode, u2);
1408
1409   return make_ulong2((unsigned long int)tmp.x, (unsigned long int)tmp.y);
1410 }
1411
1412 template<>
1413 __forceinline__ __device__ long4 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1414 {
1415   uint4 tmp = __surfModeSwitch(surf, x, layer, mode, u4);
1416
1417   return make_long4((long int)tmp.x, (long int)tmp.y, (long int)tmp.z, (long int)tmp.w);
1418 }
1419
1420 template<>
1421 __forceinline__ __device__ ulong4 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1422 {
1423   uint4 tmp = __surfModeSwitch(surf, x, layer, mode, u4);
1424
1425   return make_ulong4((unsigned long int)tmp.x, (unsigned long int)tmp.y, (unsigned long int)tmp.z, (unsigned long int)tmp.w);
1426 }
1427
1428 #endif /* !__LP64__ */
1429
1430 template<>
1431 __forceinline__ __device__ float surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1432 {
1433   return __int_as_float((int)__surfModeSwitch(surf, x, layer, mode, u1).x);
1434 }
1435
1436 template<>
1437 __forceinline__ __device__ float1 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1438 {
1439   return make_float1(__int_as_float((int)__surfModeSwitch(surf, x, layer, mode, u1).x));
1440 }
1441
1442 template<>
1443 __forceinline__ __device__ float2 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1444 {
1445   uint2 tmp = __surfModeSwitch(surf, x, layer, mode, u2);
1446
1447   return make_float2(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y));
1448 }
1449
1450 template<>
1451 __forceinline__ __device__ float4 surf1DLayeredread(surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
1452 {
1453   uint4 tmp = __surfModeSwitch(surf, x, layer, mode, u4);
1454
1455   return make_float4(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y), __int_as_float((int)tmp.z), __int_as_float((int)tmp.w));
1456 }
1457
1458 #undef __surfModeSwitch
1459
1460 /*******************************************************************************
1461 *                                                                              *
1462 *                                                                              *
1463 *                                                                              *
1464 *******************************************************************************/
1465 extern __device__ __device_builtin__ uchar1     __surf2DLayeredreadc1(surface<void, cudaSurfaceType2DLayered> t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
1466 extern __device__ __device_builtin__ uchar2     __surf2DLayeredreadc2(surface<void, cudaSurfaceType2DLayered> t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
1467 extern __device__ __device_builtin__ uchar4     __surf2DLayeredreadc4(surface<void, cudaSurfaceType2DLayered> t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
1468 extern __device__ __device_builtin__ ushort1    __surf2DLayeredreads1(surface<void, cudaSurfaceType2DLayered> t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
1469 extern __device__ __device_builtin__ ushort2    __surf2DLayeredreads2(surface<void, cudaSurfaceType2DLayered> t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
1470 extern __device__ __device_builtin__ ushort4    __surf2DLayeredreads4(surface<void, cudaSurfaceType2DLayered> t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
1471 extern __device__ __device_builtin__ uint1      __surf2DLayeredreadu1(surface<void, cudaSurfaceType2DLayered> t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
1472 extern __device__ __device_builtin__ uint2      __surf2DLayeredreadu2(surface<void, cudaSurfaceType2DLayered> t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
1473 extern __device__ __device_builtin__ uint4      __surf2DLayeredreadu4(surface<void, cudaSurfaceType2DLayered> t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
1474 extern __device__ __device_builtin__ ulonglong1 __surf2DLayeredreadl1(surface<void, cudaSurfaceType2DLayered> t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
1475 extern __device__ __device_builtin__ ulonglong2 __surf2DLayeredreadl2(surface<void, cudaSurfaceType2DLayered> t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
1476
1477 #if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 200
1478
1479 #define __surfModeSwitch(surf, x, y, layer, mode, type)                                                   \
1480         ((mode == cudaBoundaryModeZero)  ? __surf2DLayeredread##type(surf, x, y, layer, cudaBoundaryModeZero ) : \
1481          (mode == cudaBoundaryModeClamp) ? __surf2DLayeredread##type(surf, x, y, layer, cudaBoundaryModeClamp) : \
1482                                            __surf2DLayeredread##type(surf, x, y, layer, cudaBoundaryModeTrap ))
1483
1484 #else /* CUDA_ARCH && __CUDA_ARCH__ >= 200 */
1485
1486 #define __surfModeSwitch(surf, x, y, layer, mode, type) \
1487          __surf2DLayeredread##type(surf, x, y, layer, cudaBoundaryModeTrap)
1488
1489 #endif /* CUDA_ARCH && __CUDA_ARCH__ >= 200 */
1490
1491 template<class T>
1492 static __forceinline__ __device__ void surf2DLayeredread(T *res, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
1493 {
1494   (s ==  1) ? (void)(*(uchar1 *)res = __surfModeSwitch(surf, x, y, layer, mode, c1)) :
1495   (s ==  2) ? (void)(*(ushort1*)res = __surfModeSwitch(surf, x, y, layer, mode, s1)) :
1496   (s ==  4) ? (void)(*(uint1  *)res = __surfModeSwitch(surf, x, y, layer, mode, u1)) :
1497   (s ==  8) ? (void)(*(uint2  *)res = __surfModeSwitch(surf, x, y, layer, mode, u2)) :
1498   (s == 16) ? (void)(*(uint4  *)res = __surfModeSwitch(surf, x, y, layer, mode, u4)) :
1499               (void)0;
1500 }
1501
1502 template<class T>
1503 static __forceinline__ __device__ T surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
1504 {
1505   T tmp;
1506
1507   surf2DLayeredread(&tmp, surf, x, y, layer, (int)sizeof(T), mode);
1508
1509   return tmp;
1510 }
1511
1512 template<class T>
1513 static __forceinline__ __device__ void surf2DLayeredread(T *res, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
1514 {
1515   *res = surf2DLayeredread<T>(surf, x, y, layer, mode);
1516 }
1517
1518 template<>
1519 __forceinline__ __device__ char surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1520 {
1521   return (char)__surfModeSwitch(surf, x, y, layer, mode, c1).x;
1522 }
1523
1524 template<>
1525 __forceinline__ __device__ signed char surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1526 {
1527   return (signed char)__surfModeSwitch(surf, x, y, layer, mode, c1).x;
1528 }
1529
1530 template<>
1531 __forceinline__ __device__ unsigned char surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1532 {
1533   return __surfModeSwitch(surf, x, y, layer, mode, c1).x;
1534 }
1535
1536 template<>
1537 __forceinline__ __device__ char1 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1538 {
1539   return make_char1((signed char)__surfModeSwitch(surf, x, y, layer, mode, c1).x);
1540 }
1541
1542 template<>
1543 __forceinline__ __device__ uchar1 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1544 {
1545   return __surfModeSwitch(surf, x, y, layer, mode, c1);
1546 }
1547
1548 template<>
1549 __forceinline__ __device__ char2 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1550 {
1551   uchar2 tmp = __surfModeSwitch(surf, x, y, layer, mode, c2);
1552
1553   return make_char2((signed char)tmp.x, (signed char)tmp.y);
1554 }
1555
1556 template<>
1557 __forceinline__ __device__ uchar2 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1558 {
1559   return __surfModeSwitch(surf, x, y, layer, mode, c2);
1560 }
1561
1562 template<>
1563 __forceinline__ __device__ char4 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1564 {
1565   uchar4 tmp = __surfModeSwitch(surf, x, y, layer, mode, c4);
1566
1567   return make_char4((signed char)tmp.x, (signed char)tmp.y, (signed char)tmp.z, (signed char)tmp.w);
1568 }
1569
1570 template<>
1571 __forceinline__ __device__ uchar4 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1572 {
1573   return __surfModeSwitch(surf, x, y, layer, mode, c4);
1574 }
1575
1576 template<>
1577 __forceinline__ __device__ short surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1578 {
1579   return (short)__surfModeSwitch(surf, x, y, layer, mode, s1).x;
1580 }
1581
1582 template<>
1583 __forceinline__ __device__ unsigned short surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1584 {
1585   return __surfModeSwitch(surf, x, y, layer, mode, s1).x;
1586 }
1587
1588 template<>
1589 __forceinline__ __device__ short1 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1590 {
1591   return make_short1((signed short)__surfModeSwitch(surf, x, y, layer, mode, s1).x);
1592 }
1593
1594 template<>
1595 __forceinline__ __device__ ushort1 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1596 {
1597   return __surfModeSwitch(surf, x, y, layer, mode, s1);
1598 }
1599
1600 template<>
1601 __forceinline__ __device__ short2 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1602 {
1603   ushort2 tmp = __surfModeSwitch(surf, x, y, layer, mode, s2);
1604
1605   return make_short2((signed short)tmp.x, (signed short)tmp.y);
1606 }
1607
1608 template<>
1609 __forceinline__ __device__ ushort2 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1610 {
1611   return __surfModeSwitch(surf, x, y, layer, mode, s2);
1612 }
1613
1614 template<>
1615 __forceinline__ __device__ short4 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1616 {
1617   ushort4 tmp = __surfModeSwitch(surf, x, y, layer, mode, s4);
1618
1619   return make_short4((signed short)tmp.x, (signed short)tmp.y, (signed short)tmp.z, (signed short)tmp.w);
1620 }
1621
1622 template<>
1623 __forceinline__ __device__ ushort4 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1624 {
1625   return __surfModeSwitch(surf, x, y, layer, mode, s4);
1626 }
1627
1628 template<>
1629 __forceinline__ __device__ int surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1630 {
1631   return (int)__surfModeSwitch(surf, x, y, layer, mode, u1).x;
1632 }
1633
1634 template<>
1635 __forceinline__ __device__ unsigned int surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1636 {
1637   return __surfModeSwitch(surf, x, y, layer, mode, u1).x;
1638 }
1639
1640 template<>
1641 __forceinline__ __device__ int1 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1642 {
1643   return make_int1((signed int)__surfModeSwitch(surf, x, y, layer, mode, u1).x);
1644 }
1645
1646 template<>
1647 __forceinline__ __device__ uint1 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1648 {
1649   return __surfModeSwitch(surf, x, y, layer, mode, u1);
1650 }
1651
1652 template<>
1653 __forceinline__ __device__ int2 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1654 {
1655   uint2 tmp = __surfModeSwitch(surf, x, y, layer, mode, u2);
1656
1657   return make_int2((int)tmp.x, (int)tmp.y);
1658 }
1659
1660 template<>
1661 __forceinline__ __device__ uint2 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1662 {
1663   return __surfModeSwitch(surf, x, y, layer, mode, u2);
1664 }
1665
1666 template<>
1667 __forceinline__ __device__ int4 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1668 {
1669   uint4 tmp = __surfModeSwitch(surf, x, y, layer, mode, u4);
1670
1671   return make_int4((int)tmp.x, (int)tmp.y, (int)tmp.z, (int)tmp.w);
1672 }
1673
1674 template<>
1675 __forceinline__ __device__ uint4 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1676 {
1677   return __surfModeSwitch(surf, x, y, layer, mode, u4);
1678 }
1679
1680 template<>
1681 __forceinline__ __device__ long long int surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1682 {
1683   return (long long int)__surfModeSwitch(surf, x, y, layer, mode, l1).x;
1684 }
1685
1686 template<>
1687 __forceinline__ __device__ unsigned long long int surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1688 {
1689   return __surfModeSwitch(surf, x, y, layer, mode, l1).x;
1690 }
1691
1692 template<>
1693 __forceinline__ __device__ longlong1 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1694 {
1695   return make_longlong1((long long int)__surfModeSwitch(surf, x, y, layer, mode, l1).x);
1696 }
1697
1698 template<>
1699 __forceinline__ __device__ ulonglong1 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1700 {
1701   return __surfModeSwitch(surf, x, y, layer, mode, l1);
1702 }
1703
1704 template<>
1705 __forceinline__ __device__ longlong2 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1706 {
1707   ulonglong2 tmp = __surfModeSwitch(surf, x, y, layer, mode, l2);
1708
1709   return make_longlong2((long long int)tmp.x, (long long int)tmp.y);
1710 }
1711
1712 template<>
1713 __forceinline__ __device__ ulonglong2 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1714 {
1715   return __surfModeSwitch(surf, x, y, layer, mode, l2);
1716 }
1717
1718 #if !defined(__LP64__)
1719
1720 template<>
1721 __forceinline__ __device__ long int surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1722 {
1723   return (long int)__surfModeSwitch(surf, x, y, layer, mode, u1).x;
1724 }
1725
1726 template<>
1727 __forceinline__ __device__ unsigned long int surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1728 {
1729   return (unsigned long int)__surfModeSwitch(surf, x, y, layer, mode, u1).x;
1730 }
1731
1732 template<>
1733 __forceinline__ __device__ long1 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1734 {
1735   return make_long1((long int)__surfModeSwitch(surf, x, y, layer, mode, u1).x);
1736 }
1737
1738 template<>
1739 __forceinline__ __device__ ulong1 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1740 {
1741   return make_ulong1((unsigned long int)__surfModeSwitch(surf, x, y, layer, mode, u1).x);
1742 }
1743
1744 template<>
1745 __forceinline__ __device__ long2 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1746 {
1747   uint2 tmp = __surfModeSwitch(surf, x, y, layer, mode, u2);
1748
1749   return make_long2((long int)tmp.x, (long int)tmp.y);
1750 }
1751
1752 template<>
1753 __forceinline__ __device__ ulong2 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1754 {
1755   uint2 tmp = __surfModeSwitch(surf, x, y, layer, mode, u2);
1756
1757   return make_ulong2((unsigned long int)tmp.x, (unsigned long int)tmp.y);
1758 }
1759
1760 template<>
1761 __forceinline__ __device__ long4 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1762 {
1763   uint4 tmp = __surfModeSwitch(surf, x, y, layer, mode, u4);
1764
1765   return make_long4((long int)tmp.x, (long int)tmp.y, (long int)tmp.z, (long int)tmp.w);
1766 }
1767
1768 template<>
1769 __forceinline__ __device__ ulong4 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1770 {
1771   uint4 tmp = __surfModeSwitch(surf, x, y, layer, mode, u4);
1772
1773   return make_ulong4((unsigned long int)tmp.x, (unsigned long int)tmp.y, (unsigned long int)tmp.z, (unsigned long int)tmp.w);
1774 }
1775
1776 #endif /* !__LP64__ */
1777
1778 template<>
1779 __forceinline__ __device__ float surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1780 {
1781   return __int_as_float((int)__surfModeSwitch(surf, x, y, layer, mode, u1).x);
1782 }
1783
1784 template<>
1785 __forceinline__ __device__ float1 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1786 {
1787   return make_float1(__int_as_float((int)__surfModeSwitch(surf, x, y, layer, mode, u1).x));
1788 }
1789
1790 template<>
1791 __forceinline__ __device__ float2 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1792 {
1793   uint2 tmp = __surfModeSwitch(surf, x, y, layer, mode, u2);
1794
1795   return make_float2(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y));
1796 }
1797
1798 template<>
1799 __forceinline__ __device__ float4 surf2DLayeredread(surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
1800 {
1801   uint4 tmp = __surfModeSwitch(surf, x, y, layer, mode, u4);
1802
1803   return make_float4(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y), __int_as_float((int)tmp.z), __int_as_float((int)tmp.w));
1804 }
1805
1806 #undef __surfModeSwitch
1807
1808 /*******************************************************************************
1809 *                                                                              *
1810 *                                                                              *
1811 *                                                                              *
1812 *******************************************************************************/
1813 extern __device__ __device_builtin__ uchar1     __surfCubemapreadc1(surface<void, cudaSurfaceTypeCubemap> t, int x, int y, int face, enum cudaSurfaceBoundaryMode mode);
1814 extern __device__ __device_builtin__ uchar2     __surfCubemapreadc2(surface<void, cudaSurfaceTypeCubemap> t, int x, int y, int face, enum cudaSurfaceBoundaryMode mode);
1815 extern __device__ __device_builtin__ uchar4     __surfCubemapreadc4(surface<void, cudaSurfaceTypeCubemap> t, int x, int y, int face, enum cudaSurfaceBoundaryMode mode);
1816 extern __device__ __device_builtin__ ushort1    __surfCubemapreads1(surface<void, cudaSurfaceTypeCubemap> t, int x, int y, int face, enum cudaSurfaceBoundaryMode mode);
1817 extern __device__ __device_builtin__ ushort2    __surfCubemapreads2(surface<void, cudaSurfaceTypeCubemap> t, int x, int y, int face, enum cudaSurfaceBoundaryMode mode);
1818 extern __device__ __device_builtin__ ushort4    __surfCubemapreads4(surface<void, cudaSurfaceTypeCubemap> t, int x, int y, int face, enum cudaSurfaceBoundaryMode mode);
1819 extern __device__ __device_builtin__ uint1      __surfCubemapreadu1(surface<void, cudaSurfaceTypeCubemap> t, int x, int y, int face, enum cudaSurfaceBoundaryMode mode);
1820 extern __device__ __device_builtin__ uint2      __surfCubemapreadu2(surface<void, cudaSurfaceTypeCubemap> t, int x, int y, int face, enum cudaSurfaceBoundaryMode mode);
1821 extern __device__ __device_builtin__ uint4      __surfCubemapreadu4(surface<void, cudaSurfaceTypeCubemap> t, int x, int y, int face, enum cudaSurfaceBoundaryMode mode);
1822 extern __device__ __device_builtin__ ulonglong1 __surfCubemapreadl1(surface<void, cudaSurfaceTypeCubemap> t, int x, int y, int face, enum cudaSurfaceBoundaryMode mode);
1823 extern __device__ __device_builtin__ ulonglong2 __surfCubemapreadl2(surface<void, cudaSurfaceTypeCubemap> t, int x, int y, int face, enum cudaSurfaceBoundaryMode mode);
1824
1825 #if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 200
1826
1827 #define __surfModeSwitch(surf, x, y, face, mode, type)                                                   \
1828         ((mode == cudaBoundaryModeZero)  ? __surfCubemapread##type(surf, x, y, face, cudaBoundaryModeZero ) : \
1829          (mode == cudaBoundaryModeClamp) ? __surfCubemapread##type(surf, x, y, face, cudaBoundaryModeClamp) : \
1830                                            __surfCubemapread##type(surf, x, y, face, cudaBoundaryModeTrap ))
1831
1832 #else /* CUDA_ARCH && __CUDA_ARCH__ >= 200 */
1833
1834 #define __surfModeSwitch(surf, x, y, face, mode, type) \
1835          __surfCubemapread##type(surf, x, y, face, cudaBoundaryModeTrap)
1836
1837 #endif /* CUDA_ARCH && __CUDA_ARCH__ >= 200 */
1838
1839 template<class T>
1840 static __forceinline__ __device__ void surfCubemapread(T *res, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
1841 {
1842   (s ==  1) ? (void)(*(uchar1 *)res = __surfModeSwitch(surf, x, y, face, mode, c1)) :
1843   (s ==  2) ? (void)(*(ushort1*)res = __surfModeSwitch(surf, x, y, face, mode, s1)) :
1844   (s ==  4) ? (void)(*(uint1  *)res = __surfModeSwitch(surf, x, y, face, mode, u1)) :
1845   (s ==  8) ? (void)(*(uint2  *)res = __surfModeSwitch(surf, x, y, face, mode, u2)) :
1846   (s == 16) ? (void)(*(uint4  *)res = __surfModeSwitch(surf, x, y, face, mode, u4)) :
1847               (void)0;
1848 }
1849
1850 template<class T>
1851 static __forceinline__ __device__ T surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
1852 {
1853   T tmp;
1854
1855   surfCubemapread(&tmp, surf, x, y, face, (int)sizeof(T), mode);
1856
1857   return tmp;
1858 }
1859
1860 template<class T>
1861 static __forceinline__ __device__ void surfCubemapread(T *res, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
1862 {
1863   *res = surfCubemapread<T>(surf, x, y, face, mode);
1864 }
1865
1866 template<>
1867 __forceinline__ __device__ char surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
1868 {
1869   return (char)__surfModeSwitch(surf, x, y, face, mode, c1).x;
1870 }
1871
1872 template<>
1873 __forceinline__ __device__ signed char surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
1874 {
1875   return (signed char)__surfModeSwitch(surf, x, y, face, mode, c1).x;
1876 }
1877
1878 template<>
1879 __forceinline__ __device__ unsigned char surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
1880 {
1881   return __surfModeSwitch(surf, x, y, face, mode, c1).x;
1882 }
1883
1884 template<>
1885 __forceinline__ __device__ char1 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
1886 {
1887   return make_char1((signed char)__surfModeSwitch(surf, x, y, face, mode, c1).x);
1888 }
1889
1890 template<>
1891 __forceinline__ __device__ uchar1 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
1892 {
1893   return __surfModeSwitch(surf, x, y, face, mode, c1);
1894 }
1895
1896 template<>
1897 __forceinline__ __device__ char2 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
1898 {
1899   uchar2 tmp = __surfModeSwitch(surf, x, y, face, mode, c2);
1900
1901   return make_char2((signed char)tmp.x, (signed char)tmp.y);
1902 }
1903
1904 template<>
1905 __forceinline__ __device__ uchar2 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
1906 {
1907   return __surfModeSwitch(surf, x, y, face, mode, c2);
1908 }
1909
1910 template<>
1911 __forceinline__ __device__ char4 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
1912 {
1913   uchar4 tmp = __surfModeSwitch(surf, x, y, face, mode, c4);
1914
1915   return make_char4((signed char)tmp.x, (signed char)tmp.y, (signed char)tmp.z, (signed char)tmp.w);
1916 }
1917
1918 template<>
1919 __forceinline__ __device__ uchar4 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
1920 {
1921   return __surfModeSwitch(surf, x, y, face, mode, c4);
1922 }
1923
1924 template<>
1925 __forceinline__ __device__ short surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
1926 {
1927   return (short)__surfModeSwitch(surf, x, y, face, mode, s1).x;
1928 }
1929
1930 template<>
1931 __forceinline__ __device__ unsigned short surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
1932 {
1933   return __surfModeSwitch(surf, x, y, face, mode, s1).x;
1934 }
1935
1936 template<>
1937 __forceinline__ __device__ short1 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
1938 {
1939   return make_short1((signed short)__surfModeSwitch(surf, x, y, face, mode, s1).x);
1940 }
1941
1942 template<>
1943 __forceinline__ __device__ ushort1 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
1944 {
1945   return __surfModeSwitch(surf, x, y, face, mode, s1);
1946 }
1947
1948 template<>
1949 __forceinline__ __device__ short2 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
1950 {
1951   ushort2 tmp = __surfModeSwitch(surf, x, y, face, mode, s2);
1952
1953   return make_short2((signed short)tmp.x, (signed short)tmp.y);
1954 }
1955
1956 template<>
1957 __forceinline__ __device__ ushort2 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
1958 {
1959   return __surfModeSwitch(surf, x, y, face, mode, s2);
1960 }
1961
1962 template<>
1963 __forceinline__ __device__ short4 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
1964 {
1965   ushort4 tmp = __surfModeSwitch(surf, x, y, face, mode, s4);
1966
1967   return make_short4((signed short)tmp.x, (signed short)tmp.y, (signed short)tmp.z, (signed short)tmp.w);
1968 }
1969
1970 template<>
1971 __forceinline__ __device__ ushort4 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
1972 {
1973   return __surfModeSwitch(surf, x, y, face, mode, s4);
1974 }
1975
1976 template<>
1977 __forceinline__ __device__ int surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
1978 {
1979   return (int)__surfModeSwitch(surf, x, y, face, mode, u1).x;
1980 }
1981
1982 template<>
1983 __forceinline__ __device__ unsigned int surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
1984 {
1985   return __surfModeSwitch(surf, x, y, face, mode, u1).x;
1986 }
1987
1988 template<>
1989 __forceinline__ __device__ int1 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
1990 {
1991   return make_int1((signed int)__surfModeSwitch(surf, x, y, face, mode, u1).x);
1992 }
1993
1994 template<>
1995 __forceinline__ __device__ uint1 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
1996 {
1997   return __surfModeSwitch(surf, x, y, face, mode, u1);
1998 }
1999
2000 template<>
2001 __forceinline__ __device__ int2 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
2002 {
2003   uint2 tmp = __surfModeSwitch(surf, x, y, face, mode, u2);
2004
2005   return make_int2((int)tmp.x, (int)tmp.y);
2006 }
2007
2008 template<>
2009 __forceinline__ __device__ uint2 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
2010 {
2011   return __surfModeSwitch(surf, x, y, face, mode, u2);
2012 }
2013
2014 template<>
2015 __forceinline__ __device__ int4 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
2016 {
2017   uint4 tmp = __surfModeSwitch(surf, x, y, face, mode, u4);
2018
2019   return make_int4((int)tmp.x, (int)tmp.y, (int)tmp.z, (int)tmp.w);
2020 }
2021
2022 template<>
2023 __forceinline__ __device__ uint4 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
2024 {
2025   return __surfModeSwitch(surf, x, y, face, mode, u4);
2026 }
2027
2028 template<>
2029 __forceinline__ __device__ long long int surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
2030 {
2031   return (long long int)__surfModeSwitch(surf, x, y, face, mode, l1).x;
2032 }
2033
2034 template<>
2035 __forceinline__ __device__ unsigned long long int surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
2036 {
2037   return __surfModeSwitch(surf, x, y, face, mode, l1).x;
2038 }
2039
2040 template<>
2041 __forceinline__ __device__ longlong1 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
2042 {
2043   return make_longlong1((long long int)__surfModeSwitch(surf, x, y, face, mode, l1).x);
2044 }
2045
2046 template<>
2047 __forceinline__ __device__ ulonglong1 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
2048 {
2049   return __surfModeSwitch(surf, x, y, face, mode, l1);
2050 }
2051
2052 template<>
2053 __forceinline__ __device__ longlong2 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
2054 {
2055   ulonglong2 tmp = __surfModeSwitch(surf, x, y, face, mode, l2);
2056
2057   return make_longlong2((long long int)tmp.x, (long long int)tmp.y);
2058 }
2059
2060 template<>
2061 __forceinline__ __device__ ulonglong2 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
2062 {
2063   return __surfModeSwitch(surf, x, y, face, mode, l2);
2064 }
2065
2066 #if !defined(__LP64__)
2067
2068 template<>
2069 __forceinline__ __device__ long int surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
2070 {
2071   return (long int)__surfModeSwitch(surf, x, y, face, mode, u1).x;
2072 }
2073
2074 template<>
2075 __forceinline__ __device__ unsigned long int surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
2076 {
2077   return (unsigned long int)__surfModeSwitch(surf, x, y, face, mode, u1).x;
2078 }
2079
2080 template<>
2081 __forceinline__ __device__ long1 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
2082 {
2083   return make_long1((long int)__surfModeSwitch(surf, x, y, face, mode, u1).x);
2084 }
2085
2086 template<>
2087 __forceinline__ __device__ ulong1 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
2088 {
2089   return make_ulong1((unsigned long int)__surfModeSwitch(surf, x, y, face, mode, u1).x);
2090 }
2091
2092 template<>
2093 __forceinline__ __device__ long2 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
2094 {
2095   uint2 tmp = __surfModeSwitch(surf, x, y, face, mode, u2);
2096
2097   return make_long2((long int)tmp.x, (long int)tmp.y);
2098 }
2099
2100 template<>
2101 __forceinline__ __device__ ulong2 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
2102 {
2103   uint2 tmp = __surfModeSwitch(surf, x, y, face, mode, u2);
2104
2105   return make_ulong2((unsigned long int)tmp.x, (unsigned long int)tmp.y);
2106 }
2107
2108 template<>
2109 __forceinline__ __device__ long4 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
2110 {
2111   uint4 tmp = __surfModeSwitch(surf, x, y, face, mode, u4);
2112
2113   return make_long4((long int)tmp.x, (long int)tmp.y, (long int)tmp.z, (long int)tmp.w);
2114 }
2115
2116 template<>
2117 __forceinline__ __device__ ulong4 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
2118 {
2119   uint4 tmp = __surfModeSwitch(surf, x, y, face, mode, u4);
2120
2121   return make_ulong4((unsigned long int)tmp.x, (unsigned long int)tmp.y, (unsigned long int)tmp.z, (unsigned long int)tmp.w);
2122 }
2123
2124 #endif /* !__LP64__ */
2125
2126 template<>
2127 __forceinline__ __device__ float surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
2128 {
2129   return __int_as_float((int)__surfModeSwitch(surf, x, y, face, mode, u1).x);
2130 }
2131
2132 template<>
2133 __forceinline__ __device__ float1 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
2134 {
2135   return make_float1(__int_as_float((int)__surfModeSwitch(surf, x, y, face, mode, u1).x));
2136 }
2137
2138 template<>
2139 __forceinline__ __device__ float2 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
2140 {
2141   uint2 tmp = __surfModeSwitch(surf, x, y, face, mode, u2);
2142
2143   return make_float2(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y));
2144 }
2145
2146 template<>
2147 __forceinline__ __device__ float4 surfCubemapread(surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
2148 {
2149   uint4 tmp = __surfModeSwitch(surf, x, y, face, mode, u4);
2150
2151   return make_float4(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y), __int_as_float((int)tmp.z), __int_as_float((int)tmp.w));
2152 }
2153
2154 #undef __surfModeSwitch
2155
2156 /*******************************************************************************
2157 *                                                                              *
2158 *                                                                              *
2159 *                                                                              *
2160 *******************************************************************************/
2161 extern __device__ __device_builtin__ uchar1     __surfCubemapLayeredreadc1(surface<void, cudaSurfaceTypeCubemapLayered> t, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode);
2162 extern __device__ __device_builtin__ uchar2     __surfCubemapLayeredreadc2(surface<void, cudaSurfaceTypeCubemapLayered> t, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode);
2163 extern __device__ __device_builtin__ uchar4     __surfCubemapLayeredreadc4(surface<void, cudaSurfaceTypeCubemapLayered> t, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode);
2164 extern __device__ __device_builtin__ ushort1    __surfCubemapLayeredreads1(surface<void, cudaSurfaceTypeCubemapLayered> t, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode);
2165 extern __device__ __device_builtin__ ushort2    __surfCubemapLayeredreads2(surface<void, cudaSurfaceTypeCubemapLayered> t, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode);
2166 extern __device__ __device_builtin__ ushort4    __surfCubemapLayeredreads4(surface<void, cudaSurfaceTypeCubemapLayered> t, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode);
2167 extern __device__ __device_builtin__ uint1      __surfCubemapLayeredreadu1(surface<void, cudaSurfaceTypeCubemapLayered> t, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode);
2168 extern __device__ __device_builtin__ uint2      __surfCubemapLayeredreadu2(surface<void, cudaSurfaceTypeCubemapLayered> t, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode);
2169 extern __device__ __device_builtin__ uint4      __surfCubemapLayeredreadu4(surface<void, cudaSurfaceTypeCubemapLayered> t, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode);
2170 extern __device__ __device_builtin__ ulonglong1 __surfCubemapLayeredreadl1(surface<void, cudaSurfaceTypeCubemapLayered> t, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode);
2171 extern __device__ __device_builtin__ ulonglong2 __surfCubemapLayeredreadl2(surface<void, cudaSurfaceTypeCubemapLayered> t, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode);
2172
2173 #if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 200
2174
2175 #define __surfModeSwitch(surf, x, y, layerFace, mode, type)                                                   \
2176         ((mode == cudaBoundaryModeZero)  ? __surfCubemapLayeredread##type(surf, x, y, layerFace, cudaBoundaryModeZero ) : \
2177          (mode == cudaBoundaryModeClamp) ? __surfCubemapLayeredread##type(surf, x, y, layerFace, cudaBoundaryModeClamp) : \
2178                                            __surfCubemapLayeredread##type(surf, x, y, layerFace, cudaBoundaryModeTrap ))
2179
2180 #else /* CUDA_ARCH && __CUDA_ARCH__ >= 200 */
2181
2182 #define __surfModeSwitch(surf, x, y, layerFace, mode, type) \
2183          __surfCubemapLayeredread##type(surf, x, y, layerFace, cudaBoundaryModeTrap)
2184
2185
2186 #endif /* CUDA_ARCH && __CUDA_ARCH__ >= 200 */
2187
2188 template<class T>
2189 static __forceinline__ __device__ void surfCubemapLayeredread(T *res, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2190 {
2191   (s ==  1) ? (void)(*(uchar1 *)res = __surfModeSwitch(surf, x, y, layerFace, mode, c1)) :
2192   (s ==  2) ? (void)(*(ushort1*)res = __surfModeSwitch(surf, x, y, layerFace, mode, s1)) :
2193   (s ==  4) ? (void)(*(uint1  *)res = __surfModeSwitch(surf, x, y, layerFace, mode, u1)) :
2194   (s ==  8) ? (void)(*(uint2  *)res = __surfModeSwitch(surf, x, y, layerFace, mode, u2)) :
2195   (s == 16) ? (void)(*(uint4  *)res = __surfModeSwitch(surf, x, y, layerFace, mode, u4)) :
2196               (void)0;
2197 }
2198
2199 template<class T>
2200 static __forceinline__ __device__ T surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2201 {
2202   T tmp;
2203
2204   surfCubemapLayeredread(&tmp, surf, x, y, layerFace, (int)sizeof(T), mode);
2205
2206   return tmp;
2207 }
2208
2209 template<class T>
2210 static __forceinline__ __device__ void surfCubemapLayeredread(T *res, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2211 {
2212   *res = surfCubemapLayeredread<T>(surf, x, y, layerFace, mode);
2213 }
2214
2215 template<>
2216 __forceinline__ __device__ char surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2217 {
2218   return (char)__surfModeSwitch(surf, x, y, layerFace, mode, c1).x;
2219 }
2220
2221 template<>
2222 __forceinline__ __device__ signed char surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2223 {
2224   return (signed char)__surfModeSwitch(surf, x, y, layerFace, mode, c1).x;
2225 }
2226
2227 template<>
2228 __forceinline__ __device__ unsigned char surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2229 {
2230   return __surfModeSwitch(surf, x, y, layerFace, mode, c1).x;
2231 }
2232
2233 template<>
2234 __forceinline__ __device__ char1 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2235 {
2236   return make_char1((signed char)__surfModeSwitch(surf, x, y, layerFace, mode, c1).x);
2237 }
2238
2239 template<>
2240 __forceinline__ __device__ uchar1 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2241 {
2242   return __surfModeSwitch(surf, x, y, layerFace, mode, c1);
2243 }
2244
2245 template<>
2246 __forceinline__ __device__ char2 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2247 {
2248   uchar2 tmp = __surfModeSwitch(surf, x, y, layerFace, mode, c2);
2249
2250   return make_char2((signed char)tmp.x, (signed char)tmp.y);
2251 }
2252
2253 template<>
2254 __forceinline__ __device__ uchar2 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2255 {
2256   return __surfModeSwitch(surf, x, y, layerFace, mode, c2);
2257 }
2258
2259 template<>
2260 __forceinline__ __device__ char4 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2261 {
2262   uchar4 tmp = __surfModeSwitch(surf, x, y, layerFace, mode, c4);
2263
2264   return make_char4((signed char)tmp.x, (signed char)tmp.y, (signed char)tmp.z, (signed char)tmp.w);
2265 }
2266
2267 template<>
2268 __forceinline__ __device__ uchar4 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2269 {
2270   return __surfModeSwitch(surf, x, y, layerFace, mode, c4);
2271 }
2272
2273 template<>
2274 __forceinline__ __device__ short surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2275 {
2276   return (short)__surfModeSwitch(surf, x, y, layerFace, mode, s1).x;
2277 }
2278
2279 template<>
2280 __forceinline__ __device__ unsigned short surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2281 {
2282   return __surfModeSwitch(surf, x, y, layerFace, mode, s1).x;
2283 }
2284
2285 template<>
2286 __forceinline__ __device__ short1 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2287 {
2288   return make_short1((signed short)__surfModeSwitch(surf, x, y, layerFace, mode, s1).x);
2289 }
2290
2291 template<>
2292 __forceinline__ __device__ ushort1 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2293 {
2294   return __surfModeSwitch(surf, x, y, layerFace, mode, s1);
2295 }
2296
2297 template<>
2298 __forceinline__ __device__ short2 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2299 {
2300   ushort2 tmp = __surfModeSwitch(surf, x, y, layerFace, mode, s2);
2301
2302   return make_short2((signed short)tmp.x, (signed short)tmp.y);
2303 }
2304
2305 template<>
2306 __forceinline__ __device__ ushort2 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2307 {
2308   return __surfModeSwitch(surf, x, y, layerFace, mode, s2);
2309 }
2310
2311 template<>
2312 __forceinline__ __device__ short4 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2313 {
2314   ushort4 tmp = __surfModeSwitch(surf, x, y, layerFace, mode, s4);
2315
2316   return make_short4((signed short)tmp.x, (signed short)tmp.y, (signed short)tmp.z, (signed short)tmp.w);
2317 }
2318
2319 template<>
2320 __forceinline__ __device__ ushort4 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2321 {
2322   return __surfModeSwitch(surf, x, y, layerFace, mode, s4);
2323 }
2324
2325 template<>
2326 __forceinline__ __device__ int surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2327 {
2328   return (int)__surfModeSwitch(surf, x, y, layerFace, mode, u1).x;
2329 }
2330
2331 template<>
2332 __forceinline__ __device__ unsigned int surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2333 {
2334   return __surfModeSwitch(surf, x, y, layerFace, mode, u1).x;
2335 }
2336
2337 template<>
2338 __forceinline__ __device__ int1 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2339 {
2340   return make_int1((signed int)__surfModeSwitch(surf, x, y, layerFace, mode, u1).x);
2341 }
2342
2343 template<>
2344 __forceinline__ __device__ uint1 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2345 {
2346   return __surfModeSwitch(surf, x, y, layerFace, mode, u1);
2347 }
2348
2349 template<>
2350 __forceinline__ __device__ int2 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2351 {
2352   uint2 tmp = __surfModeSwitch(surf, x, y, layerFace, mode, u2);
2353
2354   return make_int2((int)tmp.x, (int)tmp.y);
2355 }
2356
2357 template<>
2358 __forceinline__ __device__ uint2 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2359 {
2360   return __surfModeSwitch(surf, x, y, layerFace, mode, u2);
2361 }
2362
2363 template<>
2364 __forceinline__ __device__ int4 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2365 {
2366   uint4 tmp = __surfModeSwitch(surf, x, y, layerFace, mode, u4);
2367
2368   return make_int4((int)tmp.x, (int)tmp.y, (int)tmp.z, (int)tmp.w);
2369 }
2370
2371 template<>
2372 __forceinline__ __device__ uint4 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2373 {
2374   return __surfModeSwitch(surf, x, y, layerFace, mode, u4);
2375 }
2376
2377 template<>
2378 __forceinline__ __device__ long long int surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2379 {
2380   return (long long int)__surfModeSwitch(surf, x, y, layerFace, mode, l1).x;
2381 }
2382
2383 template<>
2384 __forceinline__ __device__ unsigned long long int surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2385 {
2386   return __surfModeSwitch(surf, x, y, layerFace, mode, l1).x;
2387 }
2388
2389 template<>
2390 __forceinline__ __device__ longlong1 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2391 {
2392   return make_longlong1((long long int)__surfModeSwitch(surf, x, y, layerFace, mode, l1).x);
2393 }
2394
2395 template<>
2396 __forceinline__ __device__ ulonglong1 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2397 {
2398   return __surfModeSwitch(surf, x, y, layerFace, mode, l1);
2399 }
2400
2401 template<>
2402 __forceinline__ __device__ longlong2 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2403 {
2404   ulonglong2 tmp = __surfModeSwitch(surf, x, y, layerFace, mode, l2);
2405
2406   return make_longlong2((long long int)tmp.x, (long long int)tmp.y);
2407 }
2408
2409 template<>
2410 __forceinline__ __device__ ulonglong2 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2411 {
2412   return __surfModeSwitch(surf, x, y, layerFace, mode, l2);
2413 }
2414
2415 #if !defined(__LP64__)
2416
2417 template<>
2418 __forceinline__ __device__ long int surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2419 {
2420   return (long int)__surfModeSwitch(surf, x, y, layerFace, mode, u1).x;
2421 }
2422
2423 template<>
2424 __forceinline__ __device__ unsigned long int surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2425 {
2426   return (unsigned long int)__surfModeSwitch(surf, x, y, layerFace, mode, u1).x;
2427 }
2428
2429 template<>
2430 __forceinline__ __device__ long1 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2431 {
2432   return make_long1((long int)__surfModeSwitch(surf, x, y, layerFace, mode, u1).x);
2433 }
2434
2435 template<>
2436 __forceinline__ __device__ ulong1 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2437 {
2438   return make_ulong1((unsigned long int)__surfModeSwitch(surf, x, y, layerFace, mode, u1).x);
2439 }
2440
2441 template<>
2442 __forceinline__ __device__ long2 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2443 {
2444   uint2 tmp = __surfModeSwitch(surf, x, y, layerFace, mode, u2);
2445
2446   return make_long2((long int)tmp.x, (long int)tmp.y);
2447 }
2448
2449 template<>
2450 __forceinline__ __device__ ulong2 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2451 {
2452   uint2 tmp = __surfModeSwitch(surf, x, y, layerFace, mode, u2);
2453
2454   return make_ulong2((unsigned long int)tmp.x, (unsigned long int)tmp.y);
2455 }
2456
2457 template<>
2458 __forceinline__ __device__ long4 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2459 {
2460   uint4 tmp = __surfModeSwitch(surf, x, y, layerFace, mode, u4);
2461
2462   return make_long4((long int)tmp.x, (long int)tmp.y, (long int)tmp.z, (long int)tmp.w);
2463 }
2464
2465 template<>
2466 __forceinline__ __device__ ulong4 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2467 {
2468   uint4 tmp = __surfModeSwitch(surf, x, y, layerFace, mode, u4);
2469
2470   return make_ulong4((unsigned long int)tmp.x, (unsigned long int)tmp.y, (unsigned long int)tmp.z, (unsigned long int)tmp.w);
2471 }
2472
2473 #endif /* !__LP64__ */
2474
2475 template<>
2476 __forceinline__ __device__ float surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2477 {
2478   return __int_as_float((int)__surfModeSwitch(surf, x, y, layerFace, mode, u1).x);
2479 }
2480
2481 template<>
2482 __forceinline__ __device__ float1 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2483 {
2484   return make_float1(__int_as_float((int)__surfModeSwitch(surf, x, y, layerFace, mode, u1).x));
2485 }
2486
2487 template<>
2488 __forceinline__ __device__ float2 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2489 {
2490   uint2 tmp = __surfModeSwitch(surf, x, y, layerFace, mode, u2);
2491
2492   return make_float2(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y));
2493 }
2494
2495 template<>
2496 __forceinline__ __device__ float4 surfCubemapLayeredread(surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
2497 {
2498   uint4 tmp = __surfModeSwitch(surf, x, y, layerFace, mode, u4);
2499
2500   return make_float4(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y), __int_as_float((int)tmp.z), __int_as_float((int)tmp.w));
2501 }
2502
2503 #undef __surfModeSwitch
2504
2505 /*******************************************************************************
2506 *                                                                              *
2507 *                                                                              *
2508 *                                                                              *
2509 *******************************************************************************/
2510
2511 extern __device__ __device_builtin__ void __surf1Dwritec1(    uchar1 val, surface<void, cudaSurfaceType1D> t, int x, enum cudaSurfaceBoundaryMode mode);
2512 extern __device__ __device_builtin__ void __surf1Dwritec2(    uchar2 val, surface<void, cudaSurfaceType1D> t, int x, enum cudaSurfaceBoundaryMode mode);
2513 extern __device__ __device_builtin__ void __surf1Dwritec4(    uchar4 val, surface<void, cudaSurfaceType1D> t, int x, enum cudaSurfaceBoundaryMode mode);
2514 extern __device__ __device_builtin__ void __surf1Dwrites1(   ushort1 val, surface<void, cudaSurfaceType1D> t, int x, enum cudaSurfaceBoundaryMode mode);
2515 extern __device__ __device_builtin__ void __surf1Dwrites2(   ushort2 val, surface<void, cudaSurfaceType1D> t, int x, enum cudaSurfaceBoundaryMode mode);
2516 extern __device__ __device_builtin__ void __surf1Dwrites4(   ushort4 val, surface<void, cudaSurfaceType1D> t, int x, enum cudaSurfaceBoundaryMode mode);
2517 extern __device__ __device_builtin__ void __surf1Dwriteu1(     uint1 val, surface<void, cudaSurfaceType1D> t, int x, enum cudaSurfaceBoundaryMode mode);
2518 extern __device__ __device_builtin__ void __surf1Dwriteu2(     uint2 val, surface<void, cudaSurfaceType1D> t, int x, enum cudaSurfaceBoundaryMode mode);
2519 extern __device__ __device_builtin__ void __surf1Dwriteu4(     uint4 val, surface<void, cudaSurfaceType1D> t, int x, enum cudaSurfaceBoundaryMode mode);
2520 extern __device__ __device_builtin__ void __surf1Dwritel1(ulonglong1 val, surface<void, cudaSurfaceType1D> t, int x, enum cudaSurfaceBoundaryMode mode);
2521 extern __device__ __device_builtin__ void __surf1Dwritel2(ulonglong2 val, surface<void, cudaSurfaceType1D> t, int x, enum cudaSurfaceBoundaryMode mode);
2522
2523 #if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 200
2524
2525 #define __surfModeSwitch(val, surf, x, mode, type)                                                    \
2526         ((mode == cudaBoundaryModeZero)  ? __surf1Dwrite##type(val, surf, x, cudaBoundaryModeZero ) : \
2527          (mode == cudaBoundaryModeClamp) ? __surf1Dwrite##type(val, surf, x, cudaBoundaryModeClamp) : \
2528                                            __surf1Dwrite##type(val, surf, x, cudaBoundaryModeTrap ))
2529
2530 #else /* __CUDA_ARCH__ && __CUDA_ARCH__ >= 200 */
2531
2532 #define __surfModeSwitch(val, surf, x, mode, type) \
2533         __surf1Dwrite##type(val, surf, x, cudaBoundaryModeTrap)
2534
2535 #endif /* __CUDA_ARCH__ && __CUDA_ARCH__ >= 200 */
2536
2537 template<class T>
2538 static __forceinline__ __device__ void surf1Dwrite(T val, surface<void, cudaSurfaceType1D> surf, int x, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2539 {
2540   union {
2541     T       val;
2542     uchar1  c1;
2543     ushort1 s1;
2544     uint1   u1;
2545     uint2   u2;
2546     uint4   u4;
2547   } tmp;
2548
2549   tmp.val = val;
2550
2551   (s ==  1) ? (void)(__surfModeSwitch(tmp.c1, surf, x, mode, c1)) :
2552   (s ==  2) ? (void)(__surfModeSwitch(tmp.s1, surf, x, mode, s1)) :
2553   (s ==  4) ? (void)(__surfModeSwitch(tmp.u1, surf, x, mode, u1)) :
2554   (s ==  8) ? (void)(__surfModeSwitch(tmp.u2, surf, x, mode, u2)) :
2555   (s == 16) ? (void)(__surfModeSwitch(tmp.u4, surf, x, mode, u4)) :
2556               (void)0;
2557 }
2558
2559 template<class T>
2560 static __forceinline__ __device__ void surf1Dwrite(T val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2561 {;
2562   surf1Dwrite(val, surf, x, (int)sizeof(T), mode);
2563 }
2564
2565
2566 static __forceinline__ __device__ void surf1Dwrite(char val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2567 {
2568   __surfModeSwitch(make_uchar1((unsigned char)val), surf, x, mode, c1);
2569 }
2570
2571 static __forceinline__ __device__ void surf1Dwrite(signed char val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2572 {
2573   __surfModeSwitch(make_uchar1((unsigned char)val), surf, x, mode, c1);
2574 }
2575
2576 static __forceinline__ __device__ void surf1Dwrite(unsigned char val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2577 {
2578   __surfModeSwitch(make_uchar1(val), surf, x, mode, c1);
2579 }
2580
2581 static __forceinline__ __device__ void surf1Dwrite(char1 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2582 {
2583   __surfModeSwitch(make_uchar1((unsigned char)val.x), surf, x, mode, c1);
2584 }
2585
2586 static __forceinline__ __device__ void surf1Dwrite(uchar1 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2587 {
2588   __surfModeSwitch(val, surf, x, mode, c1);
2589 }
2590
2591 static __forceinline__ __device__ void surf1Dwrite(char2 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2592 {
2593   __surfModeSwitch(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, mode, c2);
2594 }
2595
2596 static __forceinline__ __device__ void surf1Dwrite(uchar2 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2597 {
2598   __surfModeSwitch(val, surf, x, mode, c2);
2599 }
2600
2601 static __forceinline__ __device__ void surf1Dwrite(char4 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2602 {
2603   __surfModeSwitch(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, mode, c4);
2604 }
2605
2606 static __forceinline__ __device__ void surf1Dwrite(uchar4 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2607 {
2608   __surfModeSwitch(val, surf, x, mode, c4);
2609 }
2610
2611 static __forceinline__ __device__ void surf1Dwrite(short val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2612 {
2613   __surfModeSwitch(make_ushort1((unsigned short)val), surf, x, mode, s1);
2614 }
2615
2616 static __forceinline__ __device__ void surf1Dwrite(unsigned short val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2617 {
2618   __surfModeSwitch(make_ushort1(val), surf, x, mode, s1);
2619 }
2620
2621 static __forceinline__ __device__ void surf1Dwrite(short1 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2622 {
2623   __surfModeSwitch(make_ushort1((unsigned short)val.x), surf, x, mode, s1);
2624 }
2625
2626 static __forceinline__ __device__ void surf1Dwrite(ushort1 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2627 {
2628   __surfModeSwitch(val, surf, x, mode, s1);
2629 }
2630
2631 static __forceinline__ __device__ void surf1Dwrite(short2 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2632 {
2633   __surfModeSwitch(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, mode, s2);
2634 }
2635
2636 static __forceinline__ __device__ void surf1Dwrite(ushort2 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2637 {
2638   __surfModeSwitch(val, surf, x, mode, s2);
2639 }
2640
2641 static __forceinline__ __device__ void surf1Dwrite(short4 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2642 {
2643   __surfModeSwitch(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, mode, s4);
2644 }
2645
2646 static __forceinline__ __device__ void surf1Dwrite(ushort4 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2647 {
2648   __surfModeSwitch(val, surf, x, mode, s4);
2649 }
2650
2651 static __forceinline__ __device__ void surf1Dwrite(int val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2652 {
2653   __surfModeSwitch(make_uint1((unsigned int)val), surf, x, mode, u1);
2654 }
2655
2656 static __forceinline__ __device__ void surf1Dwrite(unsigned int val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2657 {
2658   __surfModeSwitch(make_uint1(val), surf, x, mode, u1);
2659 }
2660
2661 static __forceinline__ __device__ void surf1Dwrite(int1 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2662 {
2663   __surfModeSwitch(make_uint1((unsigned int)val.x), surf, x, mode, u1);
2664 }
2665
2666 static __forceinline__ __device__ void surf1Dwrite(uint1 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2667 {
2668   __surfModeSwitch(val, surf, x, mode, u1);
2669 }
2670
2671 static __forceinline__ __device__ void surf1Dwrite(int2 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2672 {
2673   __surfModeSwitch(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, mode, u2);
2674 }
2675
2676 static __forceinline__ __device__ void surf1Dwrite(uint2 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2677 {
2678   __surfModeSwitch(val, surf, x, mode, u2);
2679 }
2680
2681 static __forceinline__ __device__ void surf1Dwrite(int4 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2682 {
2683   __surfModeSwitch(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, mode, u4);
2684 }
2685
2686 static __forceinline__ __device__ void surf1Dwrite(uint4 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2687 {
2688   __surfModeSwitch(val, surf, x, mode, u4);
2689 }
2690
2691 static __forceinline__ __device__ void surf1Dwrite(long long int val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2692 {
2693   __surfModeSwitch(make_ulonglong1((unsigned long long int)val), surf, x, mode, l1);
2694 }
2695
2696 static __forceinline__ __device__ void surf1Dwrite(unsigned long long int val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2697 {
2698   __surfModeSwitch(make_ulonglong1(val), surf, x, mode, l1);
2699 }
2700
2701 static __forceinline__ __device__ void surf1Dwrite(longlong1 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2702 {
2703   __surfModeSwitch(make_ulonglong1((unsigned long long int)val.x), surf, x, mode, l1);
2704 }
2705
2706 static __forceinline__ __device__ void surf1Dwrite(ulonglong1 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2707 {
2708   __surfModeSwitch(val, surf, x, mode, l1);
2709 }
2710
2711 static __forceinline__ __device__ void surf1Dwrite(longlong2 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2712 {
2713   __surfModeSwitch(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, mode, l2);
2714 }
2715
2716 static __forceinline__ __device__ void surf1Dwrite(ulonglong2 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2717 {
2718   __surfModeSwitch(val, surf, x, mode, l2);
2719 }
2720
2721 #if !defined(__LP64__)
2722
2723 static __forceinline__ __device__ void surf1Dwrite(long int val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2724 {
2725   __surfModeSwitch(make_uint1((unsigned int)val), surf, x, mode, u1);
2726 }
2727
2728 static __forceinline__ __device__ void surf1Dwrite(unsigned long int val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2729 {
2730   __surfModeSwitch(make_uint1((unsigned int)val), surf, x, mode, u1);
2731 }
2732
2733 static __forceinline__ __device__ void surf1Dwrite(long1 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2734 {
2735   __surfModeSwitch(make_uint1((unsigned int)val.x), surf, x, mode, u1);
2736 }
2737
2738 static __forceinline__ __device__ void surf1Dwrite(ulong1 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2739 {
2740   __surfModeSwitch(make_uint1((unsigned int)val.x), surf, x, mode, u1);
2741 }
2742
2743 static __forceinline__ __device__ void surf1Dwrite(long2 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2744 {
2745   __surfModeSwitch(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, mode, u2);
2746 }
2747
2748 static __forceinline__ __device__ void surf1Dwrite(ulong2 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2749 {
2750   __surfModeSwitch(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, mode, u2);
2751 }
2752
2753 static __forceinline__ __device__ void surf1Dwrite(long4 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2754 {
2755   __surfModeSwitch(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, mode, u4);
2756 }
2757
2758 static __forceinline__ __device__ void surf1Dwrite(ulong4 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2759 {
2760   __surfModeSwitch(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, mode, u4);
2761 }
2762
2763 #endif /* !__LP64__ */
2764
2765 static __forceinline__ __device__ void surf1Dwrite(float val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2766 {
2767   __surfModeSwitch(make_uint1((unsigned int)__float_as_int(val)), surf, x, mode, u1);
2768 }
2769
2770 static __forceinline__ __device__ void surf1Dwrite(float1 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2771 {
2772   __surfModeSwitch(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, mode, u1);
2773 }
2774
2775 static __forceinline__ __device__ void surf1Dwrite(float2 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2776 {
2777   __surfModeSwitch(make_uint2((unsigned int)__float_as_int(val.x), __float_as_int((unsigned int)val.y)), surf, x, mode, u2);
2778 }
2779
2780 static __forceinline__ __device__ void surf1Dwrite(float4 val, surface<void, cudaSurfaceType1D> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2781 {
2782   __surfModeSwitch(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, mode, u4);
2783 }
2784
2785 #undef __surfModeSwitch
2786
2787 /*******************************************************************************
2788 *                                                                              *
2789 *                                                                              *
2790 *                                                                              *
2791 *******************************************************************************/
2792
2793 extern __device__ __device_builtin__ void __surf2Dwritec1(    uchar1 val, surface<void, cudaSurfaceType2D> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
2794 extern __device__ __device_builtin__ void __surf2Dwritec2(    uchar2 val, surface<void, cudaSurfaceType2D> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
2795 extern __device__ __device_builtin__ void __surf2Dwritec4(    uchar4 val, surface<void, cudaSurfaceType2D> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
2796 extern __device__ __device_builtin__ void __surf2Dwrites1(   ushort1 val, surface<void, cudaSurfaceType2D> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
2797 extern __device__ __device_builtin__ void __surf2Dwrites2(   ushort2 val, surface<void, cudaSurfaceType2D> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
2798 extern __device__ __device_builtin__ void __surf2Dwrites4(   ushort4 val, surface<void, cudaSurfaceType2D> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
2799 extern __device__ __device_builtin__ void __surf2Dwriteu1(     uint1 val, surface<void, cudaSurfaceType2D> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
2800 extern __device__ __device_builtin__ void __surf2Dwriteu2(     uint2 val, surface<void, cudaSurfaceType2D> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
2801 extern __device__ __device_builtin__ void __surf2Dwriteu4(     uint4 val, surface<void, cudaSurfaceType2D> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
2802 extern __device__ __device_builtin__ void __surf2Dwritel1(ulonglong1 val, surface<void, cudaSurfaceType2D> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
2803 extern __device__ __device_builtin__ void __surf2Dwritel2(ulonglong2 val, surface<void, cudaSurfaceType2D> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
2804
2805 #if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 200
2806
2807 #define __surfModeSwitch(val, surf, x, y, mode, type)                                                    \
2808         ((mode == cudaBoundaryModeZero)  ? __surf2Dwrite##type(val, surf, x, y, cudaBoundaryModeZero ) : \
2809          (mode == cudaBoundaryModeClamp) ? __surf2Dwrite##type(val, surf, x, y, cudaBoundaryModeClamp) : \
2810                                            __surf2Dwrite##type(val, surf, x, y, cudaBoundaryModeTrap ))
2811
2812 #else /* __CUDA_ARCH__ && __CUDA_ARCH__ >= 200 */
2813
2814 #define __surfModeSwitch(val, surf, x, y, mode, type) \
2815         __surf2Dwrite##type(val, surf, x, y, cudaBoundaryModeTrap)
2816
2817 #endif /* __CUDA_ARCH__ && __CUDA_ARCH__ >= 200 */
2818
2819 template<class T>
2820 static __forceinline__ __device__ void surf2Dwrite(T val, surface<void, cudaSurfaceType2D> surf, int x, int y, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2821 {
2822   union {
2823     T       val;
2824     uchar1  c1;
2825     ushort1 s1;
2826     uint1   u1;
2827     uint2   u2;
2828     uint4   u4;
2829   } tmp;
2830
2831   tmp.val = val;
2832
2833   (s ==  1) ? (void)(__surfModeSwitch(tmp.c1, surf, x, y, mode, c1)) :
2834   (s ==  2) ? (void)(__surfModeSwitch(tmp.s1, surf, x, y, mode, s1)) :
2835   (s ==  4) ? (void)(__surfModeSwitch(tmp.u1, surf, x, y, mode, u1)) :
2836   (s ==  8) ? (void)(__surfModeSwitch(tmp.u2, surf, x, y, mode, u2)) :
2837   (s == 16) ? (void)(__surfModeSwitch(tmp.u4, surf, x, y, mode, u4)) :
2838               (void)0;
2839 }
2840
2841 template<class T>
2842 static __forceinline__ __device__ void surf2Dwrite(T val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2843 {;
2844   surf2Dwrite(val, surf, x, y, (int)sizeof(T), mode);
2845 }
2846
2847
2848 static __forceinline__ __device__ void surf2Dwrite(char val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2849 {
2850   __surfModeSwitch(make_uchar1((unsigned char)val), surf, x, y, mode, c1);
2851 }
2852
2853 static __forceinline__ __device__ void surf2Dwrite(signed char val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2854 {
2855   __surfModeSwitch(make_uchar1((unsigned char)val), surf, x, y, mode, c1);
2856 }
2857
2858 static __forceinline__ __device__ void surf2Dwrite(unsigned char val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2859 {
2860   __surfModeSwitch(make_uchar1(val), surf, x, y, mode, c1);
2861 }
2862
2863 static __forceinline__ __device__ void surf2Dwrite(char1 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2864 {
2865   __surfModeSwitch(make_uchar1((unsigned char)val.x), surf, x, y, mode, c1);
2866 }
2867
2868 static __forceinline__ __device__ void surf2Dwrite(uchar1 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2869 {
2870   __surfModeSwitch(val, surf, x, y, mode, c1);
2871 }
2872
2873 static __forceinline__ __device__ void surf2Dwrite(char2 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2874 {
2875   __surfModeSwitch(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, y, mode, c2);
2876 }
2877
2878 static __forceinline__ __device__ void surf2Dwrite(uchar2 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2879 {
2880   __surfModeSwitch(val, surf, x, y, mode, c2);
2881 }
2882
2883 static __forceinline__ __device__ void surf2Dwrite(char4 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2884 {
2885   __surfModeSwitch(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, y, mode, c4);
2886 }
2887
2888 static __forceinline__ __device__ void surf2Dwrite(uchar4 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2889 {
2890   __surfModeSwitch(val, surf, x, y, mode, c4);
2891 }
2892
2893 static __forceinline__ __device__ void surf2Dwrite(short val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2894 {
2895   __surfModeSwitch(make_ushort1((unsigned short)val), surf, x, y, mode, s1);
2896 }
2897
2898 static __forceinline__ __device__ void surf2Dwrite(unsigned short val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2899 {
2900   __surfModeSwitch(make_ushort1(val), surf, x, y, mode, s1);
2901 }
2902
2903 static __forceinline__ __device__ void surf2Dwrite(short1 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2904 {
2905   __surfModeSwitch(make_ushort1((unsigned short)val.x), surf, x, y, mode, s1);
2906 }
2907
2908 static __forceinline__ __device__ void surf2Dwrite(ushort1 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2909 {
2910   __surfModeSwitch(val, surf, x, y, mode, s1);
2911 }
2912
2913 static __forceinline__ __device__ void surf2Dwrite(short2 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2914 {
2915   __surfModeSwitch(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, y, mode, s2);
2916 }
2917
2918 static __forceinline__ __device__ void surf2Dwrite(ushort2 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2919 {
2920   __surfModeSwitch(val, surf, x, y, mode, s2);
2921 }
2922
2923 static __forceinline__ __device__ void surf2Dwrite(short4 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2924 {
2925   __surfModeSwitch(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, y, mode, s4);
2926 }
2927
2928 static __forceinline__ __device__ void surf2Dwrite(ushort4 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2929 {
2930   __surfModeSwitch(val, surf, x, y, mode, s4);
2931 }
2932
2933 static __forceinline__ __device__ void surf2Dwrite(int val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2934 {
2935   __surfModeSwitch(make_uint1((unsigned int)val), surf, x, y, mode, u1);
2936 }
2937
2938 static __forceinline__ __device__ void surf2Dwrite(unsigned int val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2939 {
2940   __surfModeSwitch(make_uint1(val), surf, x, y, mode, u1);
2941 }
2942
2943 static __forceinline__ __device__ void surf2Dwrite(int1 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2944 {
2945   __surfModeSwitch(make_uint1((unsigned int)val.x), surf, x, y, mode, u1);
2946 }
2947
2948 static __forceinline__ __device__ void surf2Dwrite(uint1 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2949 {
2950   __surfModeSwitch(val, surf, x, y, mode, u1);
2951 }
2952
2953 static __forceinline__ __device__ void surf2Dwrite(int2 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2954 {
2955   __surfModeSwitch(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, mode, u2);
2956 }
2957
2958 static __forceinline__ __device__ void surf2Dwrite(uint2 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2959 {
2960   __surfModeSwitch(val, surf, x, y, mode, u2);
2961 }
2962
2963 static __forceinline__ __device__ void surf2Dwrite(int4 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2964 {
2965   __surfModeSwitch(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, mode, u4);
2966 }
2967
2968 static __forceinline__ __device__ void surf2Dwrite(uint4 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2969 {
2970   __surfModeSwitch(val, surf, x, y, mode, u4);
2971 }
2972
2973 static __forceinline__ __device__ void surf2Dwrite(long long int val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2974 {
2975   __surfModeSwitch(make_ulonglong1((unsigned long long int)val), surf, x, y, mode, l1);
2976 }
2977
2978 static __forceinline__ __device__ void surf2Dwrite(unsigned long long int val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2979 {
2980   __surfModeSwitch(make_ulonglong1(val), surf, x, y, mode, l1);
2981 }
2982
2983 static __forceinline__ __device__ void surf2Dwrite(longlong1 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2984 {
2985   __surfModeSwitch(make_ulonglong1((unsigned long long int)val.x), surf, x, y, mode, l1);
2986 }
2987
2988 static __forceinline__ __device__ void surf2Dwrite(ulonglong1 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2989 {
2990   __surfModeSwitch(val, surf, x, y, mode, l1);
2991 }
2992
2993 static __forceinline__ __device__ void surf2Dwrite(longlong2 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2994 {
2995   __surfModeSwitch(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, y, mode, l2);
2996 }
2997
2998 static __forceinline__ __device__ void surf2Dwrite(ulonglong2 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
2999 {
3000   __surfModeSwitch(val, surf, x, y, mode, l2);
3001 }
3002
3003 #if !defined(__LP64__)
3004
3005 static __forceinline__ __device__ void surf2Dwrite(long int val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3006 {
3007   __surfModeSwitch(make_uint1((unsigned int)val), surf, x, y, mode, u1);
3008 }
3009
3010 static __forceinline__ __device__ void surf2Dwrite(unsigned long int val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3011 {
3012   __surfModeSwitch(make_uint1((unsigned int)val), surf, x, y, mode, u1);
3013 }
3014
3015 static __forceinline__ __device__ void surf2Dwrite(long1 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3016 {
3017   __surfModeSwitch(make_uint1((unsigned int)val.x), surf, x, y, mode, u1);
3018 }
3019
3020 static __forceinline__ __device__ void surf2Dwrite(ulong1 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3021 {
3022   __surfModeSwitch(make_uint1((unsigned int)val.x), surf, x, y, mode, u1);
3023 }
3024
3025 static __forceinline__ __device__ void surf2Dwrite(long2 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3026 {
3027   __surfModeSwitch(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, mode, u2);
3028 }
3029
3030 static __forceinline__ __device__ void surf2Dwrite(ulong2 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3031 {
3032   __surfModeSwitch(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, mode, u2);
3033 }
3034
3035 static __forceinline__ __device__ void surf2Dwrite(long4 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3036 {
3037   __surfModeSwitch(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, mode, u4);
3038 }
3039
3040 static __forceinline__ __device__ void surf2Dwrite(ulong4 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3041 {
3042   __surfModeSwitch(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, mode, u4);
3043 }
3044
3045 #endif /* !__LP64__ */
3046
3047 static __forceinline__ __device__ void surf2Dwrite(float val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3048 {
3049   __surfModeSwitch(make_uint1((unsigned int)__float_as_int(val)), surf, x, y, mode, u1);
3050 }
3051
3052 static __forceinline__ __device__ void surf2Dwrite(float1 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3053 {
3054   __surfModeSwitch(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, y, mode, u1);
3055 }
3056
3057 static __forceinline__ __device__ void surf2Dwrite(float2 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3058 {
3059   __surfModeSwitch(make_uint2((unsigned int)__float_as_int(val.x), __float_as_int((unsigned int)val.y)), surf, x, y, mode, u2);
3060 }
3061
3062 static __forceinline__ __device__ void surf2Dwrite(float4 val, surface<void, cudaSurfaceType2D> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3063 {
3064   __surfModeSwitch(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, y, mode, u4);
3065 }
3066
3067 #undef __surfModeSwitch
3068
3069 /*******************************************************************************
3070 *                                                                              *
3071 *                                                                              *
3072 *                                                                              *
3073 *******************************************************************************/
3074
3075 extern __device__ __device_builtin__ void __surf3Dwritec1(    uchar1 val, surface<void, cudaSurfaceType3D> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
3076 extern __device__ __device_builtin__ void __surf3Dwritec2(    uchar2 val, surface<void, cudaSurfaceType3D> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
3077 extern __device__ __device_builtin__ void __surf3Dwritec4(    uchar4 val, surface<void, cudaSurfaceType3D> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
3078 extern __device__ __device_builtin__ void __surf3Dwrites1(   ushort1 val, surface<void, cudaSurfaceType3D> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
3079 extern __device__ __device_builtin__ void __surf3Dwrites2(   ushort2 val, surface<void, cudaSurfaceType3D> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
3080 extern __device__ __device_builtin__ void __surf3Dwrites4(   ushort4 val, surface<void, cudaSurfaceType3D> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
3081 extern __device__ __device_builtin__ void __surf3Dwriteu1(     uint1 val, surface<void, cudaSurfaceType3D> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
3082 extern __device__ __device_builtin__ void __surf3Dwriteu2(     uint2 val, surface<void, cudaSurfaceType3D> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
3083 extern __device__ __device_builtin__ void __surf3Dwriteu4(     uint4 val, surface<void, cudaSurfaceType3D> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
3084 extern __device__ __device_builtin__ void __surf3Dwritel1(ulonglong1 val, surface<void, cudaSurfaceType3D> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
3085 extern __device__ __device_builtin__ void __surf3Dwritel2(ulonglong2 val, surface<void, cudaSurfaceType3D> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
3086
3087 #if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 200
3088
3089 #define __surfModeSwitch(val, surf, x, y, z, mode, type)                                                    \
3090         ((mode == cudaBoundaryModeZero)  ? __surf3Dwrite##type(val, surf, x, y, z, cudaBoundaryModeZero ) : \
3091          (mode == cudaBoundaryModeClamp) ? __surf3Dwrite##type(val, surf, x, y, z, cudaBoundaryModeClamp) : \
3092                                            __surf3Dwrite##type(val, surf, x, y, z, cudaBoundaryModeTrap ))
3093
3094 #else /* __CUDA_ARCH__ && __CUDA_ARCH__ >= 200 */
3095
3096 #define __surfModeSwitch(val, surf, x, y, z, mode, type) \
3097         __surf3Dwrite##type(val, surf, x, y, z, cudaBoundaryModeTrap)
3098
3099 #endif /* __CUDA_ARCH__ && __CUDA_ARCH__ >= 200 */
3100
3101 template<class T>
3102 static __forceinline__ __device__ void surf3Dwrite(T val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3103 {
3104   union {
3105     T       val;
3106     uchar1  c1;
3107     ushort1 s1;
3108     uint1   u1;
3109     uint2   u2;
3110     uint4   u4;
3111   } tmp;
3112
3113   tmp.val = val;
3114
3115   (s ==  1) ? (void)(__surfModeSwitch(tmp.c1, surf, x, y, z, mode, c1)) :
3116   (s ==  2) ? (void)(__surfModeSwitch(tmp.s1, surf, x, y, z, mode, s1)) :
3117   (s ==  4) ? (void)(__surfModeSwitch(tmp.u1, surf, x, y, z, mode, u1)) :
3118   (s ==  8) ? (void)(__surfModeSwitch(tmp.u2, surf, x, y, z, mode, u2)) :
3119   (s == 16) ? (void)(__surfModeSwitch(tmp.u4, surf, x, y, z, mode, u4)) :
3120               (void)0;
3121 }
3122
3123 template<class T>
3124 static __forceinline__ __device__ void surf3Dwrite(T val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3125 {;
3126   surf3Dwrite(val, surf, x, y, z, (int)sizeof(T), mode);
3127 }
3128
3129
3130 static __forceinline__ __device__ void surf3Dwrite(char val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3131 {
3132   __surfModeSwitch(make_uchar1((unsigned char)val), surf, x, y, z, mode, c1);
3133 }
3134
3135 static __forceinline__ __device__ void surf3Dwrite(signed char val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3136 {
3137   __surfModeSwitch(make_uchar1((unsigned char)val), surf, x, y, z, mode, c1);
3138 }
3139
3140 static __forceinline__ __device__ void surf3Dwrite(unsigned char val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3141 {
3142   __surfModeSwitch(make_uchar1(val), surf, x, y, z, mode, c1);
3143 }
3144
3145 static __forceinline__ __device__ void surf3Dwrite(char1 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3146 {
3147   __surfModeSwitch(make_uchar1((unsigned char)val.x), surf, x, y, z, mode, c1);
3148 }
3149
3150 static __forceinline__ __device__ void surf3Dwrite(uchar1 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3151 {
3152   __surfModeSwitch(val, surf, x, y, z, mode, c1);
3153 }
3154
3155 static __forceinline__ __device__ void surf3Dwrite(char2 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3156 {
3157   __surfModeSwitch(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, y, z, mode, c2);
3158 }
3159
3160 static __forceinline__ __device__ void surf3Dwrite(uchar2 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3161 {
3162   __surfModeSwitch(val, surf, x, y, z, mode, c2);
3163 }
3164
3165 static __forceinline__ __device__ void surf3Dwrite(char4 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3166 {
3167   __surfModeSwitch(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, y, z, mode, c4);
3168 }
3169
3170 static __forceinline__ __device__ void surf3Dwrite(uchar4 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3171 {
3172   __surfModeSwitch(val, surf, x, y, z, mode, c4);
3173 }
3174
3175 static __forceinline__ __device__ void surf3Dwrite(short val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3176 {
3177   __surfModeSwitch(make_ushort1((unsigned short)val), surf, x, y, z, mode, s1);
3178 }
3179
3180 static __forceinline__ __device__ void surf3Dwrite(unsigned short val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3181 {
3182   __surfModeSwitch(make_ushort1(val), surf, x, y, z, mode, s1);
3183 }
3184
3185 static __forceinline__ __device__ void surf3Dwrite(short1 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3186 {
3187   __surfModeSwitch(make_ushort1((unsigned short)val.x), surf, x, y, z, mode, s1);
3188 }
3189
3190 static __forceinline__ __device__ void surf3Dwrite(ushort1 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3191 {
3192   __surfModeSwitch(val, surf, x, y, z, mode, s1);
3193 }
3194
3195 static __forceinline__ __device__ void surf3Dwrite(short2 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3196 {
3197   __surfModeSwitch(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, y, z, mode, s2);
3198 }
3199
3200 static __forceinline__ __device__ void surf3Dwrite(ushort2 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3201 {
3202   __surfModeSwitch(val, surf, x, y, z, mode, s2);
3203 }
3204
3205 static __forceinline__ __device__ void surf3Dwrite(short4 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3206 {
3207   __surfModeSwitch(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, y, z, mode, s4);
3208 }
3209
3210 static __forceinline__ __device__ void surf3Dwrite(ushort4 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3211 {
3212   __surfModeSwitch(val, surf, x, y, z, mode, s4);
3213 }
3214
3215 static __forceinline__ __device__ void surf3Dwrite(int val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3216 {
3217   __surfModeSwitch(make_uint1((unsigned int)val), surf, x, y, z, mode, u1);
3218 }
3219
3220 static __forceinline__ __device__ void surf3Dwrite(unsigned int val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3221 {
3222   __surfModeSwitch(make_uint1(val), surf, x, y, z, mode, u1);
3223 }
3224
3225 static __forceinline__ __device__ void surf3Dwrite(int1 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3226 {
3227   __surfModeSwitch(make_uint1((unsigned int)val.x), surf, x, y, z, mode, u1);
3228 }
3229
3230 static __forceinline__ __device__ void surf3Dwrite(uint1 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3231 {
3232   __surfModeSwitch(val, surf, x, y, z, mode, u1);
3233 }
3234
3235 static __forceinline__ __device__ void surf3Dwrite(int2 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3236 {
3237   __surfModeSwitch(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, z, mode, u2);
3238 }
3239
3240 static __forceinline__ __device__ void surf3Dwrite(uint2 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3241 {
3242   __surfModeSwitch(val, surf, x, y, z, mode, u2);
3243 }
3244
3245 static __forceinline__ __device__ void surf3Dwrite(int4 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3246 {
3247   __surfModeSwitch(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, z, mode, u4);
3248 }
3249
3250 static __forceinline__ __device__ void surf3Dwrite(uint4 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3251 {
3252   __surfModeSwitch(val, surf, x, y, z, mode, u4);
3253 }
3254
3255 static __forceinline__ __device__ void surf3Dwrite(long long int val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3256 {
3257   __surfModeSwitch(make_ulonglong1((unsigned long long int)val), surf, x, y, z, mode, l1);
3258 }
3259
3260 static __forceinline__ __device__ void surf3Dwrite(unsigned long long int val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3261 {
3262   __surfModeSwitch(make_ulonglong1(val), surf, x, y, z, mode, l1);
3263 }
3264
3265 static __forceinline__ __device__ void surf3Dwrite(longlong1 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3266 {
3267   __surfModeSwitch(make_ulonglong1((unsigned long long int)val.x), surf, x, y, z, mode, l1);
3268 }
3269
3270 static __forceinline__ __device__ void surf3Dwrite(ulonglong1 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3271 {
3272   __surfModeSwitch(val, surf, x, y, z, mode, l1);
3273 }
3274
3275 static __forceinline__ __device__ void surf3Dwrite(longlong2 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3276 {
3277   __surfModeSwitch(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, y, z, mode, l2);
3278 }
3279
3280 static __forceinline__ __device__ void surf3Dwrite(ulonglong2 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3281 {
3282   __surfModeSwitch(val, surf, x, y, z, mode, l2);
3283 }
3284
3285 #if !defined(__LP64__)
3286
3287 static __forceinline__ __device__ void surf3Dwrite(long int val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3288 {
3289   __surfModeSwitch(make_uint1((unsigned int)val), surf, x, y, z, mode, u1);
3290 }
3291
3292 static __forceinline__ __device__ void surf3Dwrite(unsigned long int val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3293 {
3294   __surfModeSwitch(make_uint1((unsigned int)val), surf, x, y, z, mode, u1);
3295 }
3296
3297 static __forceinline__ __device__ void surf3Dwrite(long1 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3298 {
3299   __surfModeSwitch(make_uint1((unsigned int)val.x), surf, x, y, z, mode, u1);
3300 }
3301
3302 static __forceinline__ __device__ void surf3Dwrite(ulong1 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3303 {
3304   __surfModeSwitch(make_uint1((unsigned int)val.x), surf, x, y, z, mode, u1);
3305 }
3306
3307 static __forceinline__ __device__ void surf3Dwrite(long2 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3308 {
3309   __surfModeSwitch(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, z, mode, u2);
3310 }
3311
3312 static __forceinline__ __device__ void surf3Dwrite(ulong2 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3313 {
3314   __surfModeSwitch(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, z, mode, u2);
3315 }
3316
3317 static __forceinline__ __device__ void surf3Dwrite(long4 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3318 {
3319   __surfModeSwitch(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, z, mode, u4);
3320 }
3321
3322 static __forceinline__ __device__ void surf3Dwrite(ulong4 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3323 {
3324   __surfModeSwitch(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, z, mode, u4);
3325 }
3326
3327 #endif /* !__LP64__ */
3328
3329 static __forceinline__ __device__ void surf3Dwrite(float val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3330 {
3331   __surfModeSwitch(make_uint1((unsigned int)__float_as_int(val)), surf, x, y, z, mode, u1);
3332 }
3333
3334 static __forceinline__ __device__ void surf3Dwrite(float1 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3335 {
3336   __surfModeSwitch(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, y, z, mode, u1);
3337 }
3338
3339 static __forceinline__ __device__ void surf3Dwrite(float2 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3340 {
3341   __surfModeSwitch(make_uint2((unsigned int)__float_as_int(val.x), __float_as_int((unsigned int)val.y)), surf, x, y, z, mode, u2);
3342 }
3343
3344 static __forceinline__ __device__ void surf3Dwrite(float4 val, surface<void, cudaSurfaceType3D> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3345 {
3346   __surfModeSwitch(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, y, z, mode, u4);
3347 }
3348
3349 #undef __surfModeSwitch
3350
3351 /*******************************************************************************
3352 *                                                                              *
3353 *                                                                              *
3354 *                                                                              *
3355 *******************************************************************************/
3356
3357 extern __device__ __device_builtin__ void __surf1DLayeredwritec1(    uchar1 val, surface<void, cudaSurfaceType1DLayered> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
3358 extern __device__ __device_builtin__ void __surf1DLayeredwritec2(    uchar2 val, surface<void, cudaSurfaceType1DLayered> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
3359 extern __device__ __device_builtin__ void __surf1DLayeredwritec4(    uchar4 val, surface<void, cudaSurfaceType1DLayered> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
3360 extern __device__ __device_builtin__ void __surf1DLayeredwrites1(   ushort1 val, surface<void, cudaSurfaceType1DLayered> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
3361 extern __device__ __device_builtin__ void __surf1DLayeredwrites2(   ushort2 val, surface<void, cudaSurfaceType1DLayered> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
3362 extern __device__ __device_builtin__ void __surf1DLayeredwrites4(   ushort4 val, surface<void, cudaSurfaceType1DLayered> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
3363 extern __device__ __device_builtin__ void __surf1DLayeredwriteu1(     uint1 val, surface<void, cudaSurfaceType1DLayered> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
3364 extern __device__ __device_builtin__ void __surf1DLayeredwriteu2(     uint2 val, surface<void, cudaSurfaceType1DLayered> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
3365 extern __device__ __device_builtin__ void __surf1DLayeredwriteu4(     uint4 val, surface<void, cudaSurfaceType1DLayered> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
3366 extern __device__ __device_builtin__ void __surf1DLayeredwritel1(ulonglong1 val, surface<void, cudaSurfaceType1DLayered> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
3367 extern __device__ __device_builtin__ void __surf1DLayeredwritel2(ulonglong2 val, surface<void, cudaSurfaceType1DLayered> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
3368
3369 #if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 200
3370
3371 #define __surfModeSwitch(val, surf, x, layer, mode, type)                                                    \
3372         ((mode == cudaBoundaryModeZero)  ? __surf1DLayeredwrite##type(val, surf, x, layer, cudaBoundaryModeZero ) : \
3373          (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwrite##type(val, surf, x, layer, cudaBoundaryModeClamp) : \
3374                                            __surf1DLayeredwrite##type(val, surf, x, layer, cudaBoundaryModeTrap ))
3375
3376 #else /* __CUDA_ARCH__ && __CUDA_ARCH__ >= 200 */
3377
3378 #define __surfModeSwitch(val, surf, x, layer, mode, type) \
3379         __surf1DLayeredwrite##type(val, surf, x, layer, cudaBoundaryModeTrap)
3380
3381 #endif /* __CUDA_ARCH__ && __CUDA_ARCH__ >= 200 */
3382
3383 template<class T>
3384 static __forceinline__ __device__ void surf1DLayeredwrite(T val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3385 {
3386   union {
3387     T       val;
3388     uchar1  c1;
3389     ushort1 s1;
3390     uint1   u1;
3391     uint2   u2;
3392     uint4   u4;
3393   } tmp;
3394
3395   tmp.val = val;
3396
3397   (s ==  1) ? (void)(__surfModeSwitch(tmp.c1, surf, x, layer, mode, c1)) :
3398   (s ==  2) ? (void)(__surfModeSwitch(tmp.s1, surf, x, layer, mode, s1)) :
3399   (s ==  4) ? (void)(__surfModeSwitch(tmp.u1, surf, x, layer, mode, u1)) :
3400   (s ==  8) ? (void)(__surfModeSwitch(tmp.u2, surf, x, layer, mode, u2)) :
3401   (s == 16) ? (void)(__surfModeSwitch(tmp.u4, surf, x, layer, mode, u4)) :
3402               (void)0;
3403 }
3404
3405 template<class T>
3406 static __forceinline__ __device__ void surf1DLayeredwrite(T val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3407 {;
3408   surf1DLayeredwrite(val, surf, x, layer, (int)sizeof(T), mode);
3409 }
3410
3411
3412 static __forceinline__ __device__ void surf1DLayeredwrite(char val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3413 {
3414   __surfModeSwitch(make_uchar1((unsigned char)val), surf, x, layer, mode, c1);
3415 }
3416
3417 static __forceinline__ __device__ void surf1DLayeredwrite(signed char val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3418 {
3419   __surfModeSwitch(make_uchar1((unsigned char)val), surf, x, layer, mode, c1);
3420 }
3421
3422 static __forceinline__ __device__ void surf1DLayeredwrite(unsigned char val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3423 {
3424   __surfModeSwitch(make_uchar1(val), surf, x, layer, mode, c1);
3425 }
3426
3427 static __forceinline__ __device__ void surf1DLayeredwrite(char1 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3428 {
3429   __surfModeSwitch(make_uchar1((unsigned char)val.x), surf, x, layer, mode, c1);
3430 }
3431
3432 static __forceinline__ __device__ void surf1DLayeredwrite(uchar1 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3433 {
3434   __surfModeSwitch(val, surf, x, layer, mode, c1);
3435 }
3436
3437 static __forceinline__ __device__ void surf1DLayeredwrite(char2 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3438 {
3439   __surfModeSwitch(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, layer, mode, c2);
3440 }
3441
3442 static __forceinline__ __device__ void surf1DLayeredwrite(uchar2 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3443 {
3444   __surfModeSwitch(val, surf, x, layer, mode, c2);
3445 }
3446
3447 static __forceinline__ __device__ void surf1DLayeredwrite(char4 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3448 {
3449   __surfModeSwitch(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, layer, mode, c4);
3450 }
3451
3452 static __forceinline__ __device__ void surf1DLayeredwrite(uchar4 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3453 {
3454   __surfModeSwitch(val, surf, x, layer, mode, c4);
3455 }
3456
3457 static __forceinline__ __device__ void surf1DLayeredwrite(short val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3458 {
3459   __surfModeSwitch(make_ushort1((unsigned short)val), surf, x, layer, mode, s1);
3460 }
3461
3462 static __forceinline__ __device__ void surf1DLayeredwrite(unsigned short val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3463 {
3464   __surfModeSwitch(make_ushort1(val), surf, x, layer, mode, s1);
3465 }
3466
3467 static __forceinline__ __device__ void surf1DLayeredwrite(short1 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3468 {
3469   __surfModeSwitch(make_ushort1((unsigned short)val.x), surf, x, layer, mode, s1);
3470 }
3471
3472 static __forceinline__ __device__ void surf1DLayeredwrite(ushort1 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3473 {
3474   __surfModeSwitch(val, surf, x, layer, mode, s1);
3475 }
3476
3477 static __forceinline__ __device__ void surf1DLayeredwrite(short2 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3478 {
3479   __surfModeSwitch(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, layer, mode, s2);
3480 }
3481
3482 static __forceinline__ __device__ void surf1DLayeredwrite(ushort2 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3483 {
3484   __surfModeSwitch(val, surf, x, layer, mode, s2);
3485 }
3486
3487 static __forceinline__ __device__ void surf1DLayeredwrite(short4 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3488 {
3489   __surfModeSwitch(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, layer, mode, s4);
3490 }
3491
3492 static __forceinline__ __device__ void surf1DLayeredwrite(ushort4 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3493 {
3494   __surfModeSwitch(val, surf, x, layer, mode, s4);
3495 }
3496
3497 static __forceinline__ __device__ void surf1DLayeredwrite(int val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3498 {
3499   __surfModeSwitch(make_uint1((unsigned int)val), surf, x, layer, mode, u1);
3500 }
3501
3502 static __forceinline__ __device__ void surf1DLayeredwrite(unsigned int val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3503 {
3504   __surfModeSwitch(make_uint1(val), surf, x, layer, mode, u1);
3505 }
3506
3507 static __forceinline__ __device__ void surf1DLayeredwrite(int1 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3508 {
3509   __surfModeSwitch(make_uint1((unsigned int)val.x), surf, x, layer, mode, u1);
3510 }
3511
3512 static __forceinline__ __device__ void surf1DLayeredwrite(uint1 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3513 {
3514   __surfModeSwitch(val, surf, x, layer, mode, u1);
3515 }
3516
3517 static __forceinline__ __device__ void surf1DLayeredwrite(int2 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3518 {
3519   __surfModeSwitch(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, layer, mode, u2);
3520 }
3521
3522 static __forceinline__ __device__ void surf1DLayeredwrite(uint2 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3523 {
3524   __surfModeSwitch(val, surf, x, layer, mode, u2);
3525 }
3526
3527 static __forceinline__ __device__ void surf1DLayeredwrite(int4 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3528 {
3529   __surfModeSwitch(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, layer, mode, u4);
3530 }
3531
3532 static __forceinline__ __device__ void surf1DLayeredwrite(uint4 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3533 {
3534   __surfModeSwitch(val, surf, x, layer, mode, u4);
3535 }
3536
3537 static __forceinline__ __device__ void surf1DLayeredwrite(long long int val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3538 {
3539   __surfModeSwitch(make_ulonglong1((unsigned long long int)val), surf, x, layer, mode, l1);
3540 }
3541
3542 static __forceinline__ __device__ void surf1DLayeredwrite(unsigned long long int val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3543 {
3544   __surfModeSwitch(make_ulonglong1(val), surf, x, layer, mode, l1);
3545 }
3546
3547 static __forceinline__ __device__ void surf1DLayeredwrite(longlong1 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3548 {
3549   __surfModeSwitch(make_ulonglong1((unsigned long long int)val.x), surf, x, layer, mode, l1);
3550 }
3551
3552 static __forceinline__ __device__ void surf1DLayeredwrite(ulonglong1 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3553 {
3554   __surfModeSwitch(val, surf, x, layer, mode, l1);
3555 }
3556
3557 static __forceinline__ __device__ void surf1DLayeredwrite(longlong2 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3558 {
3559   __surfModeSwitch(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, layer, mode, l2);
3560 }
3561
3562 static __forceinline__ __device__ void surf1DLayeredwrite(ulonglong2 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3563 {
3564   __surfModeSwitch(val, surf, x, layer, mode, l2);
3565 }
3566
3567 #if !defined(__LP64__)
3568
3569 static __forceinline__ __device__ void surf1DLayeredwrite(long int val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3570 {
3571   __surfModeSwitch(make_uint1((unsigned int)val), surf, x, layer, mode, u1);
3572 }
3573
3574 static __forceinline__ __device__ void surf1DLayeredwrite(unsigned long int val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3575 {
3576   __surfModeSwitch(make_uint1((unsigned int)val), surf, x, layer, mode, u1);
3577 }
3578
3579 static __forceinline__ __device__ void surf1DLayeredwrite(long1 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3580 {
3581   __surfModeSwitch(make_uint1((unsigned int)val.x), surf, x, layer, mode, u1);
3582 }
3583
3584 static __forceinline__ __device__ void surf1DLayeredwrite(ulong1 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3585 {
3586   __surfModeSwitch(make_uint1((unsigned int)val.x), surf, x, layer, mode, u1);
3587 }
3588
3589 static __forceinline__ __device__ void surf1DLayeredwrite(long2 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3590 {
3591   __surfModeSwitch(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, layer, mode, u2);
3592 }
3593
3594 static __forceinline__ __device__ void surf1DLayeredwrite(ulong2 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3595 {
3596   __surfModeSwitch(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, layer, mode, u2);
3597 }
3598
3599 static __forceinline__ __device__ void surf1DLayeredwrite(long4 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3600 {
3601   __surfModeSwitch(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, layer, mode, u4);
3602 }
3603
3604 static __forceinline__ __device__ void surf1DLayeredwrite(ulong4 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3605 {
3606   __surfModeSwitch(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, layer, mode, u4);
3607 }
3608
3609 #endif /* !__LP64__ */
3610
3611 static __forceinline__ __device__ void surf1DLayeredwrite(float val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3612 {
3613   __surfModeSwitch(make_uint1((unsigned int)__float_as_int(val)), surf, x, layer, mode, u1);
3614 }
3615
3616 static __forceinline__ __device__ void surf1DLayeredwrite(float1 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3617 {
3618   __surfModeSwitch(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, layer, mode, u1);
3619 }
3620
3621 static __forceinline__ __device__ void surf1DLayeredwrite(float2 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3622 {
3623   __surfModeSwitch(make_uint2((unsigned int)__float_as_int(val.x), __float_as_int((unsigned int)val.y)), surf, x, layer, mode, u2);
3624 }
3625
3626 static __forceinline__ __device__ void surf1DLayeredwrite(float4 val, surface<void, cudaSurfaceType1DLayered> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3627 {
3628   __surfModeSwitch(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, layer, mode, u4);
3629 }
3630
3631 #undef __surfModeSwitch
3632
3633 /*******************************************************************************
3634 *                                                                              *
3635 *                                                                              *
3636 *                                                                              *
3637 *******************************************************************************/
3638
3639 extern __device__ __device_builtin__ void __surf2DLayeredwritec1(    uchar1 val, surface<void, cudaSurfaceType2DLayered> t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
3640 extern __device__ __device_builtin__ void __surf2DLayeredwritec2(    uchar2 val, surface<void, cudaSurfaceType2DLayered> t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
3641 extern __device__ __device_builtin__ void __surf2DLayeredwritec4(    uchar4 val, surface<void, cudaSurfaceType2DLayered> t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
3642 extern __device__ __device_builtin__ void __surf2DLayeredwrites1(   ushort1 val, surface<void, cudaSurfaceType2DLayered> t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
3643 extern __device__ __device_builtin__ void __surf2DLayeredwrites2(   ushort2 val, surface<void, cudaSurfaceType2DLayered> t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
3644 extern __device__ __device_builtin__ void __surf2DLayeredwrites4(   ushort4 val, surface<void, cudaSurfaceType2DLayered> t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
3645 extern __device__ __device_builtin__ void __surf2DLayeredwriteu1(     uint1 val, surface<void, cudaSurfaceType2DLayered> t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
3646 extern __device__ __device_builtin__ void __surf2DLayeredwriteu2(     uint2 val, surface<void, cudaSurfaceType2DLayered> t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
3647 extern __device__ __device_builtin__ void __surf2DLayeredwriteu4(     uint4 val, surface<void, cudaSurfaceType2DLayered> t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
3648 extern __device__ __device_builtin__ void __surf2DLayeredwritel1(ulonglong1 val, surface<void, cudaSurfaceType2DLayered> t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
3649 extern __device__ __device_builtin__ void __surf2DLayeredwritel2(ulonglong2 val, surface<void, cudaSurfaceType2DLayered> t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
3650
3651 #if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 200
3652
3653 #define __surfModeSwitch(val, surf, x, y, layer, mode, type)                                                    \
3654         ((mode == cudaBoundaryModeZero)  ? __surf2DLayeredwrite##type(val, surf, x, y, layer, cudaBoundaryModeZero ) : \
3655          (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrite##type(val, surf, x, y, layer, cudaBoundaryModeClamp) : \
3656                                            __surf2DLayeredwrite##type(val, surf, x, y, layer, cudaBoundaryModeTrap ))
3657
3658 #else /* __CUDA_ARCH__ && __CUDA_ARCH__ >= 200 */
3659
3660 #define __surfModeSwitch(val, surf, x, y, layer, mode, type) \
3661         __surf2DLayeredwrite##type(val, surf, x, y, layer, cudaBoundaryModeTrap)
3662
3663 #endif /* __CUDA_ARCH__ && __CUDA_ARCH__ >= 200 */
3664
3665 template<class T>
3666 static __forceinline__ __device__ void surf2DLayeredwrite(T val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3667 {
3668   union {
3669     T       val;
3670     uchar1  c1;
3671     ushort1 s1;
3672     uint1   u1;
3673     uint2   u2;
3674     uint4   u4;
3675   } tmp;
3676
3677   tmp.val = val;
3678
3679   (s ==  1) ? (void)(__surfModeSwitch(tmp.c1, surf, x, y, layer, mode, c1)) :
3680   (s ==  2) ? (void)(__surfModeSwitch(tmp.s1, surf, x, y, layer, mode, s1)) :
3681   (s ==  4) ? (void)(__surfModeSwitch(tmp.u1, surf, x, y, layer, mode, u1)) :
3682   (s ==  8) ? (void)(__surfModeSwitch(tmp.u2, surf, x, y, layer, mode, u2)) :
3683   (s == 16) ? (void)(__surfModeSwitch(tmp.u4, surf, x, y, layer, mode, u4)) :
3684               (void)0;
3685 }
3686
3687 template<class T>
3688 static __forceinline__ __device__ void surf2DLayeredwrite(T val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3689 {;
3690   surf2DLayeredwrite(val, surf, x, y, layer, (int)sizeof(T), mode);
3691 }
3692
3693
3694 static __forceinline__ __device__ void surf2DLayeredwrite(char val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3695 {
3696   __surfModeSwitch(make_uchar1((unsigned char)val), surf, x, y, layer, mode, c1);
3697 }
3698
3699 static __forceinline__ __device__ void surf2DLayeredwrite(signed char val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3700 {
3701   __surfModeSwitch(make_uchar1((unsigned char)val), surf, x, y, layer, mode, c1);
3702 }
3703
3704 static __forceinline__ __device__ void surf2DLayeredwrite(unsigned char val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3705 {
3706   __surfModeSwitch(make_uchar1(val), surf, x, y, layer, mode, c1);
3707 }
3708
3709 static __forceinline__ __device__ void surf2DLayeredwrite(char1 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3710 {
3711   __surfModeSwitch(make_uchar1((unsigned char)val.x), surf, x, y, layer, mode, c1);
3712 }
3713
3714 static __forceinline__ __device__ void surf2DLayeredwrite(uchar1 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3715 {
3716   __surfModeSwitch(val, surf, x, y, layer, mode, c1);
3717 }
3718
3719 static __forceinline__ __device__ void surf2DLayeredwrite(char2 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3720 {
3721   __surfModeSwitch(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, y, layer, mode, c2);
3722 }
3723
3724 static __forceinline__ __device__ void surf2DLayeredwrite(uchar2 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3725 {
3726   __surfModeSwitch(val, surf, x, y, layer, mode, c2);
3727 }
3728
3729 static __forceinline__ __device__ void surf2DLayeredwrite(char4 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3730 {
3731   __surfModeSwitch(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, y, layer, mode, c4);
3732 }
3733
3734 static __forceinline__ __device__ void surf2DLayeredwrite(uchar4 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3735 {
3736   __surfModeSwitch(val, surf, x, y, layer, mode, c4);
3737 }
3738
3739 static __forceinline__ __device__ void surf2DLayeredwrite(short val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3740 {
3741   __surfModeSwitch(make_ushort1((unsigned short)val), surf, x, y, layer, mode, s1);
3742 }
3743
3744 static __forceinline__ __device__ void surf2DLayeredwrite(unsigned short val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3745 {
3746   __surfModeSwitch(make_ushort1(val), surf, x, y, layer, mode, s1);
3747 }
3748
3749 static __forceinline__ __device__ void surf2DLayeredwrite(short1 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3750 {
3751   __surfModeSwitch(make_ushort1((unsigned short)val.x), surf, x, y, layer, mode, s1);
3752 }
3753
3754 static __forceinline__ __device__ void surf2DLayeredwrite(ushort1 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3755 {
3756   __surfModeSwitch(val, surf, x, y, layer, mode, s1);
3757 }
3758
3759 static __forceinline__ __device__ void surf2DLayeredwrite(short2 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3760 {
3761   __surfModeSwitch(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, y, layer, mode, s2);
3762 }
3763
3764 static __forceinline__ __device__ void surf2DLayeredwrite(ushort2 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3765 {
3766   __surfModeSwitch(val, surf, x, y, layer, mode, s2);
3767 }
3768
3769 static __forceinline__ __device__ void surf2DLayeredwrite(short4 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3770 {
3771   __surfModeSwitch(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, y, layer, mode, s4);
3772 }
3773
3774 static __forceinline__ __device__ void surf2DLayeredwrite(ushort4 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3775 {
3776   __surfModeSwitch(val, surf, x, y, layer, mode, s4);
3777 }
3778
3779 static __forceinline__ __device__ void surf2DLayeredwrite(int val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3780 {
3781   __surfModeSwitch(make_uint1((unsigned int)val), surf, x, y, layer, mode, u1);
3782 }
3783
3784 static __forceinline__ __device__ void surf2DLayeredwrite(unsigned int val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3785 {
3786   __surfModeSwitch(make_uint1(val), surf, x, y, layer, mode, u1);
3787 }
3788
3789 static __forceinline__ __device__ void surf2DLayeredwrite(int1 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3790 {
3791   __surfModeSwitch(make_uint1((unsigned int)val.x), surf, x, y, layer, mode, u1);
3792 }
3793
3794 static __forceinline__ __device__ void surf2DLayeredwrite(uint1 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3795 {
3796   __surfModeSwitch(val, surf, x, y, layer, mode, u1);
3797 }
3798
3799 static __forceinline__ __device__ void surf2DLayeredwrite(int2 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3800 {
3801   __surfModeSwitch(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, layer, mode, u2);
3802 }
3803
3804 static __forceinline__ __device__ void surf2DLayeredwrite(uint2 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3805 {
3806   __surfModeSwitch(val, surf, x, y, layer, mode, u2);
3807 }
3808
3809 static __forceinline__ __device__ void surf2DLayeredwrite(int4 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3810 {
3811   __surfModeSwitch(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, layer, mode, u4);
3812 }
3813
3814 static __forceinline__ __device__ void surf2DLayeredwrite(uint4 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3815 {
3816   __surfModeSwitch(val, surf, x, y, layer, mode, u4);
3817 }
3818
3819 static __forceinline__ __device__ void surf2DLayeredwrite(long long int val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3820 {
3821   __surfModeSwitch(make_ulonglong1((unsigned long long int)val), surf, x, y, layer, mode, l1);
3822 }
3823
3824 static __forceinline__ __device__ void surf2DLayeredwrite(unsigned long long int val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3825 {
3826   __surfModeSwitch(make_ulonglong1(val), surf, x, y, layer, mode, l1);
3827 }
3828
3829 static __forceinline__ __device__ void surf2DLayeredwrite(longlong1 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3830 {
3831   __surfModeSwitch(make_ulonglong1((unsigned long long int)val.x), surf, x, y, layer, mode, l1);
3832 }
3833
3834 static __forceinline__ __device__ void surf2DLayeredwrite(ulonglong1 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3835 {
3836   __surfModeSwitch(val, surf, x, y, layer, mode, l1);
3837 }
3838
3839 static __forceinline__ __device__ void surf2DLayeredwrite(longlong2 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3840 {
3841   __surfModeSwitch(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, y, layer, mode, l2);
3842 }
3843
3844 static __forceinline__ __device__ void surf2DLayeredwrite(ulonglong2 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3845 {
3846   __surfModeSwitch(val, surf, x, y, layer, mode, l2);
3847 }
3848
3849 #if !defined(__LP64__)
3850
3851 static __forceinline__ __device__ void surf2DLayeredwrite(long int val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3852 {
3853   __surfModeSwitch(make_uint1((unsigned int)val), surf, x, y, layer, mode, u1);
3854 }
3855
3856 static __forceinline__ __device__ void surf2DLayeredwrite(unsigned long int val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3857 {
3858   __surfModeSwitch(make_uint1((unsigned int)val), surf, x, y, layer, mode, u1);
3859 }
3860
3861 static __forceinline__ __device__ void surf2DLayeredwrite(long1 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3862 {
3863   __surfModeSwitch(make_uint1((unsigned int)val.x), surf, x, y, layer, mode, u1);
3864 }
3865
3866 static __forceinline__ __device__ void surf2DLayeredwrite(ulong1 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3867 {
3868   __surfModeSwitch(make_uint1((unsigned int)val.x), surf, x, y, layer, mode, u1);
3869 }
3870
3871 static __forceinline__ __device__ void surf2DLayeredwrite(long2 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3872 {
3873   __surfModeSwitch(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, layer, mode, u2);
3874 }
3875
3876 static __forceinline__ __device__ void surf2DLayeredwrite(ulong2 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3877 {
3878   __surfModeSwitch(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, layer, mode, u2);
3879 }
3880
3881 static __forceinline__ __device__ void surf2DLayeredwrite(long4 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3882 {
3883   __surfModeSwitch(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, layer, mode, u4);
3884 }
3885
3886 static __forceinline__ __device__ void surf2DLayeredwrite(ulong4 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3887 {
3888   __surfModeSwitch(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, layer, mode, u4);
3889 }
3890
3891 #endif /* !__LP64__ */
3892
3893 static __forceinline__ __device__ void surf2DLayeredwrite(float val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3894 {
3895   __surfModeSwitch(make_uint1((unsigned int)__float_as_int(val)), surf, x, y, layer, mode, u1);
3896 }
3897
3898 static __forceinline__ __device__ void surf2DLayeredwrite(float1 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3899 {
3900   __surfModeSwitch(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, y, layer, mode, u1);
3901 }
3902
3903 static __forceinline__ __device__ void surf2DLayeredwrite(float2 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3904 {
3905   __surfModeSwitch(make_uint2((unsigned int)__float_as_int(val.x), __float_as_int((unsigned int)val.y)), surf, x, y, layer, mode, u2);
3906 }
3907
3908 static __forceinline__ __device__ void surf2DLayeredwrite(float4 val, surface<void, cudaSurfaceType2DLayered> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3909 {
3910   __surfModeSwitch(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, y, layer, mode, u4);
3911 }
3912
3913 #undef __surfModeSwitch
3914
3915 /*******************************************************************************
3916 *                                                                              *
3917 *                                                                              *
3918 *                                                                              *
3919 *******************************************************************************/
3920 extern __device__ __device_builtin__ void __surfCubemapwritec1(    uchar1 val, surface<void, cudaSurfaceTypeCubemap> t, int x, int y, int face, enum cudaSurfaceBoundaryMode mode);
3921 extern __device__ __device_builtin__ void __surfCubemapwritec2(    uchar2 val, surface<void, cudaSurfaceTypeCubemap> t, int x, int y, int face, enum cudaSurfaceBoundaryMode mode);
3922 extern __device__ __device_builtin__ void __surfCubemapwritec4(    uchar4 val, surface<void, cudaSurfaceTypeCubemap> t, int x, int y, int face, enum cudaSurfaceBoundaryMode mode);
3923 extern __device__ __device_builtin__ void __surfCubemapwrites1(   ushort1 val, surface<void, cudaSurfaceTypeCubemap> t, int x, int y, int face, enum cudaSurfaceBoundaryMode mode);
3924 extern __device__ __device_builtin__ void __surfCubemapwrites2(   ushort2 val, surface<void, cudaSurfaceTypeCubemap> t, int x, int y, int face, enum cudaSurfaceBoundaryMode mode);
3925 extern __device__ __device_builtin__ void __surfCubemapwrites4(   ushort4 val, surface<void, cudaSurfaceTypeCubemap> t, int x, int y, int face, enum cudaSurfaceBoundaryMode mode);
3926 extern __device__ __device_builtin__ void __surfCubemapwriteu1(     uint1 val, surface<void, cudaSurfaceTypeCubemap> t, int x, int y, int face, enum cudaSurfaceBoundaryMode mode);
3927 extern __device__ __device_builtin__ void __surfCubemapwriteu2(     uint2 val, surface<void, cudaSurfaceTypeCubemap> t, int x, int y, int face, enum cudaSurfaceBoundaryMode mode);
3928 extern __device__ __device_builtin__ void __surfCubemapwriteu4(     uint4 val, surface<void, cudaSurfaceTypeCubemap> t, int x, int y, int face, enum cudaSurfaceBoundaryMode mode);
3929 extern __device__ __device_builtin__ void __surfCubemapwritel1(ulonglong1 val, surface<void, cudaSurfaceTypeCubemap> t, int x, int y, int face, enum cudaSurfaceBoundaryMode mode);
3930 extern __device__ __device_builtin__ void __surfCubemapwritel2(ulonglong2 val, surface<void, cudaSurfaceTypeCubemap> t, int x, int y, int face, enum cudaSurfaceBoundaryMode mode);
3931
3932 #if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 200
3933
3934 #define __surfModeSwitch(val, surf, x, y, face, mode, type)                                                    \
3935         ((mode == cudaBoundaryModeZero)  ? __surfCubemapwrite##type(val, surf, x, y, face, cudaBoundaryModeZero ) : \
3936          (mode == cudaBoundaryModeClamp) ? __surfCubemapwrite##type(val, surf, x, y, face, cudaBoundaryModeClamp) : \
3937                                            __surfCubemapwrite##type(val, surf, x, y, face, cudaBoundaryModeTrap ))
3938
3939 #else /* __CUDA_ARCH__ && __CUDA_ARCH__ >= 200 */
3940
3941 #define __surfModeSwitch(val, surf, x, y, face, mode, type) \
3942         __surfCubemapwrite##type(val, surf, x, y, face, cudaBoundaryModeTrap)
3943
3944
3945 #endif /* __CUDA_ARCH__ && __CUDA_ARCH__ >= 200 */
3946
3947 template<class T>
3948 static __forceinline__ __device__ void surfCubemapwrite(T val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3949 {
3950   union {
3951     T       val;
3952     uchar1  c1;
3953     ushort1 s1;
3954     uint1   u1;
3955     uint2   u2;
3956     uint4   u4;
3957   } tmp;
3958
3959   tmp.val = val;
3960
3961   (s ==  1) ? (void)(__surfModeSwitch(tmp.c1, surf, x, y, face, mode, c1)) :
3962   (s ==  2) ? (void)(__surfModeSwitch(tmp.s1, surf, x, y, face, mode, s1)) :
3963   (s ==  4) ? (void)(__surfModeSwitch(tmp.u1, surf, x, y, face, mode, u1)) :
3964   (s ==  8) ? (void)(__surfModeSwitch(tmp.u2, surf, x, y, face, mode, u2)) :
3965   (s == 16) ? (void)(__surfModeSwitch(tmp.u4, surf, x, y, face, mode, u4)) :
3966               (void)0;
3967 }
3968
3969 template<class T>
3970 static __forceinline__ __device__ void surfCubemapwrite(T val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3971 {;
3972   surfCubemapwrite(val, surf, x, y, face, (int)sizeof(T), mode);
3973 }
3974
3975
3976 static __forceinline__ __device__ void surfCubemapwrite(char val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3977 {
3978   __surfModeSwitch(make_uchar1((unsigned char)val), surf, x, y, face, mode, c1);
3979 }
3980
3981 static __forceinline__ __device__ void surfCubemapwrite(signed char val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3982 {
3983   __surfModeSwitch(make_uchar1((unsigned char)val), surf, x, y, face, mode, c1);
3984 }
3985
3986 static __forceinline__ __device__ void surfCubemapwrite(unsigned char val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3987 {
3988   __surfModeSwitch(make_uchar1(val), surf, x, y, face, mode, c1);
3989 }
3990
3991 static __forceinline__ __device__ void surfCubemapwrite(char1 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3992 {
3993   __surfModeSwitch(make_uchar1((unsigned char)val.x), surf, x, y, face, mode, c1);
3994 }
3995
3996 static __forceinline__ __device__ void surfCubemapwrite(uchar1 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
3997 {
3998   __surfModeSwitch(val, surf, x, y, face, mode, c1);
3999 }
4000
4001 static __forceinline__ __device__ void surfCubemapwrite(char2 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4002 {
4003   __surfModeSwitch(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, y, face, mode, c2);
4004 }
4005
4006 static __forceinline__ __device__ void surfCubemapwrite(uchar2 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4007 {
4008   __surfModeSwitch(val, surf, x, y, face, mode, c2);
4009 }
4010
4011 static __forceinline__ __device__ void surfCubemapwrite(char4 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4012 {
4013   __surfModeSwitch(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, y, face, mode, c4);
4014 }
4015
4016 static __forceinline__ __device__ void surfCubemapwrite(uchar4 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4017 {
4018   __surfModeSwitch(val, surf, x, y, face, mode, c4);
4019 }
4020
4021 static __forceinline__ __device__ void surfCubemapwrite(short val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4022 {
4023   __surfModeSwitch(make_ushort1((unsigned short)val), surf, x, y, face, mode, s1);
4024 }
4025
4026 static __forceinline__ __device__ void surfCubemapwrite(unsigned short val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4027 {
4028   __surfModeSwitch(make_ushort1(val), surf, x, y, face, mode, s1);
4029 }
4030
4031 static __forceinline__ __device__ void surfCubemapwrite(short1 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4032 {
4033   __surfModeSwitch(make_ushort1((unsigned short)val.x), surf, x, y, face, mode, s1);
4034 }
4035
4036 static __forceinline__ __device__ void surfCubemapwrite(ushort1 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4037 {
4038   __surfModeSwitch(val, surf, x, y, face, mode, s1);
4039 }
4040
4041 static __forceinline__ __device__ void surfCubemapwrite(short2 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4042 {
4043   __surfModeSwitch(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, y, face, mode, s2);
4044 }
4045
4046 static __forceinline__ __device__ void surfCubemapwrite(ushort2 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4047 {
4048   __surfModeSwitch(val, surf, x, y, face, mode, s2);
4049 }
4050
4051 static __forceinline__ __device__ void surfCubemapwrite(short4 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4052 {
4053   __surfModeSwitch(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, y, face, mode, s4);
4054 }
4055
4056 static __forceinline__ __device__ void surfCubemapwrite(ushort4 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4057 {
4058   __surfModeSwitch(val, surf, x, y, face, mode, s4);
4059 }
4060
4061 static __forceinline__ __device__ void surfCubemapwrite(int val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4062 {
4063   __surfModeSwitch(make_uint1((unsigned int)val), surf, x, y, face, mode, u1);
4064 }
4065
4066 static __forceinline__ __device__ void surfCubemapwrite(unsigned int val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4067 {
4068   __surfModeSwitch(make_uint1(val), surf, x, y, face, mode, u1);
4069 }
4070
4071 static __forceinline__ __device__ void surfCubemapwrite(int1 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4072 {
4073   __surfModeSwitch(make_uint1((unsigned int)val.x), surf, x, y, face, mode, u1);
4074 }
4075
4076 static __forceinline__ __device__ void surfCubemapwrite(uint1 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4077 {
4078   __surfModeSwitch(val, surf, x, y, face, mode, u1);
4079 }
4080
4081 static __forceinline__ __device__ void surfCubemapwrite(int2 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4082 {
4083   __surfModeSwitch(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, face, mode, u2);
4084 }
4085
4086 static __forceinline__ __device__ void surfCubemapwrite(uint2 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4087 {
4088   __surfModeSwitch(val, surf, x, y, face, mode, u2);
4089 }
4090
4091 static __forceinline__ __device__ void surfCubemapwrite(int4 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4092 {
4093   __surfModeSwitch(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, face, mode, u4);
4094 }
4095
4096 static __forceinline__ __device__ void surfCubemapwrite(uint4 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4097 {
4098   __surfModeSwitch(val, surf, x, y, face, mode, u4);
4099 }
4100
4101 static __forceinline__ __device__ void surfCubemapwrite(long long int val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4102 {
4103   __surfModeSwitch(make_ulonglong1((unsigned long long int)val), surf, x, y, face, mode, l1);
4104 }
4105
4106 static __forceinline__ __device__ void surfCubemapwrite(unsigned long long int val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4107 {
4108   __surfModeSwitch(make_ulonglong1(val), surf, x, y, face, mode, l1);
4109 }
4110
4111 static __forceinline__ __device__ void surfCubemapwrite(longlong1 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4112 {
4113   __surfModeSwitch(make_ulonglong1((unsigned long long int)val.x), surf, x, y, face, mode, l1);
4114 }
4115
4116 static __forceinline__ __device__ void surfCubemapwrite(ulonglong1 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4117 {
4118   __surfModeSwitch(val, surf, x, y, face, mode, l1);
4119 }
4120
4121 static __forceinline__ __device__ void surfCubemapwrite(longlong2 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4122 {
4123   __surfModeSwitch(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, y, face, mode, l2);
4124 }
4125
4126 static __forceinline__ __device__ void surfCubemapwrite(ulonglong2 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4127 {
4128   __surfModeSwitch(val, surf, x, y, face, mode, l2);
4129 }
4130
4131 #if !defined(__LP64__)
4132
4133 static __forceinline__ __device__ void surfCubemapwrite(long int val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4134 {
4135   __surfModeSwitch(make_uint1((unsigned int)val), surf, x, y, face, mode, u1);
4136 }
4137
4138 static __forceinline__ __device__ void surfCubemapwrite(unsigned long int val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4139 {
4140   __surfModeSwitch(make_uint1((unsigned int)val), surf, x, y, face, mode, u1);
4141 }
4142
4143 static __forceinline__ __device__ void surfCubemapwrite(long1 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4144 {
4145   __surfModeSwitch(make_uint1((unsigned int)val.x), surf, x, y, face, mode, u1);
4146 }
4147
4148 static __forceinline__ __device__ void surfCubemapwrite(ulong1 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4149 {
4150   __surfModeSwitch(make_uint1((unsigned int)val.x), surf, x, y, face, mode, u1);
4151 }
4152
4153 static __forceinline__ __device__ void surfCubemapwrite(long2 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4154 {
4155   __surfModeSwitch(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, face, mode, u2);
4156 }
4157
4158 static __forceinline__ __device__ void surfCubemapwrite(ulong2 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4159 {
4160   __surfModeSwitch(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, face, mode, u2);
4161 }
4162
4163 static __forceinline__ __device__ void surfCubemapwrite(long4 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4164 {
4165   __surfModeSwitch(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, face, mode, u4);
4166 }
4167
4168 static __forceinline__ __device__ void surfCubemapwrite(ulong4 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4169 {
4170   __surfModeSwitch(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, face, mode, u4);
4171 }
4172
4173 #endif /* !__LP64__ */
4174
4175 static __forceinline__ __device__ void surfCubemapwrite(float val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4176 {
4177   __surfModeSwitch(make_uint1((unsigned int)__float_as_int(val)), surf, x, y, face, mode, u1);
4178 }
4179
4180 static __forceinline__ __device__ void surfCubemapwrite(float1 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4181 {
4182   __surfModeSwitch(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, y, face, mode, u1);
4183 }
4184
4185 static __forceinline__ __device__ void surfCubemapwrite(float2 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4186 {
4187   __surfModeSwitch(make_uint2((unsigned int)__float_as_int(val.x), __float_as_int((unsigned int)val.y)), surf, x, y, face, mode, u2);
4188 }
4189
4190 static __forceinline__ __device__ void surfCubemapwrite(float4 val, surface<void, cudaSurfaceTypeCubemap> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4191 {
4192   __surfModeSwitch(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, y, face, mode, u4);
4193 }
4194
4195 #undef __surfModeSwitch
4196
4197 /*******************************************************************************
4198 *                                                                              *
4199 *                                                                              *
4200 *                                                                              *
4201 *******************************************************************************/
4202 extern __device__ __device_builtin__ void __surfCubemapLayeredwritec1(    uchar1 val, surface<void, cudaSurfaceTypeCubemapLayered> t, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode);
4203 extern __device__ __device_builtin__ void __surfCubemapLayeredwritec2(    uchar2 val, surface<void, cudaSurfaceTypeCubemapLayered> t, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode);
4204 extern __device__ __device_builtin__ void __surfCubemapLayeredwritec4(    uchar4 val, surface<void, cudaSurfaceTypeCubemapLayered> t, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode);
4205 extern __device__ __device_builtin__ void __surfCubemapLayeredwrites1(   ushort1 val, surface<void, cudaSurfaceTypeCubemapLayered> t, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode);
4206 extern __device__ __device_builtin__ void __surfCubemapLayeredwrites2(   ushort2 val, surface<void, cudaSurfaceTypeCubemapLayered> t, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode);
4207 extern __device__ __device_builtin__ void __surfCubemapLayeredwrites4(   ushort4 val, surface<void, cudaSurfaceTypeCubemapLayered> t, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode);
4208 extern __device__ __device_builtin__ void __surfCubemapLayeredwriteu1(     uint1 val, surface<void, cudaSurfaceTypeCubemapLayered> t, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode);
4209 extern __device__ __device_builtin__ void __surfCubemapLayeredwriteu2(     uint2 val, surface<void, cudaSurfaceTypeCubemapLayered> t, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode);
4210 extern __device__ __device_builtin__ void __surfCubemapLayeredwriteu4(     uint4 val, surface<void, cudaSurfaceTypeCubemapLayered> t, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode);
4211 extern __device__ __device_builtin__ void __surfCubemapLayeredwritel1(ulonglong1 val, surface<void, cudaSurfaceTypeCubemapLayered> t, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode);
4212 extern __device__ __device_builtin__ void __surfCubemapLayeredwritel2(ulonglong2 val, surface<void, cudaSurfaceTypeCubemapLayered> t, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode);
4213
4214 #if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 200
4215
4216 #define __surfModeSwitch(val, surf, x, y, layerFace, mode, type)                                                    \
4217         ((mode == cudaBoundaryModeZero)  ? __surfCubemapLayeredwrite##type(val, surf, x, y, layerFace, cudaBoundaryModeZero ) : \
4218          (mode == cudaBoundaryModeClamp) ? __surfCubemapLayeredwrite##type(val, surf, x, y, layerFace, cudaBoundaryModeClamp) : \
4219                                            __surfCubemapLayeredwrite##type(val, surf, x, y, layerFace, cudaBoundaryModeTrap ))
4220
4221 #else /* __CUDA_ARCH__ && __CUDA_ARCH__ >= 200 */
4222
4223 #define __surfModeSwitch(val, surf, x, y, layerFace, mode, type) \
4224         __surfCubemapLayeredwrite##type(val, surf, x, y, layerFace, cudaBoundaryModeTrap)
4225
4226
4227 #endif /* __CUDA_ARCH__ && __CUDA_ARCH__ >= 200 */
4228
4229 template<class T>
4230 static __forceinline__ __device__ void surfCubemapLayeredwrite(T val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4231 {
4232   union {
4233     T       val;
4234     uchar1  c1;
4235     ushort1 s1;
4236     uint1   u1;
4237     uint2   u2;
4238     uint4   u4;
4239   } tmp;
4240
4241   tmp.val = val;
4242
4243   (s ==  1) ? (void)(__surfModeSwitch(tmp.c1, surf, x, y, layerFace, mode, c1)) :
4244   (s ==  2) ? (void)(__surfModeSwitch(tmp.s1, surf, x, y, layerFace, mode, s1)) :
4245   (s ==  4) ? (void)(__surfModeSwitch(tmp.u1, surf, x, y, layerFace, mode, u1)) :
4246   (s ==  8) ? (void)(__surfModeSwitch(tmp.u2, surf, x, y, layerFace, mode, u2)) :
4247   (s == 16) ? (void)(__surfModeSwitch(tmp.u4, surf, x, y, layerFace, mode, u4)) :
4248               (void)0;
4249 }
4250
4251 template<class T>
4252 static __forceinline__ __device__ void surfCubemapLayeredwrite(T val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4253 {;
4254   surfCubemapLayeredwrite(val, surf, x, y, layerFace, (int)sizeof(T), mode);
4255 }
4256
4257
4258 static __forceinline__ __device__ void surfCubemapLayeredwrite(char val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4259 {
4260   __surfModeSwitch(make_uchar1((unsigned char)val), surf, x, y, layerFace, mode, c1);
4261 }
4262
4263 static __forceinline__ __device__ void surfCubemapLayeredwrite(signed char val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4264 {
4265   __surfModeSwitch(make_uchar1((unsigned char)val), surf, x, y, layerFace, mode, c1);
4266 }
4267
4268 static __forceinline__ __device__ void surfCubemapLayeredwrite(unsigned char val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4269 {
4270   __surfModeSwitch(make_uchar1(val), surf, x, y, layerFace, mode, c1);
4271 }
4272
4273 static __forceinline__ __device__ void surfCubemapLayeredwrite(char1 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4274 {
4275   __surfModeSwitch(make_uchar1((unsigned char)val.x), surf, x, y, layerFace, mode, c1);
4276 }
4277
4278 static __forceinline__ __device__ void surfCubemapLayeredwrite(uchar1 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4279 {
4280   __surfModeSwitch(val, surf, x, y, layerFace, mode, c1);
4281 }
4282
4283 static __forceinline__ __device__ void surfCubemapLayeredwrite(char2 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4284 {
4285   __surfModeSwitch(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, y, layerFace, mode, c2);
4286 }
4287
4288 static __forceinline__ __device__ void surfCubemapLayeredwrite(uchar2 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4289 {
4290   __surfModeSwitch(val, surf, x, y, layerFace, mode, c2);
4291 }
4292
4293 static __forceinline__ __device__ void surfCubemapLayeredwrite(char4 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4294 {
4295   __surfModeSwitch(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, y, layerFace, mode, c4);
4296 }
4297
4298 static __forceinline__ __device__ void surfCubemapLayeredwrite(uchar4 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4299 {
4300   __surfModeSwitch(val, surf, x, y, layerFace, mode, c4);
4301 }
4302
4303 static __forceinline__ __device__ void surfCubemapLayeredwrite(short val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4304 {
4305   __surfModeSwitch(make_ushort1((unsigned short)val), surf, x, y, layerFace, mode, s1);
4306 }
4307
4308 static __forceinline__ __device__ void surfCubemapLayeredwrite(unsigned short val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4309 {
4310   __surfModeSwitch(make_ushort1(val), surf, x, y, layerFace, mode, s1);
4311 }
4312
4313 static __forceinline__ __device__ void surfCubemapLayeredwrite(short1 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4314 {
4315   __surfModeSwitch(make_ushort1((unsigned short)val.x), surf, x, y, layerFace, mode, s1);
4316 }
4317
4318 static __forceinline__ __device__ void surfCubemapLayeredwrite(ushort1 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4319 {
4320   __surfModeSwitch(val, surf, x, y, layerFace, mode, s1);
4321 }
4322
4323 static __forceinline__ __device__ void surfCubemapLayeredwrite(short2 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4324 {
4325   __surfModeSwitch(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, y, layerFace, mode, s2);
4326 }
4327
4328 static __forceinline__ __device__ void surfCubemapLayeredwrite(ushort2 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4329 {
4330   __surfModeSwitch(val, surf, x, y, layerFace, mode, s2);
4331 }
4332
4333 static __forceinline__ __device__ void surfCubemapLayeredwrite(short4 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4334 {
4335   __surfModeSwitch(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, y, layerFace, mode, s4);
4336 }
4337
4338 static __forceinline__ __device__ void surfCubemapLayeredwrite(ushort4 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4339 {
4340   __surfModeSwitch(val, surf, x, y, layerFace, mode, s4);
4341 }
4342
4343 static __forceinline__ __device__ void surfCubemapLayeredwrite(int val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4344 {
4345   __surfModeSwitch(make_uint1((unsigned int)val), surf, x, y, layerFace, mode, u1);
4346 }
4347
4348 static __forceinline__ __device__ void surfCubemapLayeredwrite(unsigned int val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4349 {
4350   __surfModeSwitch(make_uint1(val), surf, x, y, layerFace, mode, u1);
4351 }
4352
4353 static __forceinline__ __device__ void surfCubemapLayeredwrite(int1 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4354 {
4355   __surfModeSwitch(make_uint1((unsigned int)val.x), surf, x, y, layerFace, mode, u1);
4356 }
4357
4358 static __forceinline__ __device__ void surfCubemapLayeredwrite(uint1 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4359 {
4360   __surfModeSwitch(val, surf, x, y, layerFace, mode, u1);
4361 }
4362
4363 static __forceinline__ __device__ void surfCubemapLayeredwrite(int2 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4364 {
4365   __surfModeSwitch(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, layerFace, mode, u2);
4366 }
4367
4368 static __forceinline__ __device__ void surfCubemapLayeredwrite(uint2 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4369 {
4370   __surfModeSwitch(val, surf, x, y, layerFace, mode, u2);
4371 }
4372
4373 static __forceinline__ __device__ void surfCubemapLayeredwrite(int4 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4374 {
4375   __surfModeSwitch(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, layerFace, mode, u4);
4376 }
4377
4378 static __forceinline__ __device__ void surfCubemapLayeredwrite(uint4 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4379 {
4380   __surfModeSwitch(val, surf, x, y, layerFace, mode, u4);
4381 }
4382
4383 static __forceinline__ __device__ void surfCubemapLayeredwrite(long long int val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4384 {
4385   __surfModeSwitch(make_ulonglong1((unsigned long long int)val), surf, x, y, layerFace, mode, l1);
4386 }
4387
4388 static __forceinline__ __device__ void surfCubemapLayeredwrite(unsigned long long int val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4389 {
4390   __surfModeSwitch(make_ulonglong1(val), surf, x, y, layerFace, mode, l1);
4391 }
4392
4393 static __forceinline__ __device__ void surfCubemapLayeredwrite(longlong1 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4394 {
4395   __surfModeSwitch(make_ulonglong1((unsigned long long int)val.x), surf, x, y, layerFace, mode, l1);
4396 }
4397
4398 static __forceinline__ __device__ void surfCubemapLayeredwrite(ulonglong1 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4399 {
4400   __surfModeSwitch(val, surf, x, y, layerFace, mode, l1);
4401 }
4402
4403 static __forceinline__ __device__ void surfCubemapLayeredwrite(longlong2 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4404 {
4405   __surfModeSwitch(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, y, layerFace, mode, l2);
4406 }
4407
4408 static __forceinline__ __device__ void surfCubemapLayeredwrite(ulonglong2 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4409 {
4410   __surfModeSwitch(val, surf, x, y, layerFace, mode, l2);
4411 }
4412
4413 #if !defined(__LP64__)
4414
4415 static __forceinline__ __device__ void surfCubemapLayeredwrite(long int val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4416 {
4417   __surfModeSwitch(make_uint1((unsigned int)val), surf, x, y, layerFace, mode, u1);
4418 }
4419
4420 static __forceinline__ __device__ void surfCubemapLayeredwrite(unsigned long int val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4421 {
4422   __surfModeSwitch(make_uint1((unsigned int)val), surf, x, y, layerFace, mode, u1);
4423 }
4424
4425 static __forceinline__ __device__ void surfCubemapLayeredwrite(long1 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4426 {
4427   __surfModeSwitch(make_uint1((unsigned int)val.x), surf, x, y, layerFace, mode, u1);
4428 }
4429
4430 static __forceinline__ __device__ void surfCubemapLayeredwrite(ulong1 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4431 {
4432   __surfModeSwitch(make_uint1((unsigned int)val.x), surf, x, y, layerFace, mode, u1);
4433 }
4434
4435 static __forceinline__ __device__ void surfCubemapLayeredwrite(long2 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4436 {
4437   __surfModeSwitch(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, layerFace, mode, u2);
4438 }
4439
4440 static __forceinline__ __device__ void surfCubemapLayeredwrite(ulong2 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4441 {
4442   __surfModeSwitch(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, layerFace, mode, u2);
4443 }
4444
4445 static __forceinline__ __device__ void surfCubemapLayeredwrite(long4 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4446 {
4447   __surfModeSwitch(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, layerFace, mode, u4);
4448 }
4449
4450 static __forceinline__ __device__ void surfCubemapLayeredwrite(ulong4 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4451 {
4452   __surfModeSwitch(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, layerFace, mode, u4);
4453 }
4454
4455 #endif /* !__LP64__ */
4456
4457 static __forceinline__ __device__ void surfCubemapLayeredwrite(float val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4458 {
4459   __surfModeSwitch(make_uint1((unsigned int)__float_as_int(val)), surf, x, y, layerFace, mode, u1);
4460 }
4461
4462 static __forceinline__ __device__ void surfCubemapLayeredwrite(float1 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4463 {
4464   __surfModeSwitch(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, y, layerFace, mode, u1);
4465 }
4466
4467 static __forceinline__ __device__ void surfCubemapLayeredwrite(float2 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4468 {
4469   __surfModeSwitch(make_uint2((unsigned int)__float_as_int(val.x), __float_as_int((unsigned int)val.y)), surf, x, y, layerFace, mode, u2);
4470 }
4471
4472 static __forceinline__ __device__ void surfCubemapLayeredwrite(float4 val, surface<void, cudaSurfaceTypeCubemapLayered> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
4473 {
4474   __surfModeSwitch(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, y, layerFace, mode, u4);
4475 }
4476
4477 #undef __surfModeSwitch
4478
4479 /*******************************************************************************
4480 *                                                                              *
4481 *                                                                              *
4482 *                                                                              *
4483 *******************************************************************************/
4484
4485 #elif defined(__CUDABE__)
4486
4487 #if defined(__CUDANVVM__)
4488 extern uchar1     __surf1Dreadc1(unsigned long long, int, enum cudaSurfaceBoundaryMode);
4489 extern uchar2     __surf1Dreadc2(unsigned long long, int, enum cudaSurfaceBoundaryMode);
4490 extern uchar4     __surf1Dreadc4(unsigned long long, int, enum cudaSurfaceBoundaryMode);
4491 extern ushort1    __surf1Dreads1(unsigned long long, int, enum cudaSurfaceBoundaryMode);
4492 extern ushort2    __surf1Dreads2(unsigned long long, int, enum cudaSurfaceBoundaryMode);
4493 extern ushort4    __surf1Dreads4(unsigned long long, int, enum cudaSurfaceBoundaryMode);
4494 extern uint1      __surf1Dreadu1(unsigned long long, int, enum cudaSurfaceBoundaryMode);
4495 extern uint2      __surf1Dreadu2(unsigned long long, int, enum cudaSurfaceBoundaryMode);
4496 extern uint4      __surf1Dreadu4(unsigned long long, int, enum cudaSurfaceBoundaryMode);
4497 extern ulonglong1 __surf1Dreadl1(unsigned long long, int, enum cudaSurfaceBoundaryMode);
4498 extern ulonglong2 __surf1Dreadl2(unsigned long long, int, enum cudaSurfaceBoundaryMode);
4499 extern uchar1     __surf2Dreadc1(unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4500 extern uchar2     __surf2Dreadc2(unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4501 extern uchar4     __surf2Dreadc4(unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4502 extern ushort1    __surf2Dreads1(unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4503 extern ushort2    __surf2Dreads2(unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4504 extern ushort4    __surf2Dreads4(unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4505 extern uint1      __surf2Dreadu1(unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4506 extern uint2      __surf2Dreadu2(unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4507 extern uint4      __surf2Dreadu4(unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4508 extern ulonglong1 __surf2Dreadl1(unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4509 extern ulonglong2 __surf2Dreadl2(unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4510 extern uchar1     __surf3Dreadc1(unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4511 extern uchar2     __surf3Dreadc2(unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4512 extern uchar4     __surf3Dreadc4(unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4513 extern ushort1    __surf3Dreads1(unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4514 extern ushort2    __surf3Dreads2(unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4515 extern ushort4    __surf3Dreads4(unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4516 extern uint1      __surf3Dreadu1(unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4517 extern uint2      __surf3Dreadu2(unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4518 extern uint4      __surf3Dreadu4(unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4519 extern ulonglong1 __surf3Dreadl1(unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4520 extern ulonglong2 __surf3Dreadl2(unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4521 extern uchar1     __surf1DLayeredreadc1(unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4522 extern uchar2     __surf1DLayeredreadc2(unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4523 extern uchar4     __surf1DLayeredreadc4(unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4524 extern ushort1    __surf1DLayeredreads1(unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4525 extern ushort2    __surf1DLayeredreads2(unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4526 extern ushort4    __surf1DLayeredreads4(unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4527 extern uint1      __surf1DLayeredreadu1(unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4528 extern uint2      __surf1DLayeredreadu2(unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4529 extern uint4      __surf1DLayeredreadu4(unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4530 extern ulonglong1 __surf1DLayeredreadl1(unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4531 extern ulonglong2 __surf1DLayeredreadl2(unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4532 extern uchar1     __surf2DLayeredreadc1(unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4533 extern uchar2     __surf2DLayeredreadc2(unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4534 extern uchar4     __surf2DLayeredreadc4(unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4535 extern ushort1    __surf2DLayeredreads1(unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4536 extern ushort2    __surf2DLayeredreads2(unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4537 extern ushort4    __surf2DLayeredreads4(unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4538 extern uint1      __surf2DLayeredreadu1(unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4539 extern uint2      __surf2DLayeredreadu2(unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4540 extern uint4      __surf2DLayeredreadu4(unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4541 extern ulonglong1 __surf2DLayeredreadl1(unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4542 extern ulonglong2 __surf2DLayeredreadl2(unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4543 extern void       __surf1Dwritec1(    uchar1, unsigned long long, int, enum cudaSurfaceBoundaryMode);
4544 extern void       __surf1Dwritec2(    uchar2, unsigned long long, int, enum cudaSurfaceBoundaryMode);
4545 extern void       __surf1Dwritec4(    uchar4, unsigned long long, int, enum cudaSurfaceBoundaryMode);
4546 extern void       __surf1Dwrites1(   ushort1, unsigned long long, int, enum cudaSurfaceBoundaryMode);
4547 extern void       __surf1Dwrites2(   ushort2, unsigned long long, int, enum cudaSurfaceBoundaryMode);
4548 extern void       __surf1Dwrites4(   ushort4, unsigned long long, int, enum cudaSurfaceBoundaryMode);
4549 extern void       __surf1Dwriteu1(     uint1, unsigned long long, int, enum cudaSurfaceBoundaryMode);
4550 extern void       __surf1Dwriteu2(     uint2, unsigned long long, int, enum cudaSurfaceBoundaryMode);
4551 extern void       __surf1Dwriteu4(     uint4, unsigned long long, int, enum cudaSurfaceBoundaryMode);
4552 extern void       __surf1Dwritel1(ulonglong1, unsigned long long, int, enum cudaSurfaceBoundaryMode);
4553 extern void       __surf1Dwritel2(ulonglong2, unsigned long long, int, enum cudaSurfaceBoundaryMode);
4554 extern void       __surf2Dwritec1(    uchar1, unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4555 extern void       __surf2Dwritec2(    uchar2, unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4556 extern void       __surf2Dwritec4(    uchar4, unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4557 extern void       __surf2Dwrites1(   ushort1, unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4558 extern void       __surf2Dwrites2(   ushort2, unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4559 extern void       __surf2Dwrites4(   ushort4, unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4560 extern void       __surf2Dwriteu1(     uint1, unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4561 extern void       __surf2Dwriteu2(     uint2, unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4562 extern void       __surf2Dwriteu4(     uint4, unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4563 extern void       __surf2Dwritel1(ulonglong1, unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4564 extern void       __surf2Dwritel2(ulonglong2, unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4565 extern void       __surf3Dwritec1(    uchar1 val, unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4566 extern void       __surf3Dwritec2(    uchar2 val, unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4567 extern void       __surf3Dwritec4(    uchar4 val, unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4568 extern void       __surf3Dwrites1(   ushort1 val, unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4569 extern void       __surf3Dwrites2(   ushort2 val, unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4570 extern void       __surf3Dwrites4(   ushort4 val, unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4571 extern void       __surf3Dwriteu1(     uint1 val, unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4572 extern void       __surf3Dwriteu2(     uint2 val, unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4573 extern void       __surf3Dwriteu4(     uint4 val, unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4574 extern void       __surf3Dwritel1(ulonglong1 val, unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4575 extern void       __surf3Dwritel2(ulonglong2 val, unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4576 extern void       __surf1DLayeredwritec1(    uchar1 val, unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4577 extern void       __surf1DLayeredwritec2(    uchar2 val, unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4578 extern void       __surf1DLayeredwritec4(    uchar4 val, unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4579 extern void       __surf1DLayeredwrites1(   ushort1 val, unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4580 extern void       __surf1DLayeredwrites2(   ushort2 val, unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4581 extern void       __surf1DLayeredwrites4(   ushort4 val, unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4582 extern void       __surf1DLayeredwriteu1(     uint1 val, unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4583 extern void       __surf1DLayeredwriteu2(     uint2 val, unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4584 extern void       __surf1DLayeredwriteu4(     uint4 val, unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4585 extern void       __surf1DLayeredwritel1(ulonglong1 val, unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4586 extern void       __surf1DLayeredwritel2(ulonglong2 val, unsigned long long, int, int, enum cudaSurfaceBoundaryMode);
4587 extern void       __surf2DLayeredwritec1(    uchar1 val, unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4588 extern void       __surf2DLayeredwritec2(    uchar2 val, unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4589 extern void       __surf2DLayeredwritec4(    uchar4 val, unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4590 extern void       __surf2DLayeredwrites1(   ushort1 val, unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4591 extern void       __surf2DLayeredwrites2(   ushort2 val, unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4592 extern void       __surf2DLayeredwrites4(   ushort4 val, unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4593 extern void       __surf2DLayeredwriteu1(     uint1 val, unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4594 extern void       __surf2DLayeredwriteu2(     uint2 val, unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4595 extern void       __surf2DLayeredwriteu4(     uint4 val, unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4596 extern void       __surf2DLayeredwritel1(ulonglong1 val, unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4597 extern void       __surf2DLayeredwritel2(ulonglong2 val, unsigned long long, int, int, int, enum cudaSurfaceBoundaryMode);
4598 #else /* __CUDANVVM__ */
4599 extern uchar1     __surf1Dreadc1(const void*, int, enum cudaSurfaceBoundaryMode);
4600 extern uchar2     __surf1Dreadc2(const void*, int, enum cudaSurfaceBoundaryMode);
4601 extern uchar4     __surf1Dreadc4(const void*, int, enum cudaSurfaceBoundaryMode);
4602 extern ushort1    __surf1Dreads1(const void*, int, enum cudaSurfaceBoundaryMode);
4603 extern ushort2    __surf1Dreads2(const void*, int, enum cudaSurfaceBoundaryMode);
4604 extern ushort4    __surf1Dreads4(const void*, int, enum cudaSurfaceBoundaryMode);
4605 extern uint1      __surf1Dreadu1(const void*, int, enum cudaSurfaceBoundaryMode);
4606 extern uint2      __surf1Dreadu2(const void*, int, enum cudaSurfaceBoundaryMode);
4607 extern uint4      __surf1Dreadu4(const void*, int, enum cudaSurfaceBoundaryMode);
4608 extern ulonglong1 __surf1Dreadl1(const void*, int, enum cudaSurfaceBoundaryMode);
4609 extern ulonglong2 __surf1Dreadl2(const void*, int, enum cudaSurfaceBoundaryMode);
4610 extern uchar1     __surf2Dreadc1(const void*, int, int, enum cudaSurfaceBoundaryMode);
4611 extern uchar2     __surf2Dreadc2(const void*, int, int, enum cudaSurfaceBoundaryMode);
4612 extern uchar4     __surf2Dreadc4(const void*, int, int, enum cudaSurfaceBoundaryMode);
4613 extern ushort1    __surf2Dreads1(const void*, int, int, enum cudaSurfaceBoundaryMode);
4614 extern ushort2    __surf2Dreads2(const void*, int, int, enum cudaSurfaceBoundaryMode);
4615 extern ushort4    __surf2Dreads4(const void*, int, int, enum cudaSurfaceBoundaryMode);
4616 extern uint1      __surf2Dreadu1(const void*, int, int, enum cudaSurfaceBoundaryMode);
4617 extern uint2      __surf2Dreadu2(const void*, int, int, enum cudaSurfaceBoundaryMode);
4618 extern uint4      __surf2Dreadu4(const void*, int, int, enum cudaSurfaceBoundaryMode);
4619 extern ulonglong1 __surf2Dreadl1(const void*, int, int, enum cudaSurfaceBoundaryMode);
4620 extern ulonglong2 __surf2Dreadl2(const void*, int, int, enum cudaSurfaceBoundaryMode);
4621 extern uchar1     __surf3Dreadc1(const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4622 extern uchar2     __surf3Dreadc2(const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4623 extern uchar4     __surf3Dreadc4(const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4624 extern ushort1    __surf3Dreads1(const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4625 extern ushort2    __surf3Dreads2(const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4626 extern ushort4    __surf3Dreads4(const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4627 extern uint1      __surf3Dreadu1(const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4628 extern uint2      __surf3Dreadu2(const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4629 extern uint4      __surf3Dreadu4(const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4630 extern ulonglong1 __surf3Dreadl1(const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4631 extern ulonglong2 __surf3Dreadl2(const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4632 extern uchar1     __surf1DLayeredreadc1(const void*, int, int, enum cudaSurfaceBoundaryMode);
4633 extern uchar2     __surf1DLayeredreadc2(const void*, int, int, enum cudaSurfaceBoundaryMode);
4634 extern uchar4     __surf1DLayeredreadc4(const void*, int, int, enum cudaSurfaceBoundaryMode);
4635 extern ushort1    __surf1DLayeredreads1(const void*, int, int, enum cudaSurfaceBoundaryMode);
4636 extern ushort2    __surf1DLayeredreads2(const void*, int, int, enum cudaSurfaceBoundaryMode);
4637 extern ushort4    __surf1DLayeredreads4(const void*, int, int, enum cudaSurfaceBoundaryMode);
4638 extern uint1      __surf1DLayeredreadu1(const void*, int, int, enum cudaSurfaceBoundaryMode);
4639 extern uint2      __surf1DLayeredreadu2(const void*, int, int, enum cudaSurfaceBoundaryMode);
4640 extern uint4      __surf1DLayeredreadu4(const void*, int, int, enum cudaSurfaceBoundaryMode);
4641 extern ulonglong1 __surf1DLayeredreadl1(const void*, int, int, enum cudaSurfaceBoundaryMode);
4642 extern ulonglong2 __surf1DLayeredreadl2(const void*, int, int, enum cudaSurfaceBoundaryMode);
4643 extern uchar1     __surf2DLayeredreadc1(const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4644 extern uchar2     __surf2DLayeredreadc2(const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4645 extern uchar4     __surf2DLayeredreadc4(const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4646 extern ushort1    __surf2DLayeredreads1(const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4647 extern ushort2    __surf2DLayeredreads2(const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4648 extern ushort4    __surf2DLayeredreads4(const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4649 extern uint1      __surf2DLayeredreadu1(const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4650 extern uint2      __surf2DLayeredreadu2(const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4651 extern uint4      __surf2DLayeredreadu4(const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4652 extern ulonglong1 __surf2DLayeredreadl1(const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4653 extern ulonglong2 __surf2DLayeredreadl2(const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4654 extern void       __surf1Dwritec1(    uchar1, const void*, int, enum cudaSurfaceBoundaryMode);
4655 extern void       __surf1Dwritec2(    uchar2, const void*, int, enum cudaSurfaceBoundaryMode);
4656 extern void       __surf1Dwritec4(    uchar4, const void*, int, enum cudaSurfaceBoundaryMode);
4657 extern void       __surf1Dwrites1(   ushort1, const void*, int, enum cudaSurfaceBoundaryMode);
4658 extern void       __surf1Dwrites2(   ushort2, const void*, int, enum cudaSurfaceBoundaryMode);
4659 extern void       __surf1Dwrites4(   ushort4, const void*, int, enum cudaSurfaceBoundaryMode);
4660 extern void       __surf1Dwriteu1(     uint1, const void*, int, enum cudaSurfaceBoundaryMode);
4661 extern void       __surf1Dwriteu2(     uint2, const void*, int, enum cudaSurfaceBoundaryMode);
4662 extern void       __surf1Dwriteu4(     uint4, const void*, int, enum cudaSurfaceBoundaryMode);
4663 extern void       __surf1Dwritel1(ulonglong1, const void*, int, enum cudaSurfaceBoundaryMode);
4664 extern void       __surf1Dwritel2(ulonglong2, const void*, int, enum cudaSurfaceBoundaryMode);
4665 extern void       __surf2Dwritec1(    uchar1, const void*, int, int, enum cudaSurfaceBoundaryMode);
4666 extern void       __surf2Dwritec2(    uchar2, const void*, int, int, enum cudaSurfaceBoundaryMode);
4667 extern void       __surf2Dwritec4(    uchar4, const void*, int, int, enum cudaSurfaceBoundaryMode);
4668 extern void       __surf2Dwrites1(   ushort1, const void*, int, int, enum cudaSurfaceBoundaryMode);
4669 extern void       __surf2Dwrites2(   ushort2, const void*, int, int, enum cudaSurfaceBoundaryMode);
4670 extern void       __surf2Dwrites4(   ushort4, const void*, int, int, enum cudaSurfaceBoundaryMode);
4671 extern void       __surf2Dwriteu1(     uint1, const void*, int, int, enum cudaSurfaceBoundaryMode);
4672 extern void       __surf2Dwriteu2(     uint2, const void*, int, int, enum cudaSurfaceBoundaryMode);
4673 extern void       __surf2Dwriteu4(     uint4, const void*, int, int, enum cudaSurfaceBoundaryMode);
4674 extern void       __surf2Dwritel1(ulonglong1, const void*, int, int, enum cudaSurfaceBoundaryMode);
4675 extern void       __surf2Dwritel2(ulonglong2, const void*, int, int, enum cudaSurfaceBoundaryMode);
4676 extern void       __surf3Dwritec1(    uchar1 val, const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4677 extern void       __surf3Dwritec2(    uchar2 val, const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4678 extern void       __surf3Dwritec4(    uchar4 val, const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4679 extern void       __surf3Dwrites1(   ushort1 val, const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4680 extern void       __surf3Dwrites2(   ushort2 val, const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4681 extern void       __surf3Dwrites4(   ushort4 val, const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4682 extern void       __surf3Dwriteu1(     uint1 val, const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4683 extern void       __surf3Dwriteu2(     uint2 val, const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4684 extern void       __surf3Dwriteu4(     uint4 val, const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4685 extern void       __surf3Dwritel1(ulonglong1 val, const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4686 extern void       __surf3Dwritel2(ulonglong2 val, const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4687 extern void       __surf1DLayeredwritec1(    uchar1 val, const void*, int, int, enum cudaSurfaceBoundaryMode);
4688 extern void       __surf1DLayeredwritec2(    uchar2 val, const void*, int, int, enum cudaSurfaceBoundaryMode);
4689 extern void       __surf1DLayeredwritec4(    uchar4 val, const void*, int, int, enum cudaSurfaceBoundaryMode);
4690 extern void       __surf1DLayeredwrites1(   ushort1 val, const void*, int, int, enum cudaSurfaceBoundaryMode);
4691 extern void       __surf1DLayeredwrites2(   ushort2 val, const void*, int, int, enum cudaSurfaceBoundaryMode);
4692 extern void       __surf1DLayeredwrites4(   ushort4 val, const void*, int, int, enum cudaSurfaceBoundaryMode);
4693 extern void       __surf1DLayeredwriteu1(     uint1 val, const void*, int, int, enum cudaSurfaceBoundaryMode);
4694 extern void       __surf1DLayeredwriteu2(     uint2 val, const void*, int, int, enum cudaSurfaceBoundaryMode);
4695 extern void       __surf1DLayeredwriteu4(     uint4 val, const void*, int, int, enum cudaSurfaceBoundaryMode);
4696 extern void       __surf1DLayeredwritel1(ulonglong1 val, const void*, int, int, enum cudaSurfaceBoundaryMode);
4697 extern void       __surf1DLayeredwritel2(ulonglong2 val, const void*, int, int, enum cudaSurfaceBoundaryMode);
4698 extern void       __surf2DLayeredwritec1(    uchar1 val, const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4699 extern void       __surf2DLayeredwritec2(    uchar2 val, const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4700 extern void       __surf2DLayeredwritec4(    uchar4 val, const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4701 extern void       __surf2DLayeredwrites1(   ushort1 val, const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4702 extern void       __surf2DLayeredwrites2(   ushort2 val, const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4703 extern void       __surf2DLayeredwrites4(   ushort4 val, const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4704 extern void       __surf2DLayeredwriteu1(     uint1 val, const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4705 extern void       __surf2DLayeredwriteu2(     uint2 val, const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4706 extern void       __surf2DLayeredwriteu4(     uint4 val, const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4707 extern void       __surf2DLayeredwritel1(ulonglong1 val, const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4708 extern void       __surf2DLayeredwritel2(ulonglong2 val, const void*, int, int, int, enum cudaSurfaceBoundaryMode);
4709 #endif /* __CUDANVVM__ */
4710
4711 // Cubemap and cubemap layered surfaces use 2D Layered instrinsics
4712 #define __surfCubemapreadc1 __surf2DLayeredreadc1
4713 #define __surfCubemapreadc2 __surf2DLayeredreadc2
4714 #define __surfCubemapreadc4 __surf2DLayeredreadc4
4715 #define __surfCubemapreads1 __surf2DLayeredreads1
4716 #define __surfCubemapreads2 __surf2DLayeredreads2
4717 #define __surfCubemapreads4 __surf2DLayeredreads4
4718 #define __surfCubemapreadu1 __surf2DLayeredreadu1
4719 #define __surfCubemapreadu2 __surf2DLayeredreadu2
4720 #define __surfCubemapreadu4 __surf2DLayeredreadu4
4721 #define __surfCubemapreadl1 __surf2DLayeredreadl1
4722 #define __surfCubemapreadl2 __surf2DLayeredreadl2
4723 #define __surfCubemapLayeredreadc1 __surf2DLayeredreadc1
4724 #define __surfCubemapLayeredreadc2 __surf2DLayeredreadc2
4725 #define __surfCubemapLayeredreadc4 __surf2DLayeredreadc4
4726 #define __surfCubemapLayeredreads1 __surf2DLayeredreads1
4727 #define __surfCubemapLayeredreads2 __surf2DLayeredreads2
4728 #define __surfCubemapLayeredreads4 __surf2DLayeredreads4
4729 #define __surfCubemapLayeredreadu1 __surf2DLayeredreadu1
4730 #define __surfCubemapLayeredreadu2 __surf2DLayeredreadu2
4731 #define __surfCubemapLayeredreadu4 __surf2DLayeredreadu4
4732 #define __surfCubemapLayeredreadl1 __surf2DLayeredreadl1
4733 #define __surfCubemapLayeredreadl2 __surf2DLayeredreadl2
4734
4735 #define __surfCubemapwritec1 __surf2DLayeredwritec1
4736 #define __surfCubemapwritec2 __surf2DLayeredwritec2
4737 #define __surfCubemapwritec4 __surf2DLayeredwritec4
4738 #define __surfCubemapwrites1 __surf2DLayeredwrites1
4739 #define __surfCubemapwrites2 __surf2DLayeredwrites2
4740 #define __surfCubemapwrites4 __surf2DLayeredwrites4
4741 #define __surfCubemapwriteu1 __surf2DLayeredwriteu1
4742 #define __surfCubemapwriteu2 __surf2DLayeredwriteu2
4743 #define __surfCubemapwriteu4 __surf2DLayeredwriteu4
4744 #define __surfCubemapwritel1 __surf2DLayeredwritel1
4745 #define __surfCubemapwritel2 __surf2DLayeredwritel2
4746 #define __surfCubemapLayeredwritec1 __surf2DLayeredwritec1
4747 #define __surfCubemapLayeredwritec2 __surf2DLayeredwritec2
4748 #define __surfCubemapLayeredwritec4 __surf2DLayeredwritec4
4749 #define __surfCubemapLayeredwrites1 __surf2DLayeredwrites1
4750 #define __surfCubemapLayeredwrites2 __surf2DLayeredwrites2
4751 #define __surfCubemapLayeredwrites4 __surf2DLayeredwrites4
4752 #define __surfCubemapLayeredwriteu1 __surf2DLayeredwriteu1
4753 #define __surfCubemapLayeredwriteu2 __surf2DLayeredwriteu2
4754 #define __surfCubemapLayeredwriteu4 __surf2DLayeredwriteu4
4755 #define __surfCubemapLayeredwritel1 __surf2DLayeredwritel1
4756 #define __surfCubemapLayeredwritel2 __surf2DLayeredwritel2
4757
4758 #endif /* __cplusplus && __CUDACC__ */
4759
4760 #endif /* !__SURFACE_FUNCTIONS_H__ */