Skip to content

Introduction of marray's complex specialization #33

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
TApplencourt merged 8 commits into from
Mar 27, 2023
Merged

Introduction of marray's complex specialization #33

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
8 commits
Select commit Hold shift + click to select a range
b57b04f
introduction of marray's complex specialization
jle-quel Feb 6, 2023
390cda6
update complex tests with marray test cases
jle-quel Feb 6, 2023
16fa809
introduce new tests for marray
jle-quel Feb 6, 2023
262f227
Fix clang-format CI error
jle-quel Feb 6, 2023
83b1ee9
Fix clang-format-14 CI error
jle-quel Feb 6, 2023
22b23cb
rename 'index' variable to 'i' to match the overall interface convention
jle-quel Feb 24, 2023
fc69738
rename DataT to ComplexDataT
jle-quel Mar 8, 2023
78007db
restructure define and handle hypsycl and sycl namespace for marray
jle-quel Mar 8, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
457 changes: 454 additions & 3 deletions include/sycl_ext_complex.hpp
View file
Open in desktop

Large diffs are not rendered by default.

63 changes: 63 additions & 0 deletions tests/abs_complex.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,5 +1,9 @@
#include "test_helper.hpp"

////////////////////////////////////////////////////////////////////////////////
// COMPLEX TESTS
////////////////////////////////////////////////////////////////////////////////

TEMPLATE_TEST_CASE("Test complex abs", "[abs]", double, float, sycl::half) {
using T = TestType;

Expand Down Expand Up @@ -38,3 +42,62 @@ TEMPLATE_TEST_CASE("Test complex abs", "[abs]", double, float, sycl::half) {

sycl::free(cplx_out, Q);
}

////////////////////////////////////////////////////////////////////////////////
// MARRAY<COMPLEX> TESTS
////////////////////////////////////////////////////////////////////////////////

TEMPLATE_TEST_CASE_SIG("Test marray complex abs", "[abs]",
((typename T, std::size_t NumElements), T, NumElements),
(double, 14), (float, 14), (sycl::half, 14)) {
sycl::queue Q;

// std::complex test cases
const auto std_in =
GENERATE(init_std_complex(sycl::marray<std::complex<T>, NumElements>{
std::complex<T>{1.0, 1.0},
std::complex<T>{4.42, 2.02},
std::complex<T>{-3, 3.5},
std::complex<T>{4.0, -4.0},
std::complex<T>{2.02, inf_val<T>},
std::complex<T>{inf_val<T>, 4.42},
std::complex<T>{inf_val<T>, nan_val<T>},
std::complex<T>{2.02, 4.42},
std::complex<T>{nan_val<T>, nan_val<T>},
std::complex<T>{nan_val<T>, nan_val<T>},
std::complex<T>{inf_val<T>, inf_val<T>},
std::complex<T>{nan_val<T>, nan_val<T>},
std::complex<T>{inf_val<T>, inf_val<T>},
std::complex<T>{nan_val<T>, nan_val<T>},
}));

// sycl::complex test cases
sycl::marray<sycl::ext::cplx::complex<T>, NumElements> cplx_input;
for (std::size_t i = 0; i < NumElements; ++i) {
cplx_input[i] =
sycl::ext::cplx::complex<T>{std_in[i].real(), std_in[i].imag()};
}

sycl::marray<T, NumElements> std_out{};
auto *cplx_out = sycl::malloc_shared<sycl::marray<T, NumElements>>(1, Q);

// Get std::complex output
for (std::size_t i = 0; i < NumElements; ++i)
std_out[i] = std::abs(std_in[i]);

// Check cplx::complex output from device
if (is_type_supported<T>(Q)) {
Q.single_task([=]() {
*cplx_out = sycl::ext::cplx::abs<T>(cplx_input);
}).wait();

check_results(*cplx_out, std_out);
}

// Check cplx::complex output from host
*cplx_out = sycl::ext::cplx::abs<T>(cplx_input);

check_results(*cplx_out, std_out);

sycl::free(cplx_out, Q);
}
122 changes: 122 additions & 0 deletions tests/acos_complex.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,5 +1,9 @@
#include "test_helper.hpp"

////////////////////////////////////////////////////////////////////////////////
// COMPLEX TESTS
////////////////////////////////////////////////////////////////////////////////

TEMPLATE_TEST_CASE("Test complex acos", "[acos]", double, float, sycl::half) {
using T = TestType;
using std::make_tuple;
Expand Down Expand Up @@ -56,3 +60,121 @@ TEMPLATE_TEST_CASE("Test complex acos", "[acos]", double, float, sycl::half) {

sycl::free(cplx_out, Q);
}

////////////////////////////////////////////////////////////////////////////////
// MARRAY<COMPLEX> TESTS'S UTILITIES
////////////////////////////////////////////////////////////////////////////////

template <typename T, typename X, std::size_t NumElements>
auto test(
sycl::queue &Q, const sycl::marray<std::complex<X>, NumElements> &std_in,
const sycl::marray<sycl::ext::cplx::complex<T>, NumElements> &cplx_input,
bool is_error_checking) {

sycl::marray<std::complex<T>, NumElements> std_out{};
auto *cplx_out = sycl::malloc_shared<
sycl::marray<sycl::ext::cplx::complex<T>, NumElements>>(1, Q);

// Get std::complex output
if (is_error_checking) {
for (std::size_t i = 0; i < NumElements; ++i)
std_out[i] = std::acos(std_in[i]);
} else {
// Need to manually copy to handle as for for halfs, std_in is of value
// type float and std_out is of value type half
for (std::size_t i = 0; i < NumElements; ++i)
std_out[i] = std_in[i];
}

// Check cplx::complex output from device
if (is_type_supported<T>(Q)) {
if (is_error_checking) {
Q.single_task([=]() {
*cplx_out = sycl::ext::cplx::acos<T>(cplx_input);
}).wait();
} else {
Q.single_task([=]() {
*cplx_out =
sycl::ext::cplx::cos<T>(sycl::ext::cplx::acos<T>(cplx_input));
}).wait();
}

check_results(*cplx_out, std_out, /*tol_multiplier*/ 4);
}

// Check cplx::complex output from host
if (is_error_checking) {
*cplx_out = sycl::ext::cplx::acos<T>(cplx_input);
} else {
*cplx_out = sycl::ext::cplx::cos<T>(sycl::ext::cplx::acos<T>(cplx_input));
}

check_results(*cplx_out, std_out, /*tol_multiplier*/ 2);

sycl::free(cplx_out, Q);
}

////////////////////////////////////////////////////////////////////////////////
// MARRAY<COMPLEX> TESTS
////////////////////////////////////////////////////////////////////////////////

TEMPLATE_TEST_CASE_SIG("Test marray complex acos (check error: false)",
"[acos]",
((typename T, std::size_t NumElements), T, NumElements),
(double, 4), (float, 4), (sycl::half, 4)) {
sycl::queue Q;

// std::complex test cases
const auto std_in =
GENERATE(init_std_complex(sycl::marray<std::complex<T>, NumElements>{
std::complex<T>{1.0, 1.0},
std::complex<T>{4.42, 2.02},
std::complex<T>{-3, 2.5},
std::complex<T>{4.0, -4.0},
}));

// sycl::complex test cases
sycl::marray<sycl::ext::cplx::complex<T>, NumElements> cplx_input;
for (std::size_t i = 0; i < NumElements; ++i) {
cplx_input[i] =
sycl::ext::cplx::complex<T>{std_in[i].real(), std_in[i].imag()};
}

// sycl::half cases are emulated with float for std::complex class (std_in)
using X = typename std::conditional<std::is_same<T, sycl::half>::value, float,
T>::type;
test<T, X>(Q, std_in, cplx_input, false);
}

TEMPLATE_TEST_CASE_SIG("Test marray complex acos (check error: true)", "[acos]",
((typename T, std::size_t NumElements), T, NumElements),
(double, 10), (float, 10), (sycl::half, 10)) {
sycl::queue Q;

// std::complex test cases
const auto std_in =
GENERATE(init_std_complex(sycl::marray<std::complex<T>, NumElements>{
std::complex<T>{2.02, inf_val<T>},
std::complex<T>{inf_val<T>, 4.42},
std::complex<T>{inf_val<T>, nan_val<T>},
std::complex<T>{2.02, 4.42},
std::complex<T>{nan_val<T>, nan_val<T>},
std::complex<T>{nan_val<T>, nan_val<T>},
std::complex<T>{inf_val<T>, inf_val<T>},
std::complex<T>{nan_val<T>, nan_val<T>},
std::complex<T>{inf_val<T>, inf_val<T>},
std::complex<T>{nan_val<T>, nan_val<T>},
}));

// sycl::complex test cases
sycl::marray<sycl::ext::cplx::complex<T>, NumElements> cplx_input;
for (std::size_t i = 0; i < NumElements; ++i) {
cplx_input[i] =
sycl::ext::cplx::complex<T>{std_in[i].real(), std_in[i].imag()};
}

// sycl::half cases are emulated with float for std::complex class (std_in)
using X = typename std::conditional<std::is_same<T, sycl::half>::value, float,
T>::type;
test<T, X>(Q, std_in, cplx_input, true);
}
125 changes: 124 additions & 1 deletion tests/acosh_complex.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,5 +1,9 @@
#include "test_helper.hpp"

////////////////////////////////////////////////////////////////////////////////
// COMPLEX TESTS
////////////////////////////////////////////////////////////////////////////////

TEMPLATE_TEST_CASE("Test complex acosh", "[acosh]", double, float, sycl::half) {
using T = TestType;
using std::make_tuple;
Expand Down Expand Up @@ -56,4 +60,123 @@ TEMPLATE_TEST_CASE("Test complex acosh", "[acosh]", double, float, sycl::half) {
check_results(cplx_out[0], std_out, /*tol_multiplier*/ 2);

sycl::free(cplx_out, Q);
}
}

////////////////////////////////////////////////////////////////////////////////
// MARRAY<COMPLEX> TESTS'S UTILITIES
////////////////////////////////////////////////////////////////////////////////

template <typename T, typename X, std::size_t NumElements>
auto test(
sycl::queue &Q, const sycl::marray<std::complex<X>, NumElements> &std_in,
const sycl::marray<sycl::ext::cplx::complex<T>, NumElements> &cplx_input,
bool is_error_checking) {

sycl::marray<std::complex<T>, NumElements> std_out{};
auto *cplx_out = sycl::malloc_shared<
sycl::marray<sycl::ext::cplx::complex<T>, NumElements>>(1, Q);

// Get std::complex output
if (is_error_checking) {
for (std::size_t i = 0; i < NumElements; ++i)
std_out[i] = std::acosh(std_in[i]);
} else {
// Need to manually copy to handle as for for halfs, std_in is of value
// type float and std_out is of value type half
for (std::size_t i = 0; i < NumElements; ++i)
std_out[i] = std_in[i];
}

// Check cplx::complex output from device
if (is_type_supported<T>(Q)) {
if (is_error_checking) {
Q.single_task([=]() {
*cplx_out = sycl::ext::cplx::acosh<T>(cplx_input);
}).wait();
} else {
Q.single_task([=]() {
*cplx_out =
sycl::ext::cplx::cosh<T>(sycl::ext::cplx::acosh<T>(cplx_input));
}).wait();
}

check_results(*cplx_out, std_out, /*tol_multiplier*/ 4);
}

// Check cplx::complex output from host
if (is_error_checking) {
*cplx_out = sycl::ext::cplx::acosh<T>(cplx_input);
} else {
*cplx_out = sycl::ext::cplx::cosh<T>(sycl::ext::cplx::acosh<T>(cplx_input));
}

check_results(*cplx_out, std_out, /*tol_multiplier*/ 2);

sycl::free(cplx_out, Q);
}

////////////////////////////////////////////////////////////////////////////////
// MARRAY<COMPLEX> TESTS
////////////////////////////////////////////////////////////////////////////////

TEMPLATE_TEST_CASE_SIG("Test marray complex acosh (check error: false)",
"[acosh]",
((typename T, std::size_t NumElements), T, NumElements),
(double, 4), (float, 4), (sycl::half, 4)) {
sycl::queue Q;

// std::complex test cases
const auto std_in =
GENERATE(init_std_complex(sycl::marray<std::complex<T>, NumElements>{
std::complex<T>{1.0, 1.0},
std::complex<T>{4.42, 2.02},
std::complex<T>{-3, 2.5},
std::complex<T>{4.0, -4.0},
}));

// sycl::complex test cases
sycl::marray<sycl::ext::cplx::complex<T>, NumElements> cplx_input;
for (std::size_t i = 0; i < NumElements; ++i) {
cplx_input[i] =
sycl::ext::cplx::complex<T>{std_in[i].real(), std_in[i].imag()};
}

// sycl::half cases are emulated with float for std::complex class (std_in)
using X = typename std::conditional<std::is_same<T, sycl::half>::value, float,
T>::type;
test<T, X>(Q, std_in, cplx_input, false);
}

TEMPLATE_TEST_CASE_SIG("Test marray complex acosh (check error: true)",
"[acosh]",
((typename T, std::size_t NumElements), T, NumElements),
(double, 10), (float, 10), (sycl::half, 10)) {
sycl::queue Q;

// std::complex test cases
const auto std_in =
GENERATE(init_std_complex(sycl::marray<std::complex<T>, NumElements>{
std::complex<T>{2.02, inf_val<T>},
std::complex<T>{inf_val<T>, 4.42},
std::complex<T>{inf_val<T>, nan_val<T>},
std::complex<T>{2.02, 4.42},
std::complex<T>{nan_val<T>, nan_val<T>},
std::complex<T>{nan_val<T>, nan_val<T>},
std::complex<T>{inf_val<T>, inf_val<T>},
std::complex<T>{nan_val<T>, nan_val<T>},
std::complex<T>{inf_val<T>, inf_val<T>},
std::complex<T>{nan_val<T>, nan_val<T>},
}));

// sycl::complex test cases
sycl::marray<sycl::ext::cplx::complex<T>, NumElements> cplx_input;
for (std::size_t i = 0; i < NumElements; ++i) {
cplx_input[i] =
sycl::ext::cplx::complex<T>{std_in[i].real(), std_in[i].imag()};
}

// sycl::half cases are emulated with float for std::complex class (std_in)
using X = typename std::conditional<std::is_same<T, sycl::half>::value, float,
T>::type;
test<T, X>(Q, std_in, cplx_input, true);
}
Loading