Skip to content

Commit ff66540

Browse files
joeatoddjoeatodd
committed
More informative (& better formatted) static_assert message
1 parent 7203dea commit ff66540

File tree

2 files changed

+91
-24
lines changed

2 files changed

+91
-24
lines changed

‎sycl/include/syclcompat/memory.hpp‎

Lines changed: 87 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -609,7 +609,10 @@ memcpy(sycl::queue q, void *to_ptr, const void *from_ptr,
609609
sycl::range<3> to_range, sycl::range<3> from_range, sycl::id<3> to_id,
610610
sycl::id<3> from_id, sycl::range<3> size,
611611
const std::vector<sycl::event> &dep_events = {}) {
612-
static_assert(std::is_same_v<T, void>, "This syclcompat::detail::memcpy overload only accepts a dummy template parameter.");
612+
static_assert(
613+
std::is_same_v<T, void>,
614+
"This syclcompat::detail::memcpy overload only accepts a dummy template "
615+
"parameter, T = void, which prevents SYCL kernel generation by default.");
613616
std::vector<sycl::event> event_list;
614617

615618
size_t to_slice = to_range.get(1) * to_range.get(0);
@@ -732,7 +735,10 @@ template <typename T = void>
732735
static inline std::vector<sycl::event>
733736
memcpy(sycl::queue q, pitched_data to, sycl::id<3> to_id, pitched_data from,
734737
sycl::id<3> from_id, sycl::range<3> size) {
735-
static_assert(std::is_same_v<T, void>, "This syclcompat::detail::memcpy overload only accepts a dummy template parameter.");
738+
static_assert(
739+
std::is_same_v<T, void>,
740+
"This syclcompat::detail::memcpy overload only accepts a dummy template "
741+
"parameter, T = void, which prevents SYCL kernel generation by default.");
736742
return memcpy(q, to.get_data_ptr(), from.get_data_ptr(),
737743
sycl::range<3>(to.get_pitch(), to.get_y(), 1),
738744
sycl::range<3>(from.get_pitch(), from.get_y(), 1), to_id,
@@ -744,7 +750,10 @@ template <typename T = void>
744750
static inline std::vector<sycl::event>
745751
memcpy(sycl::queue q, void *to_ptr, const void *from_ptr, size_t to_pitch,
746752
size_t from_pitch, size_t x, size_t y) {
747-
static_assert(std::is_same_v<T, void>, "This syclcompat::detail::memcpy overload only accepts a dummy template parameter.");
753+
static_assert(
754+
std::is_same_v<T, void>,
755+
"This syclcompat::detail::memcpy overload only accepts a dummy template "
756+
"parameter, T = void, which prevents SYCL kernel generation by default.");
748757
return memcpy(q, to_ptr, from_ptr, sycl::range<3>(to_pitch, y, 1),
749758
sycl::range<3>(from_pitch, y, 1), sycl::id<3>(0, 0, 0),
750759
sycl::id<3>(0, 0, 0), sycl::range<3>(x, y, 1));
@@ -759,7 +768,6 @@ static sycl::event combine_events(std::vector<sycl::event> &events,
759768
cgh.host_task([]() {});
760769
});
761770
}
762-
763771
} // namespace detail
764772

765773
#ifdef SYCLCOMPAT_USM_LEVEL_NONE
@@ -864,7 +872,10 @@ namespace detail {
864872
template <typename T = void>
865873
static inline std::vector<sycl::event>
866874
memcpy(sycl::queue q, const experimental::memcpy_parameter &param) {
867-
static_assert(std::is_same_v<T, void>, "This syclcompat::experimental::detail::memcpy overload only accepts a dummy template parameter.");
875+
static_assert(std::is_same_v<T, void>,
876+
"This syclcompat::experimental::detail::memcpy overload only "
877+
"accepts a dummy template parameter, T = void, which prevents "
878+
"SYCL kernel generation by default.");
868879
auto to = param.to.pitched;
869880
auto from = param.from.pitched;
870881
#ifdef SYCL_EXT_ONEAPI_BINDLESS_IMAGES
@@ -1143,7 +1154,10 @@ template <typename T = void>
11431154
static inline void memcpy(void *to_ptr, size_t to_pitch, const void *from_ptr,
11441155
size_t from_pitch, size_t x, size_t y,
11451156
sycl::queue q = get_default_queue()) {
1146-
static_assert(std::is_same_v<T, void>, "This syclcompat::memcpy overload only accepts a dummy template parameter.");
1157+
static_assert(
1158+
std::is_same_v<T, void>,
1159+
"This syclcompat::memcpy overload only accepts a dummy template "
1160+
"parameter, T = void, which prevents SYCL kernel generation by default.");
11471161
sycl::event::wait(
11481162
detail::memcpy(q, to_ptr, from_ptr, to_pitch, from_pitch, x, y));
11491163
}
@@ -1170,7 +1184,10 @@ static inline sycl::event memcpy_async(void *to_ptr, size_t to_pitch,
11701184
const void *from_ptr, size_t from_pitch,
11711185
size_t x, size_t y,
11721186
sycl::queue q = get_default_queue()) {
1173-
static_assert(std::is_same_v<T, void>, "This syclcompat::memcpy overload only accepts a dummy template parameter.");
1187+
static_assert(
1188+
std::is_same_v<T, void>,
1189+
"This syclcompat::memcpy overload only accepts a dummy template "
1190+
"parameter, T = void, which prevents SYCL kernel generation by default.");
11741191
auto events = detail::memcpy(q, to_ptr, from_ptr, to_pitch, from_pitch, x, y);
11751192
return detail::combine_events(events, q);
11761193
}
@@ -1194,7 +1211,10 @@ static inline void memcpy(pitched_data to, sycl::id<3> to_pos,
11941211
pitched_data from, sycl::id<3> from_pos,
11951212
sycl::range<3> size,
11961213
sycl::queue q = get_default_queue()) {
1197-
static_assert(std::is_same_v<T, void>, "This syclcompat::memcpy overload only accepts a dummy template parameter.");
1214+
static_assert(
1215+
std::is_same_v<T, void>,
1216+
"This syclcompat::memcpy overload only accepts a dummy template "
1217+
"parameter, T = void, which prevents SYCL kernel generation by default.");
11981218
sycl::event::wait(detail::memcpy(q, to, to_pos, from, from_pos, size));
11991219
}
12001220
} // namespace
@@ -1216,7 +1236,10 @@ static inline sycl::event memcpy_async(pitched_data to, sycl::id<3> to_pos,
12161236
pitched_data from, sycl::id<3> from_pos,
12171237
sycl::range<3> size,
12181238
sycl::queue q = get_default_queue()) {
1219-
static_assert(std::is_same_v<T, void>, "This syclcompat::memcpy overload only accepts a dummy template parameter.");
1239+
static_assert(
1240+
std::is_same_v<T, void>,
1241+
"This syclcompat::memcpy overload only accepts a dummy template "
1242+
"parameter, T = void, which prevents SYCL kernel generation by default.");
12201243
auto events = detail::memcpy(q, to, to_pos, from, from_pos, size);
12211244
return detail::combine_events(events, q);
12221245
}
@@ -1268,7 +1291,10 @@ namespace experimental {
12681291
template <typename T = void>
12691292
static inline void memcpy(const memcpy_parameter &param,
12701293
sycl::queue q = get_default_queue()) {
1271-
static_assert(std::is_same_v<T, void>, "This syclcompat::memcpy overload only accepts a dummy template parameter.");
1294+
static_assert(
1295+
std::is_same_v<T, void>,
1296+
"This syclcompat::memcpy overload only accepts a dummy template "
1297+
"parameter, T = void, which prevents SYCL kernel generation by default.");
12721298
sycl::event::wait(syclcompat::experimental::detail::memcpy(q, param));
12731299
}
12741300

@@ -1281,7 +1307,10 @@ static inline void memcpy(const memcpy_parameter &param,
12811307
template <typename T = void>
12821308
static inline void memcpy_async(const memcpy_parameter &param,
12831309
sycl::queue q = get_default_queue()) {
1284-
static_assert(std::is_same_v<T, void>, "This syclcompat::memcpy overload only accepts a dummy template parameter.");
1310+
static_assert(
1311+
std::is_same_v<T, void>,
1312+
"This syclcompat::memcpy overload only accepts a dummy template "
1313+
"parameter, T = void, which prevents SYCL kernel generation by default.");
12851314
syclcompat::experimental::detail::memcpy(q, param);
12861315
}
12871316
} // namespace experimental
@@ -1311,7 +1340,10 @@ static void memset(void *dev_ptr, int value, size_t size,
13111340
template <typename T = void>
13121341
static inline void memset_d16(void *dev_ptr, unsigned short value, size_t size,
13131342
sycl::queue q = get_default_queue()) {
1314-
static_assert(std::is_same_v<T, void>, "syclcompat::memset_d16 only accepts a dummy template parameter.");
1343+
static_assert(
1344+
std::is_same_v<T, void>,
1345+
"syclcompat::memset_d16 only accepts a dummy template parameter, T = "
1346+
"void, which prevents SYCL kernel generation by default.");
13151347
detail::fill<unsigned short>(q, dev_ptr, value, size).wait();
13161348
}
13171349

@@ -1325,7 +1357,10 @@ static inline void memset_d16(void *dev_ptr, unsigned short value, size_t size,
13251357
template <typename T = void>
13261358
static inline void memset_d32(void *dev_ptr, unsigned int value, size_t size,
13271359
sycl::queue q = get_default_queue()) {
1328-
static_assert(std::is_same_v<T, void>, "syclcompat::memset_d32 only accepts a dummy template parameter.");
1360+
static_assert(
1361+
std::is_same_v<T, void>,
1362+
"syclcompat::memset_d32 only accepts a dummy template parameter, T = "
1363+
"void, which prevents SYCL kernel generation by default.");
13291364
detail::fill<unsigned int>(q, dev_ptr, value, size).wait();
13301365
}
13311366

@@ -1352,7 +1387,10 @@ template <typename T = void>
13521387
static inline sycl::event
13531388
memset_d16_async(void *dev_ptr, unsigned short value, size_t size,
13541389
sycl::queue q = get_default_queue()) {
1355-
static_assert(std::is_same_v<T, void>, "syclcompat::memset_d16_async only accepts a dummy template parameter.");
1390+
static_assert(
1391+
std::is_same_v<T, void>,
1392+
"syclcompat::memset_d16_async only accepts a dummy template parameter, T "
1393+
"= void, which prevents SYCL kernel generation by default.");
13561394
return detail::fill<unsigned short>(q, dev_ptr, value, size);
13571395
}
13581396

@@ -1368,7 +1406,10 @@ template <typename T = void>
13681406
static inline sycl::event
13691407
memset_d32_async(void *dev_ptr, unsigned int value, size_t size,
13701408
sycl::queue q = get_default_queue()) {
1371-
static_assert(std::is_same_v<T, void>, "syclcompat::memset_d32_async only accepts a dummy template parameter.");
1409+
static_assert(
1410+
std::is_same_v<T, void>,
1411+
"syclcompat::memset_d32_async only accepts a dummy template parameter, T "
1412+
"= void, which prevents SYCL kernel generation by default.");
13721413
return detail::fill<unsigned int>(q, dev_ptr, value, size);
13731414
}
13741415

@@ -1385,7 +1426,10 @@ namespace {
13851426
template <typename T = void>
13861427
static inline void memset(void *ptr, size_t pitch, int val, size_t x, size_t y,
13871428
sycl::queue q = get_default_queue()) {
1388-
static_assert(std::is_same_v<T, void>, "This syclcompat::memset overload only accepts a dummy template parameter.");
1429+
static_assert(
1430+
std::is_same_v<T, void>,
1431+
"This syclcompat::memset overload only accepts a dummy template "
1432+
"parameter, T = void, which prevents SYCL kernel generation by default.");
13891433
sycl::event::wait(detail::memset<unsigned char>(q, ptr, pitch, val, x, y));
13901434
}
13911435
} // namespace
@@ -1403,7 +1447,10 @@ template <typename T = void>
14031447
static inline void memset_d16(void *ptr, size_t pitch, unsigned short val,
14041448
size_t x, size_t y,
14051449
sycl::queue q = get_default_queue()) {
1406-
static_assert(std::is_same_v<T, void>, "syclcompat::memset_d16 only accepts a dummy template parameter.");
1450+
static_assert(
1451+
std::is_same_v<T, void>,
1452+
"syclcompat::memset_d16 only accepts a dummy template parameter, T = "
1453+
"void, which prevents SYCL kernel generation by default.");
14071454
sycl::event::wait(detail::memset(q, ptr, pitch, val, x, y));
14081455
}
14091456

@@ -1420,7 +1467,10 @@ template <typename T = void>
14201467
static inline void memset_d32(void *ptr, size_t pitch, unsigned int val,
14211468
size_t x, size_t y,
14221469
sycl::queue q = get_default_queue()) {
1423-
static_assert(std::is_same_v<T, void>, "syclcompat::memset_d32 only accepts a dummy template parameter.");
1470+
static_assert(
1471+
std::is_same_v<T, void>,
1472+
"syclcompat::memset_d32 only accepts a dummy template parameter, T = "
1473+
"void, which prevents SYCL kernel generation by default.");
14241474
sycl::event::wait(detail::memset(q, ptr, pitch, val, x, y));
14251475
}
14261476

@@ -1438,7 +1488,10 @@ template <typename T = void>
14381488
static inline sycl::event memset_async(void *ptr, size_t pitch, int val,
14391489
size_t x, size_t y,
14401490
sycl::queue q = get_default_queue()) {
1441-
static_assert(std::is_same_v<T, void>, "syclcompat::memset_async only accepts a dummy template parameter.");
1491+
static_assert(
1492+
std::is_same_v<T, void>,
1493+
"syclcompat::memset_async only accepts a dummy template parameter, T = "
1494+
"void, which prevents SYCL kernel generation by default.");
14421495
auto events = detail::memset<unsigned char>(q, ptr, pitch, val, x, y);
14431496
return detail::combine_events(events, q);
14441497
}
@@ -1457,7 +1510,10 @@ template <typename T = void>
14571510
static inline sycl::event
14581511
memset_d16_async(void *ptr, size_t pitch, unsigned short val, size_t x,
14591512
size_t y, sycl::queue q = get_default_queue()) {
1460-
static_assert(std::is_same_v<T, void>, "syclcompat::memset_d16_async only accepts a dummy template parameter.");
1513+
static_assert(
1514+
std::is_same_v<T, void>,
1515+
"syclcompat::memset_d16_async only accepts a dummy template parameter, T "
1516+
"= void, which prevents SYCL kernel generation by default.");
14611517
auto events = detail::memset(q, ptr, pitch, val, x, y);
14621518
return detail::combine_events(events, q);
14631519
}
@@ -1476,7 +1532,10 @@ template <typename T = void>
14761532
static inline sycl::event
14771533
memset_d32_async(void *ptr, size_t pitch, unsigned int val, size_t x, size_t y,
14781534
sycl::queue q = get_default_queue()) {
1479-
static_assert(std::is_same_v<T, void>, "syclcompat::memset_d32_async only accepts a dummy template parameter.");
1535+
static_assert(
1536+
std::is_same_v<T, void>,
1537+
"syclcompat::memset_d32_async only accepts a dummy template parameter, T "
1538+
"= void, which prevents SYCL kernel generation by default.");
14801539
auto events = detail::memset(q, ptr, pitch, val, x, y);
14811540
return detail::combine_events(events, q);
14821541
}
@@ -1495,7 +1554,9 @@ namespace {
14951554
template <typename T = void>
14961555
static inline void memset(pitched_data pitch, int val, sycl::range<3> size,
14971556
sycl::queue q = get_default_queue()) {
1498-
static_assert(std::is_same_v<T, void>, "syclcompat::memset only accepts a dummy template parameter.");
1557+
static_assert(std::is_same_v<T, void>,
1558+
"syclcompat::memset only accepts a dummy template parameter, T "
1559+
"= void, which prevents SYCL kernel generation by default.");
14991560
sycl::event::wait(detail::memset<unsigned char>(q, pitch, val, size));
15001561
}
15011562
} // namespace
@@ -1514,7 +1575,10 @@ template <typename T = void>
15141575
static inline sycl::event memset_async(pitched_data pitch, int val,
15151576
sycl::range<3> size,
15161577
sycl::queue q = get_default_queue()) {
1517-
static_assert(std::is_same_v<T, void>, "syclcompat::memset_async only accepts a dummy template parameter.");
1578+
static_assert(
1579+
std::is_same_v<T, void>,
1580+
"syclcompat::memset_async only accepts a dummy template parameter, T = "
1581+
"void, which prevents SYCL kernel generation by default.");
15181582
auto events = detail::memset<unsigned char>(q, pitch, val, size);
15191583
return detail::combine_events(events, q);
15201584
}

‎sycl/include/syclcompat/util.hpp‎

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -91,7 +91,10 @@ inline void matrix_mem_copy(void *to_ptr, const void *from_ptr, int to_ld,
9191
int from_ld, int rows, int cols, int elem_size,
9292
sycl::queue queue = syclcompat::get_default_queue(),
9393
bool async = false) {
94-
static_assert(std::is_same_v<T, void>, "syclcompat::matrix_mem_copy only accepts a dummy template parameter.");
94+
static_assert(
95+
std::is_same_v<T, void>,
96+
"syclcompat::matrix_mem_copy only accepts a dummy template parameter, T "
97+
"= void, which prevents SYCL kernel generation by default.");
9598
if (to_ptr == from_ptr && to_ld == from_ld) {
9699
return;
97100
}

0 commit comments

Comments
 (0)