Windows 10
IDE
Visual Studio 19
Compiler
Intel(R) oneAPI DPC++ compiler
Toolkit
oneAPI Base Toolkit version 2021.1
Problem
- Random call instructions are generated in critical loops when using parallel_for.
- No loop optimization is applied when using single_task.
Example program,
#include <CL/sycl.hpp>
#include <iostream>
namespace {
__declspec(noinline) void add(
float const* a, size_t a_stride,
float const* b, size_t b_stride,
float* c, size_t c_stride,
size_t w, size_t h
) {
for (size_t y = 0; y < h; ++y) {
for (size_t x = 0; x < w; ++x) {
c[y * c_stride + x] = a[y * a_stride + x] + b[y * b_stride + x];
}
}
}
__declspec(noinline) void add_single_task(
sycl::queue& q,
float const* a, size_t a_stride,
float const* b, size_t b_stride,
float* c, size_t c_stride,
size_t w, size_t h
) {
auto e = q.submit([&](sycl::handler& cgh) {
cgh.single_task([=]() {
for (size_t y = 0; y < h; ++y) {
for (size_t x = 0; x < w; ++x) {
c[y * c_stride + x] = a[y * a_stride + x] + b[y * b_stride + x];
}
}
});
});
e.wait_and_throw();
}
__declspec(noinline) void add_parallel_for(
sycl::queue& q,
float const* a, size_t a_stride,
float const* b, size_t b_stride,
float* c, size_t c_stride,
size_t w, size_t h
) {
auto e = q.submit([&](sycl::handler& cgh) {
cgh.parallel_for(sycl::range<2>(h, w), [=](sycl::id<2> index) {
auto y = index[0];
auto x = index[1];
c[y * c_stride + x] = a[y * a_stride + x] + b[y * b_stride + x];
});
});
e.wait_and_throw();
}
sycl::queue get_queue() {
// Note:
// Initialization of a queue is very slow.
// Hence, we'll be caching it.
static auto q = sycl::queue(sycl::cpu_selector());
return q;
}
} // namespace
int main(int argc, char* argv[]) {
try {
auto q = get_queue();
}
catch (std::exception const& e) {
std::cout << "Queue initialization failed with " << e.what() << '\n';
return -1;
}
try {
constexpr auto w = size_t(1024);
constexpr auto h = size_t(1024);
auto a = std::vector<float>(w * h, 1);
auto b = std::vector<float>(w * h, 2);
auto c = std::vector<float>(w * h);
auto q = get_queue();
for (size_t i = 0; i < 30; ++i) {
add(a.data(), w, b.data(), w, c.data(), w, w, h);
add_single_task(q, a.data(), w, b.data(), w, c.data(), w, w, h);
add_parallel_for(q, a.data(), w, b.data(), w, c.data(), w, w, h);
}
}
catch (std::exception const& e) {
std::cout << "Add failed with " << e.what() << '\n';
return -1;
}
return 0;
}
Intel Advisor reports,
- add_parallel_for,
- call tree,
- assembly, - add_single_task,
- source insights,
Are those call instructions necessary and is there a way to request the AOT/JIT compiler to not generate them? And for single_task, shouldn't optimization be applied as well (was simply interested to see how it fare against the host compiler optimization, add)?
1 Solution
Link Copied
