Skip to content

Commit b9a7823

Browse files
committed
Replace CUB_RUNTIME_FUNCTION with THRUST_RUNTIME_FUNCTION.
Replace CUDA_VERSION (only available if <cuda.h> is included) with CUDART_VERSION.
1 parent 8635951 commit b9a7823

File tree

11 files changed

+169
-169
lines changed

11 files changed

+169
-169
lines changed

dependencies/cub

Submodule cub updated from 464a90b to 04d36e6

testing/vector.cu

Lines changed: 62 additions & 62 deletions
Original file line numberDiff line numberDiff line change
@@ -119,7 +119,7 @@ void TestVectorFromSTLVector(void)
119119
ASSERT_EQUAL(v[2], 2);
120120

121121
v = stl_vector;
122-
122+
123123
ASSERT_EQUAL(v.size(), 3lu);
124124
ASSERT_EQUAL(v[0], 0);
125125
ASSERT_EQUAL(v[1], 1);
@@ -169,7 +169,7 @@ template <class Vector>
169169
void TestVectorFromBiDirectionalIterator(void)
170170
{
171171
typedef typename Vector::value_type T;
172-
172+
173173
std::list<T> stl_list;
174174
stl_list.push_back(0);
175175
stl_list.push_back(1);
@@ -189,7 +189,7 @@ template <class Vector>
189189
void TestVectorAssignFromBiDirectionalIterator(void)
190190
{
191191
typedef typename Vector::value_type T;
192-
192+
193193
std::list<T> stl_list;
194194
stl_list.push_back(0);
195195
stl_list.push_back(1);
@@ -246,7 +246,7 @@ void TestVectorToAndFromHostVector(void)
246246
v[1] = 11;
247247
v[2] = 12;
248248

249-
ASSERT_EQUAL(h[0], 0); ASSERT_EQUAL(v[0], 10);
249+
ASSERT_EQUAL(h[0], 0); ASSERT_EQUAL(v[0], 10);
250250
ASSERT_EQUAL(h[1], 1); ASSERT_EQUAL(v[1], 11);
251251
ASSERT_EQUAL(h[2], 2); ASSERT_EQUAL(v[2], 12);
252252

@@ -303,7 +303,7 @@ void TestVectorToAndFromDeviceVector(void)
303303
v[1] = 11;
304304
v[2] = 12;
305305

306-
ASSERT_EQUAL(h[0], 0); ASSERT_EQUAL(v[0], 10);
306+
ASSERT_EQUAL(h[0], 0); ASSERT_EQUAL(v[0], 10);
307307
ASSERT_EQUAL(h[1], 1); ASSERT_EQUAL(v[1], 11);
308308
ASSERT_EQUAL(h[2], 2); ASSERT_EQUAL(v[2], 12);
309309

@@ -348,7 +348,7 @@ void TestVectorSwap(void)
348348

349349
v.swap(u);
350350

351-
ASSERT_EQUAL(v[0], 10); ASSERT_EQUAL(u[0], 0);
351+
ASSERT_EQUAL(v[0], 10); ASSERT_EQUAL(u[0], 0);
352352
ASSERT_EQUAL(v[1], 11); ASSERT_EQUAL(u[1], 1);
353353
ASSERT_EQUAL(v[2], 12); ASSERT_EQUAL(u[2], 2);
354354
}
@@ -363,33 +363,33 @@ void TestVectorErasePosition(void)
363363

364364
v.erase(v.begin() + 2);
365365

366-
ASSERT_EQUAL(v.size(), 4lu);
367-
ASSERT_EQUAL(v[0], 0);
368-
ASSERT_EQUAL(v[1], 1);
369-
ASSERT_EQUAL(v[2], 3);
370-
ASSERT_EQUAL(v[3], 4);
371-
366+
ASSERT_EQUAL(v.size(), 4lu);
367+
ASSERT_EQUAL(v[0], 0);
368+
ASSERT_EQUAL(v[1], 1);
369+
ASSERT_EQUAL(v[2], 3);
370+
ASSERT_EQUAL(v[3], 4);
371+
372372
v.erase(v.begin() + 0);
373373

374-
ASSERT_EQUAL(v.size(), 3lu);
375-
ASSERT_EQUAL(v[0], 1);
376-
ASSERT_EQUAL(v[1], 3);
377-
ASSERT_EQUAL(v[2], 4);
378-
374+
ASSERT_EQUAL(v.size(), 3lu);
375+
ASSERT_EQUAL(v[0], 1);
376+
ASSERT_EQUAL(v[1], 3);
377+
ASSERT_EQUAL(v[2], 4);
378+
379379
v.erase(v.begin() + 2);
380380

381-
ASSERT_EQUAL(v.size(), 2lu);
382-
ASSERT_EQUAL(v[0], 1);
383-
ASSERT_EQUAL(v[1], 3);
384-
381+
ASSERT_EQUAL(v.size(), 2lu);
382+
ASSERT_EQUAL(v[0], 1);
383+
ASSERT_EQUAL(v[1], 3);
384+
385385
v.erase(v.begin() + 1);
386386

387-
ASSERT_EQUAL(v.size(), 1lu);
388-
ASSERT_EQUAL(v[0], 1);
387+
ASSERT_EQUAL(v.size(), 1lu);
388+
ASSERT_EQUAL(v[0], 1);
389389

390390
v.erase(v.begin() + 0);
391391

392-
ASSERT_EQUAL(v.size(), 0lu);
392+
ASSERT_EQUAL(v.size(), 0lu);
393393
}
394394
DECLARE_VECTOR_UNITTEST(TestVectorErasePosition);
395395

@@ -402,26 +402,26 @@ void TestVectorEraseRange(void)
402402

403403
v.erase(v.begin() + 1, v.begin() + 3);
404404

405-
ASSERT_EQUAL(v.size(), 4lu);
406-
ASSERT_EQUAL(v[0], 0);
407-
ASSERT_EQUAL(v[1], 3);
408-
ASSERT_EQUAL(v[2], 4);
409-
ASSERT_EQUAL(v[3], 5);
410-
405+
ASSERT_EQUAL(v.size(), 4lu);
406+
ASSERT_EQUAL(v[0], 0);
407+
ASSERT_EQUAL(v[1], 3);
408+
ASSERT_EQUAL(v[2], 4);
409+
ASSERT_EQUAL(v[3], 5);
410+
411411
v.erase(v.begin() + 2, v.end());
412412

413-
ASSERT_EQUAL(v.size(), 2lu);
414-
ASSERT_EQUAL(v[0], 0);
415-
ASSERT_EQUAL(v[1], 3);
416-
413+
ASSERT_EQUAL(v.size(), 2lu);
414+
ASSERT_EQUAL(v[0], 0);
415+
ASSERT_EQUAL(v[1], 3);
416+
417417
v.erase(v.begin() + 0, v.begin() + 1);
418418

419-
ASSERT_EQUAL(v.size(), 1lu);
420-
ASSERT_EQUAL(v[0], 3);
421-
419+
ASSERT_EQUAL(v.size(), 1lu);
420+
ASSERT_EQUAL(v[0], 3);
421+
422422
v.erase(v.begin(), v.end());
423423

424-
ASSERT_EQUAL(v.size(), 0lu);
424+
ASSERT_EQUAL(v.size(), 0lu);
425425
}
426426
DECLARE_VECTOR_UNITTEST(TestVectorEraseRange);
427427

@@ -449,37 +449,37 @@ void TestVectorEquality(void)
449449
s_b[0] = 0; s_b[1] = 1; s_b[2] = 3;
450450
s_b[0] = 0; s_b[1] = 1;
451451

452-
ASSERT_EQUAL((h_a == h_a), true); ASSERT_EQUAL((h_a == d_a), true); ASSERT_EQUAL((d_a == h_a), true); ASSERT_EQUAL((d_a == d_a), true);
452+
ASSERT_EQUAL((h_a == h_a), true); ASSERT_EQUAL((h_a == d_a), true); ASSERT_EQUAL((d_a == h_a), true); ASSERT_EQUAL((d_a == d_a), true);
453453
ASSERT_EQUAL((h_b == h_b), true); ASSERT_EQUAL((h_b == d_b), true); ASSERT_EQUAL((d_b == h_b), true); ASSERT_EQUAL((d_b == d_b), true);
454454
ASSERT_EQUAL((h_c == h_c), true); ASSERT_EQUAL((h_c == d_c), true); ASSERT_EQUAL((d_c == h_c), true); ASSERT_EQUAL((d_c == d_c), true);
455455

456456
// test vector vs device_vector
457-
ASSERT_EQUAL((s_a == d_a), true); ASSERT_EQUAL((d_a == s_a), true);
457+
ASSERT_EQUAL((s_a == d_a), true); ASSERT_EQUAL((d_a == s_a), true);
458458
ASSERT_EQUAL((s_b == d_b), true); ASSERT_EQUAL((d_b == s_b), true);
459459
ASSERT_EQUAL((s_c == d_c), true); ASSERT_EQUAL((d_c == s_c), true);
460460

461461
// test vector vs host_vector
462-
ASSERT_EQUAL((s_a == h_a), true); ASSERT_EQUAL((h_a == s_a), true);
462+
ASSERT_EQUAL((s_a == h_a), true); ASSERT_EQUAL((h_a == s_a), true);
463463
ASSERT_EQUAL((s_b == h_b), true); ASSERT_EQUAL((h_b == s_b), true);
464464
ASSERT_EQUAL((s_c == h_c), true); ASSERT_EQUAL((h_c == s_c), true);
465465

466-
ASSERT_EQUAL((h_a == h_b), false); ASSERT_EQUAL((h_a == d_b), false); ASSERT_EQUAL((d_a == h_b), false); ASSERT_EQUAL((d_a == d_b), false);
466+
ASSERT_EQUAL((h_a == h_b), false); ASSERT_EQUAL((h_a == d_b), false); ASSERT_EQUAL((d_a == h_b), false); ASSERT_EQUAL((d_a == d_b), false);
467467
ASSERT_EQUAL((h_b == h_a), false); ASSERT_EQUAL((h_b == d_a), false); ASSERT_EQUAL((d_b == h_a), false); ASSERT_EQUAL((d_b == d_a), false);
468468
ASSERT_EQUAL((h_a == h_c), false); ASSERT_EQUAL((h_a == d_c), false); ASSERT_EQUAL((d_a == h_c), false); ASSERT_EQUAL((d_a == d_c), false);
469469
ASSERT_EQUAL((h_c == h_a), false); ASSERT_EQUAL((h_c == d_a), false); ASSERT_EQUAL((d_c == h_a), false); ASSERT_EQUAL((d_c == d_a), false);
470470
ASSERT_EQUAL((h_b == h_c), false); ASSERT_EQUAL((h_b == d_c), false); ASSERT_EQUAL((d_b == h_c), false); ASSERT_EQUAL((d_b == d_c), false);
471471
ASSERT_EQUAL((h_c == h_b), false); ASSERT_EQUAL((h_c == d_b), false); ASSERT_EQUAL((d_c == h_b), false); ASSERT_EQUAL((d_c == d_b), false);
472472

473473
// test vector vs device_vector
474-
ASSERT_EQUAL((s_a == d_b), false); ASSERT_EQUAL((d_a == s_b), false);
474+
ASSERT_EQUAL((s_a == d_b), false); ASSERT_EQUAL((d_a == s_b), false);
475475
ASSERT_EQUAL((s_b == d_a), false); ASSERT_EQUAL((d_b == s_a), false);
476476
ASSERT_EQUAL((s_a == d_c), false); ASSERT_EQUAL((d_a == s_c), false);
477477
ASSERT_EQUAL((s_c == d_a), false); ASSERT_EQUAL((d_c == s_a), false);
478478
ASSERT_EQUAL((s_b == d_c), false); ASSERT_EQUAL((d_b == s_c), false);
479479
ASSERT_EQUAL((s_c == d_b), false); ASSERT_EQUAL((d_c == s_b), false);
480480

481481
// test vector vs host_vector
482-
ASSERT_EQUAL((s_a == h_b), false); ASSERT_EQUAL((h_a == s_b), false);
482+
ASSERT_EQUAL((s_a == h_b), false); ASSERT_EQUAL((h_a == s_b), false);
483483
ASSERT_EQUAL((s_b == h_a), false); ASSERT_EQUAL((h_b == s_a), false);
484484
ASSERT_EQUAL((s_a == h_c), false); ASSERT_EQUAL((h_a == s_c), false);
485485
ASSERT_EQUAL((s_c == h_a), false); ASSERT_EQUAL((h_c == s_a), false);
@@ -511,37 +511,37 @@ void TestVectorInequality(void)
511511
s_b[0] = 0; s_b[1] = 1; s_b[2] = 3;
512512
s_b[0] = 0; s_b[1] = 1;
513513

514-
ASSERT_EQUAL((h_a != h_a), false); ASSERT_EQUAL((h_a != d_a), false); ASSERT_EQUAL((d_a != h_a), false); ASSERT_EQUAL((d_a != d_a), false);
514+
ASSERT_EQUAL((h_a != h_a), false); ASSERT_EQUAL((h_a != d_a), false); ASSERT_EQUAL((d_a != h_a), false); ASSERT_EQUAL((d_a != d_a), false);
515515
ASSERT_EQUAL((h_b != h_b), false); ASSERT_EQUAL((h_b != d_b), false); ASSERT_EQUAL((d_b != h_b), false); ASSERT_EQUAL((d_b != d_b), false);
516516
ASSERT_EQUAL((h_c != h_c), false); ASSERT_EQUAL((h_c != d_c), false); ASSERT_EQUAL((d_c != h_c), false); ASSERT_EQUAL((d_c != d_c), false);
517517

518518
// test vector vs device_vector
519-
ASSERT_EQUAL((s_a != d_a), false); ASSERT_EQUAL((d_a != s_a), false);
519+
ASSERT_EQUAL((s_a != d_a), false); ASSERT_EQUAL((d_a != s_a), false);
520520
ASSERT_EQUAL((s_b != d_b), false); ASSERT_EQUAL((d_b != s_b), false);
521521
ASSERT_EQUAL((s_c != d_c), false); ASSERT_EQUAL((d_c != s_c), false);
522522

523523
// test vector vs host_vector
524-
ASSERT_EQUAL((s_a != h_a), false); ASSERT_EQUAL((h_a != s_a), false);
524+
ASSERT_EQUAL((s_a != h_a), false); ASSERT_EQUAL((h_a != s_a), false);
525525
ASSERT_EQUAL((s_b != h_b), false); ASSERT_EQUAL((h_b != s_b), false);
526526
ASSERT_EQUAL((s_c != h_c), false); ASSERT_EQUAL((h_c != s_c), false);
527527

528-
ASSERT_EQUAL((h_a != h_b), true); ASSERT_EQUAL((h_a != d_b), true); ASSERT_EQUAL((d_a != h_b), true); ASSERT_EQUAL((d_a != d_b), true);
528+
ASSERT_EQUAL((h_a != h_b), true); ASSERT_EQUAL((h_a != d_b), true); ASSERT_EQUAL((d_a != h_b), true); ASSERT_EQUAL((d_a != d_b), true);
529529
ASSERT_EQUAL((h_b != h_a), true); ASSERT_EQUAL((h_b != d_a), true); ASSERT_EQUAL((d_b != h_a), true); ASSERT_EQUAL((d_b != d_a), true);
530530
ASSERT_EQUAL((h_a != h_c), true); ASSERT_EQUAL((h_a != d_c), true); ASSERT_EQUAL((d_a != h_c), true); ASSERT_EQUAL((d_a != d_c), true);
531531
ASSERT_EQUAL((h_c != h_a), true); ASSERT_EQUAL((h_c != d_a), true); ASSERT_EQUAL((d_c != h_a), true); ASSERT_EQUAL((d_c != d_a), true);
532532
ASSERT_EQUAL((h_b != h_c), true); ASSERT_EQUAL((h_b != d_c), true); ASSERT_EQUAL((d_b != h_c), true); ASSERT_EQUAL((d_b != d_c), true);
533533
ASSERT_EQUAL((h_c != h_b), true); ASSERT_EQUAL((h_c != d_b), true); ASSERT_EQUAL((d_c != h_b), true); ASSERT_EQUAL((d_c != d_b), true);
534534

535535
// test vector vs device_vector
536-
ASSERT_EQUAL((s_a != d_b), true); ASSERT_EQUAL((d_a != s_b), true);
536+
ASSERT_EQUAL((s_a != d_b), true); ASSERT_EQUAL((d_a != s_b), true);
537537
ASSERT_EQUAL((s_b != d_a), true); ASSERT_EQUAL((d_b != s_a), true);
538538
ASSERT_EQUAL((s_a != d_c), true); ASSERT_EQUAL((d_a != s_c), true);
539539
ASSERT_EQUAL((s_c != d_a), true); ASSERT_EQUAL((d_c != s_a), true);
540540
ASSERT_EQUAL((s_b != d_c), true); ASSERT_EQUAL((d_b != s_c), true);
541541
ASSERT_EQUAL((s_c != d_b), true); ASSERT_EQUAL((d_c != s_b), true);
542542

543543
// test vector vs host_vector
544-
ASSERT_EQUAL((s_a != h_b), true); ASSERT_EQUAL((h_a != s_b), true);
544+
ASSERT_EQUAL((s_a != h_b), true); ASSERT_EQUAL((h_a != s_b), true);
545545
ASSERT_EQUAL((s_b != h_a), true); ASSERT_EQUAL((h_b != s_a), true);
546546
ASSERT_EQUAL((s_a != h_c), true); ASSERT_EQUAL((h_a != s_c), true);
547547
ASSERT_EQUAL((s_c != h_a), true); ASSERT_EQUAL((h_c != s_a), true);
@@ -585,8 +585,8 @@ void TestVectorResizing(void)
585585

586586
ASSERT_EQUAL(v.size(), 0lu);
587587

588-
// TODO remove this WAR
589-
#if defined(__CUDACC__) && CUDA_VERSION==3000
588+
// TODO remove this WAR
589+
#if defined(__CUDACC__) && CUDART_VERSION==3000
590590
// depending on sizeof(T), we will receive one
591591
// of two possible exceptions
592592
try
@@ -599,7 +599,7 @@ void TestVectorResizing(void)
599599
// reset the CUDA error
600600
cudaGetLastError();
601601
} // end catch
602-
#endif // defined(__CUDACC__) && CUDA_VERSION==3000
602+
#endif // defined(__CUDACC__) && CUDART_VERSION==3000
603603

604604
ASSERT_EQUAL(v.size(), 0lu);
605605
}
@@ -622,15 +622,15 @@ void TestVectorReserving(void)
622622

623623
ASSERT_EQUAL(v.capacity(), old_capacity);
624624

625-
// TODO remove this WAR
626-
#if defined(__CUDACC__) && CUDA_VERSION==3000
625+
// TODO remove this WAR
626+
#if defined(__CUDACC__) && CUDART_VERSION==3000
627627
try
628628
{
629629
v.reserve(std::numeric_limits<size_t>::max());
630630
}
631631
catch(std::length_error e) {}
632632
catch(std::bad_alloc e) {}
633-
#endif // defined(__CUDACC__) && CUDA_VERSION==3000
633+
#endif // defined(__CUDACC__) && CUDART_VERSION==3000
634634

635635
ASSERT_EQUAL(v.capacity(), old_capacity);
636636
}
@@ -680,7 +680,7 @@ struct LargeStruct
680680

681681
void TestVectorContainingLargeType(void)
682682
{
683-
// Thrust issue #5
683+
// Thrust issue #5
684684
// http://code.google.com/p/thrust/issues/detail?id=5
685685
const static int N = 100;
686686
typedef LargeStruct<N> T;
@@ -692,9 +692,9 @@ void TestVectorContainingLargeType(void)
692692

693693
thrust::device_vector<T> dv2(20);
694694
thrust::host_vector<T> hv2(20);
695-
695+
696696
ASSERT_EQUAL_QUIET(dv2, hv2);
697-
697+
698698
// initialize tofirst element to something nonzero
699699
T ls;
700700

@@ -703,15 +703,15 @@ void TestVectorContainingLargeType(void)
703703

704704
thrust::device_vector<T> dv3(20, ls);
705705
thrust::host_vector<T> hv3(20, ls);
706-
706+
707707
ASSERT_EQUAL_QUIET(dv3, hv3);
708-
708+
709709
// change first element
710710
ls.data[0] = -13;
711711

712712
dv3[2] = ls;
713713
hv3[2] = ls;
714-
714+
715715
ASSERT_EQUAL_QUIET(dv3, hv3);
716716
}
717717
DECLARE_UNITTEST(TestVectorContainingLargeType);

thrust/detail/complex/c99math.h

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,7 @@
1414
* See the License for the specific language governing permissions and
1515
* limitations under the License.
1616
*/
17-
#pragma once
17+
#pragma once
1818

1919
#include <cmath>
2020
#include <thrust/detail/complex/math_private.h>
@@ -27,7 +27,7 @@ namespace complex
2727
{
2828

2929
// Define basic arithmetic functions so we can use them without explicit scope
30-
// keeping the code as close as possible to FreeBSDs for ease of maintenance.
30+
// keeping the code as close as possible to FreeBSDs for ease of maintenance.
3131
// It also provides an easy way to support compilers with missing C99 functions.
3232
// When possible, just use the names in the global scope.
3333
// Some platforms define these as macros, others as free functions.
@@ -105,7 +105,7 @@ __host__ __device__ inline int isfinite(double x){
105105
// sometimes the CUDA toolkit provides these these names as macros,
106106
// sometimes functions in the global scope
107107

108-
# if (CUDA_VERSION >= 6500)
108+
# if (CUDART_VERSION >= 6500)
109109
using ::isinf;
110110
using ::isnan;
111111
using ::signbit;
@@ -114,7 +114,7 @@ using ::isfinite;
114114
# else
115115
// these names are macros, we don't need to define them
116116

117-
# endif // CUDA_VERSION
117+
# endif // CUDART_VERSION
118118

119119
# else
120120
// Some compilers do not provide these in the global scope
@@ -128,7 +128,7 @@ using std::isfinite;
128128

129129
using ::atanh;
130130
#endif // _MSC_VER
131-
131+
132132
#if defined _MSC_VER
133133

134134
__host__ __device__ inline double copysign(double x, double y){
@@ -159,7 +159,7 @@ inline double log1p(double x){
159159
}else{
160160
if(u > 2.0){
161161
// Use normal log for large arguments
162-
return log(u);
162+
return log(u);
163163
}else{
164164
return log(u)*(x/(u-1.0));
165165
}
@@ -173,7 +173,7 @@ inline float log1pf(float x){
173173
}else{
174174
if(u > 2.0f){
175175
// Use normal log for large arguments
176-
return logf(u);
176+
return logf(u);
177177
}else{
178178
return logf(u)*(x/(u-1.0f));
179179
}
@@ -202,4 +202,4 @@ inline double hypot(double x, double y){
202202
} // namespace detail
203203

204204
} // namespace thrust
205-
205+

thrust/detail/config/global_workarounds.h

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@
2020

2121
// XXX workaround gcc 4.8+'s complaints about unused local typedefs by silencing them globally
2222
#if defined(THRUST_GCC_VERSION) && (THRUST_GCC_VERSION >= 40800)
23-
# if defined(__NVCC__) && (CUDA_VERSION >= 6000)
23+
# if defined(__NVCC__) && (CUDART_VERSION >= 6000)
2424
# pragma GCC diagnostic ignored "-Wunused-local-typedefs"
2525
# endif // nvcc & cuda 6+
2626
#endif // gcc 4.8

0 commit comments

Comments
 (0)