Are there use cases for a trait to distinguish between different kinds of oneDPL execution policies?

[akukanov]

oneDPL provides a type trait to identify its execution policy types, oneapi::dpl::is_execution_policy. It is defined to true for both the device_policy class template and the standard-aligned policy classes such as parallel_policy.

Is there a need for another trait that would distinguish between device_policy and other oneDPL policy types that operate on the host?

Currently, there is no public API for this in oneDPL. The standard std::is_same_v trait seems insufficient or inconvenient for the purpose, because device_policy is a class template and not a type, while on the other side there are 4 standard-aligned policy types that would all need to be checked.

Please comment if you think a special trait class/variable template for oneDPL device policies would be useful. Specific usage scenarios for it are especially welcome.

[MikeDvorskiy]

Yes, distinguish between device_policy and other oneDPL policy types (the host policy in particular) would be useful.
Especially, useful when a policy implies where memory is allocated and data are (preferable). This information is required for the "general" tests, which work with a general policy.

[dmitriy-sobolev]

I agree, that the trait can be useful in that case.

Below is an example, I have managed to make up. It is a bit synthetic due to its simplicity. It sorts elements selecting the best policy depending on their number. Data management is different with the device policies: the data is copied into the device for better performance.

is_device_execution_policy simplifies the selection in abstract policy_aware_sort function. Without that option, you would need to pass a special flag to that function to distinguish the policies. There are different ways to implement such logic, so the trait is not essential, but it simplifies code.

#include <oneapi/dpl/algorithm>
#include <oneapi/dpl/execution>

#include <sycl/sycl.hpp>

#include <vector>
#include <numeric>
#include <iostream>
#include <algorithm>
#include <type_traits>

// Possible implementation of the device_policy trait
namespace oneapi::dpl::execution {

template <typename Policy>
struct is_device_execution_policy : std::false_type {};

template <typename KernelName>
struct is_device_execution_policy<oneapi::dpl::execution::device_policy<KernelName>> : std::true_type {};

template <typename Policy>
inline constexpr bool is_device_execution_policy_v = is_device_execution_policy<Policy>::value;

} // namespace oneapi::dpl::execution

// Sort abstraction depending on the policy type
template <typename Policy, typename T>
void policy_aware_sort(Policy policy, T* keys, int n)
{
    if constexpr (oneapi::dpl::execution::is_device_execution_policy_v<Policy>)
    {
        sycl::queue q = policy.queue();
        T* keys_device = sycl::malloc_device<T>(n, q);
        q.memcpy(keys_device, keys, n * sizeof(T)).wait();
        oneapi::dpl::sort(policy, keys_device, keys_device + n);
        q.memcpy(keys, keys_device, n * sizeof(T)).wait();
        sycl::free(keys_device, q);
    }
    else
    {
        oneapi::dpl::sort(policy, keys, keys + n);
    }
}

// Sort selecting the best policy based on the number of elements
template <typename T>
void sort_selecting_policy(T* keys, int n)
{
    int massive_parallel_sort_threshold = (1 << 18); // 256K
    int parallel_sort_threshold = (1 << 10); // 1K
    if (n >= massive_parallel_sort_threshold)
    {
        std::cout << "Massive parallel sort using GPU" << std::endl;
        sycl::queue q{sycl::gpu_selector_v};
        policy_aware_sort(oneapi::dpl::execution::make_device_policy(q), keys, n);
    }
    else if (n >= parallel_sort_threshold)
    {
        std::cout << "Parallel sort uisng CPU" << std::endl;
        policy_aware_sort(oneapi::dpl::execution::par_unseq, keys, n);
    }
    else
    {
        std::cout << "Vectorized sort uisng CPU" << std::endl;
        policy_aware_sort(oneapi::dpl::execution::unseq, keys, n);
    }
}

int main(int argc, char* argv[])
{
    using T = float;
    const int n = std::atoi(argv[1]);
    if (argc != 2) {
        std::cerr << "Usage: " << argv[0] << " <number_of_elements>" << std::endl;
        return 1;
    }

    // Let's say the data is in host memory
    std::vector<T> keys(n);
    std::iota(std::rbegin(keys), std::rend(keys), 0);

    sort_selecting_policy(keys.data(), n);

    std::cout << "Sorted: " << std::is_sorted(std::begin(keys), std::end(keys)) << std::endl;
    return 0;
}

Meanwhile I tried to find real-world examples searching across GitHub relying on *device_execution_policy*/*host_execution_policy* matches, but I have not managed to find anything similar outside of oneDPL.