31047320341

Committed 05 Aug 2026 09:08PM UTC coverage: 74.054% (-0.5%) from 74.579%

Build # 31047320341

Build Type

Pull #2324

github

Committed by

web-flow

Commit Message

Merge b7661fef8 into f410c8606

Pull Request Pull Request #2324: Add missing device info queries

Coverage Stats

964 of 1366 branches covered (70.57%)

Branch coverage included in aggregate %.

288 of 347 new or added lines in 4 files covered. (83.0%)

16 existing lines in 1 file now uncovered.

3654 of 4870 relevant lines covered (75.03%)

286.86 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

72.38

/libsyclinterface/helper/source/dpctl_utils_helper.cpp

//===- dpctl_utils_helper.cpp - Implementation of enum to string helpers   ===//
//
//                      Data Parallel Control (dpctl)
//
// Copyright 2020 Intel Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
//===----------------------------------------------------------------------===//
///
/// \file
/// This file implements the helper functions defined in dpctl_utils_helper.h.
///
//===----------------------------------------------------------------------===//

#include "dpctl_utils_helper.h"
#include "Config/dpctl_config.h"
#include <sstream>
#include <stdexcept>
#include <string>

using namespace sycl;

/*!
 * Transforms enum info::device_type to string.
 */
std::string DPCTL_DeviceTypeToStr(info::device_type devTy)
{
    std::stringstream ss;
    switch (devTy) {
    case info::device_type::cpu:
        ss << "cpu";
        break;
    case info::device_type::gpu:
        ss << "gpu";
        break;
    case info::device_type::accelerator:
        ss << "accelerator";
        break;
    case info::device_type::custom:
        ss << "custom";
        break;
    default:
        ss << "unknown";
    }
    return ss.str();
}

/*!
 * Transforms string to enum info::device_type.
 */
info::device_type DPCTL_StrToDeviceType(const std::string &devTyStr)
{
    info::device_type devTy;
    if (devTyStr == "cpu") {
        devTy = info::device_type::cpu;
    }
    else if (devTyStr == "gpu") {
        devTy = info::device_type::gpu;
    }
    else if (devTyStr == "accelerator") {
        devTy = info::device_type::accelerator;
    }
    else if (devTyStr == "custom") {
        devTy = info::device_type::custom;
    }
    else {
        // \todo handle the error
        throw std::runtime_error("Unknown device type.");
    }
    return devTy;
}

backend DPCTL_DPCTLBackendTypeToSyclBackend(DPCTLSyclBackendType BeTy)
{
    switch (BeTy) {
    case DPCTLSyclBackendType::DPCTL_CUDA:
        return backend::ext_oneapi_cuda;
    case DPCTLSyclBackendType::DPCTL_LEVEL_ZERO:
        return backend::ext_oneapi_level_zero;
    case DPCTLSyclBackendType::DPCTL_OPENCL:
        return backend::opencl;
    case DPCTLSyclBackendType::DPCTL_ALL_BACKENDS:
        return backend::all;
    case DPCTLSyclBackendType::DPCTL_HIP:
        return backend::ext_oneapi_hip;
    default:
        throw std::runtime_error("Unsupported backend type");
    }
}

DPCTLSyclBackendType DPCTL_SyclBackendToDPCTLBackendType(backend B)
{
    switch (B) {
    case backend::ext_oneapi_cuda:
        return DPCTLSyclBackendType::DPCTL_CUDA;
    case backend::ext_oneapi_level_zero:
        return DPCTLSyclBackendType::DPCTL_LEVEL_ZERO;
    case backend::opencl:
        return DPCTLSyclBackendType::DPCTL_OPENCL;
    case backend::ext_oneapi_hip:
        return DPCTLSyclBackendType::DPCTL_HIP;
    default:
        return DPCTLSyclBackendType::DPCTL_UNKNOWN_BACKEND;
    }
}

info::device_type DPCTL_DPCTLDeviceTypeToSyclDeviceType(DPCTLSyclDeviceType DTy)
{
    switch (DTy) {
    case DPCTLSyclDeviceType::DPCTL_ACCELERATOR:
        return info::device_type::accelerator;
    case DPCTLSyclDeviceType::DPCTL_ALL:
        return info::device_type::all;
    case DPCTLSyclDeviceType::DPCTL_AUTOMATIC:
        return info::device_type::automatic;
    case DPCTLSyclDeviceType::DPCTL_CPU:
        return info::device_type::cpu;
    case DPCTLSyclDeviceType::DPCTL_CUSTOM:
        return info::device_type::custom;
    case DPCTLSyclDeviceType::DPCTL_GPU:
        return info::device_type::gpu;
    default:
        throw std::runtime_error("Unsupported device type");
    }
}

DPCTLSyclDeviceType DPCTL_SyclDeviceTypeToDPCTLDeviceType(info::device_type D)
{
    switch (D) {
    case info::device_type::accelerator:
        return DPCTLSyclDeviceType::DPCTL_ACCELERATOR;
    case info::device_type::all:
        return DPCTLSyclDeviceType::DPCTL_ALL;
    case info::device_type::automatic:
        return DPCTLSyclDeviceType::DPCTL_AUTOMATIC;
    case info::device_type::cpu:
        return DPCTLSyclDeviceType::DPCTL_CPU;
    case info::device_type::custom:
        return DPCTLSyclDeviceType::DPCTL_CUSTOM;
    case info::device_type::gpu:
        return DPCTLSyclDeviceType::DPCTL_GPU;
    default:
        return DPCTLSyclDeviceType::DPCTL_UNKNOWN_DEVICE;
    }
}

/*!
 * Transforms sycl::aspect to string.
 */
std::string DPCTL_AspectToStr(aspect aspectTy)
{
    std::stringstream ss;
    switch (aspectTy) {
    case aspect::cpu:
        ss << "cpu";
        break;
    case aspect::gpu:
        ss << "gpu";
        break;
    case aspect::accelerator:
        ss << "accelerator";
        break;
    case aspect::custom:
        ss << "custom";
        break;
    case aspect::fp16:
        ss << "fp16";
        break;
    case aspect::fp64:
        ss << "fp64";
        break;
    case aspect::atomic64:
        ss << "atomic64";
        break;
    case aspect::image:
        ss << "image";
        break;
    case aspect::online_compiler:
        ss << "online_compiler";
        break;
    case aspect::online_linker:
        ss << "online_linker";
        break;
    case aspect::queue_profiling:
        ss << "queue_profiling";
        break;
    case aspect::usm_device_allocations:
        ss << "usm_device_allocations";
        break;
    case aspect::usm_host_allocations:
        ss << "usm_host_allocations";
        break;
    case aspect::usm_shared_allocations:
        ss << "usm_shared_allocations";
        break;
    case aspect::usm_system_allocations:
        ss << "usm_system_allocations";
        break;
    case aspect::usm_atomic_host_allocations:
        ss << "usm_atomic_host_allocations";
        break;
    case aspect::usm_atomic_shared_allocations:
        ss << "usm_atomic_shared_allocations";
        break;
    case aspect::host_debuggable:
        ss << "host_debuggable";
        break;
    case aspect::emulated:
        ss << "emulated";
        break;
    case aspect::ext_oneapi_is_component:
        ss << "is_component";
        break;
    case aspect::ext_oneapi_is_composite:
        ss << "is_composite";
        break;
#ifdef SYCL_EXT_ONEAPI_INTER_PROCESS_COMMUNICATION
    case aspect::ext_oneapi_ipc_memory:
        ss << "ext_oneapi_ipc_memory";
        break;
#endif
    default:
        throw std::runtime_error("Unsupported aspect type");
    }
    return ss.str();
}

/*!
 * Transforms string to sycl::aspect.
 */
aspect DPCTL_StrToAspectType(const std::string &aspectTyStr)
{
    aspect aspectTy;
    if (aspectTyStr == "cpu") {
        aspectTy = aspect::cpu;
    }
    else if (aspectTyStr == "gpu") {
        aspectTy = aspect::gpu;
    }
    else if (aspectTyStr == "accelerator") {
        aspectTy = aspect::accelerator;
    }
    else if (aspectTyStr == "custom") {
        aspectTy = aspect::custom;
    }
    else if (aspectTyStr == "fp16") {
        aspectTy = aspect::fp16;
    }
    else if (aspectTyStr == "fp64") {
        aspectTy = aspect::fp64;
    }
    else if (aspectTyStr == "atomic64") {
        aspectTy = aspect::atomic64;
    }
    else if (aspectTyStr == "image") {
        aspectTy = aspect::image;
    }
    else if (aspectTyStr == "online_compiler") {
        aspectTy = aspect::online_compiler;
    }
    else if (aspectTyStr == "online_linker") {
        aspectTy = aspect::online_linker;
    }
    else if (aspectTyStr == "queue_profiling") {
        aspectTy = aspect::queue_profiling;
    }
    else if (aspectTyStr == "usm_device_allocations") {
        aspectTy = aspect::usm_device_allocations;
    }
    else if (aspectTyStr == "usm_host_allocations") {
        aspectTy = aspect::usm_host_allocations;
    }
    else if (aspectTyStr == "usm_shared_allocations") {
        aspectTy = aspect::usm_shared_allocations;
    }
    else if (aspectTyStr == "usm_system_allocations") {
        aspectTy = aspect::usm_system_allocations;
    }
    else if (aspectTyStr == "usm_atomic_host_allocations") {
        aspectTy = aspect::usm_atomic_host_allocations;
    }
    else if (aspectTyStr == "usm_atomic_shared_allocations") {
        aspectTy = aspect::usm_atomic_shared_allocations;
    }
    else if (aspectTyStr == "host_debuggable") {
        aspectTy = aspect::host_debuggable;
    }
    else if (aspectTyStr == "emulated") {
        aspectTy = aspect::emulated;
    }
    else if (aspectTyStr == "is_component") {
        aspectTy = aspect::ext_oneapi_is_component;
    }
    else if (aspectTyStr == "is_composite") {
        aspectTy = aspect::ext_oneapi_is_composite;
    }
#ifdef SYCL_EXT_ONEAPI_INTER_PROCESS_COMMUNICATION
    else if (aspectTyStr == "ext_oneapi_ipc_memory") {
        aspectTy = aspect::ext_oneapi_ipc_memory;
    }
#endif
    else {
        // \todo handle the error
        throw std::runtime_error("Unsupported aspect type");
    }
    return aspectTy;
}

aspect DPCTL_DPCTLAspectTypeToSyclAspect(DPCTLSyclAspectType AspectTy)
{
    switch (AspectTy) {
    case DPCTLSyclAspectType::cpu:
        return aspect::cpu;
    case DPCTLSyclAspectType::gpu:
        return aspect::gpu;
    case DPCTLSyclAspectType::accelerator:
        return aspect::accelerator;
    case DPCTLSyclAspectType::custom:
        return aspect::custom;
    case DPCTLSyclAspectType::fp16:
        return aspect::fp16;
    case DPCTLSyclAspectType::fp64:
        return aspect::fp64;
    case DPCTLSyclAspectType::atomic64:
        return aspect::atomic64;
    case DPCTLSyclAspectType::image:
        return aspect::image;
    case DPCTLSyclAspectType::online_compiler:
        return aspect::online_compiler;
    case DPCTLSyclAspectType::online_linker:
        return aspect::online_linker;
    case DPCTLSyclAspectType::queue_profiling:
        return aspect::queue_profiling;
    case DPCTLSyclAspectType::usm_device_allocations:
        return aspect::usm_device_allocations;
    case DPCTLSyclAspectType::usm_host_allocations:
        return aspect::usm_host_allocations;
    case DPCTLSyclAspectType::usm_shared_allocations:
        return aspect::usm_shared_allocations;
    case DPCTLSyclAspectType::usm_system_allocations:
        return aspect::usm_system_allocations;
    case DPCTLSyclAspectType::usm_atomic_host_allocations:
        return aspect::usm_atomic_host_allocations;
    case DPCTLSyclAspectType::usm_atomic_shared_allocations:
        return aspect::usm_atomic_shared_allocations;
    case DPCTLSyclAspectType::host_debuggable:
        return aspect::host_debuggable;
    case DPCTLSyclAspectType::emulated:
        return aspect::emulated;
    case DPCTLSyclAspectType::is_component:
        return aspect::ext_oneapi_is_component;
    case DPCTLSyclAspectType::is_composite:
        return aspect::ext_oneapi_is_composite;
#ifdef SYCL_EXT_ONEAPI_INTER_PROCESS_COMMUNICATION
    case DPCTLSyclAspectType::ext_oneapi_ipc_memory:
        return aspect::ext_oneapi_ipc_memory;
#endif
    default:
        throw std::runtime_error("Unsupported aspect type");
    }
}

DPCTLSyclAspectType DPCTL_SyclAspectToDPCTLAspectType(aspect Aspect)
{
    switch (Aspect) {
    case aspect::cpu:
        return DPCTLSyclAspectType::cpu;
    case aspect::gpu:
        return DPCTLSyclAspectType::gpu;
    case aspect::accelerator:
        return DPCTLSyclAspectType::accelerator;
    case aspect::custom:
        return DPCTLSyclAspectType::custom;
    case aspect::fp16:
        return DPCTLSyclAspectType::fp16;
    case aspect::fp64:
        return DPCTLSyclAspectType::fp64;
    case aspect::atomic64:
        return DPCTLSyclAspectType::atomic64;
    case aspect::image:
        return DPCTLSyclAspectType::image;
    case aspect::online_compiler:
        return DPCTLSyclAspectType::online_compiler;
    case aspect::online_linker:
        return DPCTLSyclAspectType::online_linker;
    case aspect::queue_profiling:
        return DPCTLSyclAspectType::queue_profiling;
    case aspect::usm_device_allocations:
        return DPCTLSyclAspectType::usm_device_allocations;
    case aspect::usm_host_allocations:
        return DPCTLSyclAspectType::usm_host_allocations;
    case aspect::usm_shared_allocations:
        return DPCTLSyclAspectType::usm_shared_allocations;
    case aspect::usm_system_allocations:
        return DPCTLSyclAspectType::usm_system_allocations;
    case aspect::usm_atomic_host_allocations:
        return DPCTLSyclAspectType::usm_atomic_host_allocations;
    case aspect::usm_atomic_shared_allocations:
        return DPCTLSyclAspectType::usm_atomic_shared_allocations;
    case aspect::host_debuggable:
        return DPCTLSyclAspectType::host_debuggable;
    case aspect::emulated:
        return DPCTLSyclAspectType::emulated;
    case aspect::ext_oneapi_is_composite:
        return DPCTLSyclAspectType::is_composite;
    case aspect::ext_oneapi_is_component:
        return DPCTLSyclAspectType::is_component;
#ifdef SYCL_EXT_ONEAPI_INTER_PROCESS_COMMUNICATION
    case aspect::ext_oneapi_ipc_memory:
        return DPCTLSyclAspectType::ext_oneapi_ipc_memory;
#endif
    default:
        throw std::runtime_error("Unsupported aspect type");
    }
}

info::partition_affinity_domain DPCTL_DPCTLPartitionAffinityDomainTypeToSycl(
    DPCTLPartitionAffinityDomainType PartitionAffinityDomainTy)
{
    switch (PartitionAffinityDomainTy) {
    case DPCTLPartitionAffinityDomainType::not_applicable:
        return info::partition_affinity_domain::not_applicable;
    case DPCTLPartitionAffinityDomainType::numa:
        return info::partition_affinity_domain::numa;
    case DPCTLPartitionAffinityDomainType::L4_cache:
        return info::partition_affinity_domain::L4_cache;
    case DPCTLPartitionAffinityDomainType::L3_cache:
        return info::partition_affinity_domain::L3_cache;
    case DPCTLPartitionAffinityDomainType::L2_cache:
        return info::partition_affinity_domain::L2_cache;
    case DPCTLPartitionAffinityDomainType::L1_cache:
        return info::partition_affinity_domain::L1_cache;
    case DPCTLPartitionAffinityDomainType::next_partitionable:
        return info::partition_affinity_domain::next_partitionable;
    default:
        throw std::runtime_error("Unsupported partition_affinity_domain type");
    }
}

DPCTLPartitionAffinityDomainType DPCTL_SyclPartitionAffinityDomainToDPCTLType(
    sycl::info::partition_affinity_domain PartitionAffinityDomain)
{
    switch (PartitionAffinityDomain) {
    case info::partition_affinity_domain::not_applicable:
        return DPCTLPartitionAffinityDomainType::not_applicable;
    case info::partition_affinity_domain::numa:
        return DPCTLPartitionAffinityDomainType::numa;
    case info::partition_affinity_domain::L4_cache:
        return DPCTLPartitionAffinityDomainType::L4_cache;
    case info::partition_affinity_domain::L3_cache:
        return DPCTLPartitionAffinityDomainType::L3_cache;
    case info::partition_affinity_domain::L2_cache:
        return DPCTLPartitionAffinityDomainType::L2_cache;
    case info::partition_affinity_domain::L1_cache:
        return DPCTLPartitionAffinityDomainType::L1_cache;
    case info::partition_affinity_domain::next_partitionable:
        return DPCTLPartitionAffinityDomainType::next_partitionable;
    default:
        return DPCTLPartitionAffinityDomainType::
            DPCTL_PARTITION_AFFINITY_DOMAIN_UNKNOWN;
    }
}

DPCTLFPConfigType DPCTL_SyclFPConfigToDPCTLType(info::fp_config FPConfig)
{
    switch (FPConfig) {
    case info::fp_config::denorm:
        return DPCTLFPConfigType::DPCTL_FP_DENORM;
    case info::fp_config::inf_nan:
        return DPCTLFPConfigType::DPCTL_FP_INF_NAN;
    case info::fp_config::round_to_nearest:
        return DPCTLFPConfigType::DPCTL_FP_ROUND_TO_NEAREST;
    case info::fp_config::round_to_zero:
        return DPCTLFPConfigType::DPCTL_FP_ROUND_TO_ZERO;
    case info::fp_config::round_to_inf:
        return DPCTLFPConfigType::DPCTL_FP_ROUND_TO_INF;
    case info::fp_config::fma:
        return DPCTLFPConfigType::DPCTL_FP_FMA;
    case info::fp_config::correctly_rounded_divide_sqrt:
        return DPCTLFPConfigType::DPCTL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT;
    case info::fp_config::soft_float:
        return DPCTLFPConfigType::DPCTL_FP_SOFT_FLOAT;
    default:
        return DPCTLFPConfigType::DPCTL_FP_UNKNOWN;
    }
}

DPCTLLocalMemType
DPCTL_SyclLocalMemTypeToDPCTLType(info::local_mem_type LocalMemType)
{
    switch (LocalMemType) {
    case info::local_mem_type::none:
        return DPCTLLocalMemType::DPCTL_LOCAL_MEM_TYPE_NONE;
    case info::local_mem_type::local:
        return DPCTLLocalMemType::DPCTL_LOCAL_MEM_TYPE_LOCAL;
    case info::local_mem_type::global:
        return DPCTLLocalMemType::DPCTL_LOCAL_MEM_TYPE_GLOBAL;
    default:
        return DPCTLLocalMemType::DPCTL_LOCAL_MEM_TYPE_UNKNOWN;
    }
}

DPCTLMemoryOrderType DPCTL_SyclMemoryOrderToDPCTLType(memory_order MemoryOrder)
{
    switch (MemoryOrder) {
    case memory_order::relaxed:
        return DPCTLMemoryOrderType::DPCTL_MEMORY_ORDER_RELAXED;
    case memory_order::acquire:
        return DPCTLMemoryOrderType::DPCTL_MEMORY_ORDER_ACQUIRE;
    case memory_order::release:
        return DPCTLMemoryOrderType::DPCTL_MEMORY_ORDER_RELEASE;
    case memory_order::acq_rel:
        return DPCTLMemoryOrderType::DPCTL_MEMORY_ORDER_ACQ_REL;
    case memory_order::seq_cst:
        return DPCTLMemoryOrderType::DPCTL_MEMORY_ORDER_SEQ_CST;
    default:
        return DPCTLMemoryOrderType::DPCTL_MEMORY_ORDER_UNKNOWN;
    }
}

DPCTLMemoryScopeType DPCTL_SyclMemoryScopeToDPCTLType(memory_scope MemoryScope)
{
    switch (MemoryScope) {
    case memory_scope::work_item:
        return DPCTLMemoryScopeType::DPCTL_MEMORY_SCOPE_WORK_ITEM;
    case memory_scope::sub_group:
        return DPCTLMemoryScopeType::DPCTL_MEMORY_SCOPE_SUB_GROUP;
    case memory_scope::work_group:
        return DPCTLMemoryScopeType::DPCTL_MEMORY_SCOPE_WORK_GROUP;
    case memory_scope::device:
        return DPCTLMemoryScopeType::DPCTL_MEMORY_SCOPE_DEVICE;
    case memory_scope::system:
        return DPCTLMemoryScopeType::DPCTL_MEMORY_SCOPE_SYSTEM;
    default:
        return DPCTLMemoryScopeType::DPCTL_MEMORY_SCOPE_UNKNOWN;
    }
}

DPCTLPartitionPropertyType DPCTL_SyclPartitionPropertyToDPCTLType(
    info::partition_property PartitionProperty)
{
    switch (PartitionProperty) {
    case info::partition_property::no_partition:
        return DPCTLPartitionPropertyType::DPCTL_PARTITION_NO_PARTITION;
    case info::partition_property::partition_equally:
        return DPCTLPartitionPropertyType::DPCTL_PARTITION_EQUALLY;
    case info::partition_property::partition_by_counts:
        return DPCTLPartitionPropertyType::DPCTL_PARTITION_BY_COUNTS;
    case info::partition_property::partition_by_affinity_domain:
        return DPCTLPartitionPropertyType::DPCTL_PARTITION_BY_AFFINITY_DOMAIN;
    default:
        // TODO: investigate ext_intel_partition_by_cslice extension
        return DPCTLPartitionPropertyType::DPCTL_PARTITION_UNKNOWN;
    }
}

ext::oneapi::peer_access
DPCTL_DPCTLPeerAccessTypeToSycl(DPCTLPeerAccessType PeerAccessTy)
{
    switch (PeerAccessTy) {
    case DPCTLPeerAccessType::access_supported:
        return ext::oneapi::peer_access::access_supported;
    case DPCTLPeerAccessType::atomics_supported:
        return ext::oneapi::peer_access::atomics_supported;
    default:
        throw std::runtime_error("Unsupported peer_access type");
    }
}

DPCTLPeerAccessType
DPCTL_SyclPeerAccessToDPCTLType(ext::oneapi::peer_access PeerAccess)
{
    switch (PeerAccess) {
    case ext::oneapi::peer_access::access_supported:
        return DPCTLPeerAccessType::access_supported;
    case ext::oneapi::peer_access::atomics_supported:
        return DPCTLPeerAccessType::atomics_supported;
    default:
        throw std::runtime_error("Unsupported peer_access type");
    }
}

int64_t DPCTL_GetRelativeDeviceId(const device &Device)
{
    auto relid = -1;
    auto p = Device.get_platform();
    auto be = p.get_backend();
    auto dt = Device.get_info<sycl::info::device::device_type>();
    auto dev_vec = device::get_devices(dt);
    int64_t id = 0;
    for (const auto &d_i : dev_vec) {
        if (Device == d_i) {
            relid = id;
            break;
        }
        if (d_i.get_platform().get_backend() == be)
            ++id;
    }
    return relid;
}

std::string DPCTL_GetDeviceFilterString(const device &Device)
{
    std::stringstream ss;
    static constexpr const char *filter_string_separator = ":";

    auto be = Device.get_platform().get_backend();

    switch (be) {
    case backend::ext_oneapi_level_zero:
        ss << "level_zero";
        break;
    case backend::ext_oneapi_cuda:
        ss << "cuda";
        break;
    case backend::opencl:
        ss << "opencl";
        break;
    case backend::ext_oneapi_hip:
        ss << "hip";
        break;
    default:
        ss << "unknown";
    };

    ss << filter_string_separator;
    ss << DPCTL_DeviceTypeToStr(Device.get_info<info::device::device_type>());
    ss << filter_string_separator;
    ss << DPCTL_GetRelativeDeviceId(Device);

    return ss.str();
}

DPCTLSyclEventStatusType
DPCTL_SyclEventStatusToDPCTLEventStatusType(info::event_command_status E)
{
    switch (E) {
    case info::event_command_status::submitted:
        return DPCTLSyclEventStatusType::DPCTL_SUBMITTED;
    case info::event_command_status::running:
        return DPCTLSyclEventStatusType::DPCTL_RUNNING;
    case info::event_command_status::complete:
        return DPCTLSyclEventStatusType::DPCTL_COMPLETE;
    default:
        return DPCTLSyclEventStatusType::DPCTL_UNKNOWN_STATUS;
    }
}

IntelPython / dpctl / 31047320341

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous