883600720

Build Type

github

Committed by GitHub

Commit Message

Merge 5d23a0a8d into 48794f782

Pull Request Pull Request #479: Fix sub devices

Run Details

64 of 120 branches covered (53.33%)

Branch coverage included in aggregate %.

24 of 35 new or added lines in 2 files covered. (68.57%)

4 existing lines in 1 file now uncovered.

2871 of 4698 relevant lines covered (61.11%)

10.12 hits per line

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

66.87

/dpctl-capi/source/dpctl_sycl_device_interface.cpp

//===--- dpctl_sycl_device_interface.cpp - Implements C API for sycl::device =//
//
//                      Data Parallel Control (dpctl)
//
// Copyright 2020-2021 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 data types and functions declared in
/// dpctl_sycl_device_interface.h.
///
//===----------------------------------------------------------------------===//

#include "dpctl_sycl_device_interface.h"
#include "../helper/include/dpctl_utils_helper.h"
#include "Support/CBindingWrapping.h"
#include "dpctl_sycl_device_manager.h"
#include <CL/sycl.hpp> /* SYCL headers   */
#include <algorithm>
#include <cstring>

using namespace cl::sycl;

namespace
{
// Create wrappers for C Binding types (see CBindingWrapping.h).
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(device, DPCTLSyclDeviceRef)
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(device_selector, DPCTLSyclDeviceSelectorRef)
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(platform, DPCTLSyclPlatformRef)
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(vector_class<DPCTLSyclDeviceRef>,
                                   DPCTLDeviceVectorRef)

} /* end of anonymous namespace */

__dpctl_give DPCTLSyclDeviceRef
DPCTLDevice_Copy(__dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    auto Device = unwrap(DRef);
    if (!Device) {
        std::cerr << "Cannot copy DPCTLSyclDeviceRef as input is a nullptr\n";
        return nullptr;
    }
    try {
        auto CopiedDevice = new device(*Device);
        return wrap(CopiedDevice);
    } catch (std::bad_alloc const &ba) {
        // \todo log error
        std::cerr << ba.what() << '\n';
        return nullptr;
    }
}

__dpctl_give DPCTLSyclDeviceRef DPCTLDevice_Create()
{
    try {
        auto Device = new device();
        return wrap(Device);
    } catch (std::bad_alloc const &ba) {
        // \todo log error
        std::cerr << ba.what() << '\n';
        return nullptr;
    } catch (runtime_error const &re) {
        // \todo log error
        std::cerr << re.what() << '\n';
        return nullptr;
    }
}

__dpctl_give DPCTLSyclDeviceRef DPCTLDevice_CreateFromSelector(
    __dpctl_keep const DPCTLSyclDeviceSelectorRef DSRef)
{
    auto Selector = unwrap(DSRef);
    if (!Selector)
        // \todo : Log error
        return nullptr;
    try {
        auto Device = new device(*Selector);
        return wrap(Device);
    } catch (std::bad_alloc const &ba) {
        // \todo log error
        std::cerr << ba.what() << '\n';
        return nullptr;
    } catch (runtime_error const &re) {
        // \todo log error
        std::cerr << re.what() << '\n';
        return nullptr;
    }
}

void DPCTLDevice_Delete(__dpctl_take DPCTLSyclDeviceRef DRef)
{
    delete unwrap(DRef);
}

DPCTLSyclDeviceType
DPCTLDevice_GetDeviceType(__dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    DPCTLSyclDeviceType DTy = DPCTLSyclDeviceType::DPCTL_UNKNOWN_DEVICE;
    auto D = unwrap(DRef);
    if (D) {
        try {
            auto SyclDTy = D->get_info<info::device::device_type>();
            DTy = DPCTL_SyclDeviceTypeToDPCTLDeviceType(SyclDTy);
        } catch (runtime_error const &re) {
            // \todo log error
            std::cerr << re.what() << '\n';
        }
    }
    return DTy;
}

bool DPCTLDevice_IsAccelerator(__dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    auto D = unwrap(DRef);
    if (D) {
        return D->is_accelerator();
    }
    return false;
}

bool DPCTLDevice_IsCPU(__dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    auto D = unwrap(DRef);
    if (D) {
        return D->is_cpu();
    }
    return false;
}

bool DPCTLDevice_IsGPU(__dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    auto D = unwrap(DRef);
    if (D) {
        return D->is_gpu();
    }
    return false;
}

bool DPCTLDevice_IsHost(__dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    auto D = unwrap(DRef);
    if (D) {
        return D->is_host();
    }
    return false;
}

DPCTLSyclBackendType
DPCTLDevice_GetBackend(__dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    DPCTLSyclBackendType BTy = DPCTLSyclBackendType::DPCTL_UNKNOWN_BACKEND;
    auto D = unwrap(DRef);
    if (D) {
        BTy = DPCTL_SyclBackendToDPCTLBackendType(
            D->get_platform().get_backend());
    }
    return BTy;
}

uint32_t
DPCTLDevice_GetMaxComputeUnits(__dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    uint32_t nComputeUnits = 0;
    auto D = unwrap(DRef);
    if (D) {
        try {
            nComputeUnits = D->get_info<info::device::max_compute_units>();
        } catch (runtime_error const &re) {
            // \todo log error
            std::cerr << re.what() << '\n';
        }
    }
    return nComputeUnits;
}

uint32_t
DPCTLDevice_GetMaxWorkItemDims(__dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    uint32_t maxWorkItemDims = 0;
    auto D = unwrap(DRef);
    if (D) {
        try {
            maxWorkItemDims =
                D->get_info<info::device::max_work_item_dimensions>();
        } catch (runtime_error const &re) {
            // \todo log error
            std::cerr << re.what() << '\n';
        }
    }
    return maxWorkItemDims;
}

__dpctl_keep size_t *
DPCTLDevice_GetMaxWorkItemSizes(__dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    size_t *sizes = nullptr;
    auto D = unwrap(DRef);
    if (D) {
        try {
            auto id_sizes = D->get_info<info::device::max_work_item_sizes>();
            sizes = new size_t[3];
            for (auto i = 0ul; i < 3; ++i) {
                sizes[i] = id_sizes[i];
            }
        } catch (std::bad_alloc const &ba) {
            // \todo log error
            std::cerr << ba.what() << '\n';
        } catch (runtime_error const &re) {
            // \todo log error
            std::cerr << re.what() << '\n';
        }
    }
    return sizes;
}

size_t
DPCTLDevice_GetMaxWorkGroupSize(__dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    size_t max_wg_size = 0;
    auto D = unwrap(DRef);
    if (D) {
        try {
            max_wg_size = D->get_info<info::device::max_work_group_size>();
        } catch (runtime_error const &re) {
            // \todo log error
            std::cerr << re.what() << '\n';
        }
    }
    return max_wg_size;
}

uint32_t
DPCTLDevice_GetMaxNumSubGroups(__dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    size_t max_nsubgroups = 0;
    auto D = unwrap(DRef);
    if (D) {
        try {
            max_nsubgroups = D->get_info<info::device::max_num_sub_groups>();
        } catch (runtime_error const &re) {
            // \todo log error
            std::cerr << re.what() << '\n';
        }
    }
    return max_nsubgroups;
}

__dpctl_give DPCTLSyclPlatformRef
DPCTLDevice_GetPlatform(__dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    DPCTLSyclPlatformRef PRef = nullptr;
    auto D = unwrap(DRef);
    if (D) {
        try {
            PRef = wrap(new platform(D->get_platform()));
        } catch (std::bad_alloc const &ba) {
            std::cerr << ba.what() << '\n';
        }
    }
    return PRef;
}

__dpctl_give const char *
DPCTLDevice_GetName(__dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    char *cstr_name = nullptr;
    auto D = unwrap(DRef);
    if (D) {
        try {
            auto name = D->get_info<info::device::name>();
            auto cstr_len = name.length() + 1;
            cstr_name = new char[cstr_len];
#ifdef _WIN32
            strncpy_s(cstr_name, cstr_len, name.c_str(), cstr_len);
#else
            std::strncpy(cstr_name, name.c_str(), cstr_len);
#endif
        } catch (std::bad_alloc const &ba) {
            // \todo log error
            std::cerr << ba.what() << '\n';
        } catch (runtime_error const &re) {
            // \todo log error
            std::cerr << re.what() << '\n';
        }
    }
    return cstr_name;
}

__dpctl_give const char *
DPCTLDevice_GetVendor(__dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    char *cstr_vendor = nullptr;
    auto D = unwrap(DRef);
    if (D) {
        try {
            auto vendor = D->get_info<info::device::vendor>();
            auto cstr_len = vendor.length() + 1;
            cstr_vendor = new char[cstr_len];
#ifdef _WIN32
            strncpy_s(cstr_vendor, cstr_len, vendor.c_str(), cstr_len);
#else
            std::strncpy(cstr_vendor, vendor.c_str(), cstr_len);
#endif
        } catch (std::bad_alloc const &ba) {
            // \todo log error
            std::cerr << ba.what() << '\n';
        } catch (runtime_error const &re) {
            // \todo log error
            std::cerr << re.what() << '\n';
        }
    }
    return cstr_vendor;
}

__dpctl_give const char *
DPCTLDevice_GetDriverVersion(__dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    char *cstr_driver = nullptr;
    auto D = unwrap(DRef);
    if (D) {
        try {
            auto driver = D->get_info<info::device::driver_version>();
            auto cstr_len = driver.length() + 1;
            cstr_driver = new char[cstr_len];
#ifdef _WIN32
            strncpy_s(cstr_driver, cstr_len, driver.c_str(), cstr_len);
#else
            std::strncpy(cstr_driver, driver.c_str(), cstr_len);
#endif
        } catch (std::bad_alloc const &ba) {
            // \todo log error
            std::cerr << ba.what() << '\n';
        } catch (runtime_error const &re) {
            // \todo log error
            std::cerr << re.what() << '\n';
        }
    }
    return cstr_driver;
}

bool DPCTLDevice_IsHostUnifiedMemory(__dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    bool ret = false;
    auto D = unwrap(DRef);
    if (D) {
        try {
            ret = D->get_info<info::device::host_unified_memory>();
        } catch (runtime_error const &re) {
            // \todo log error
            std::cerr << re.what() << '\n';
        }
    }
    return ret;
}

bool DPCTLDevice_AreEq(__dpctl_keep const DPCTLSyclDeviceRef DRef1,
                       __dpctl_keep const DPCTLSyclDeviceRef DRef2)
{
    auto D1 = unwrap(DRef1);
    auto D2 = unwrap(DRef2);
    if (D1 && D2)
        return *D1 == *D2;
    else
        return false;
}

bool DPCTLDevice_HasAspect(__dpctl_keep const DPCTLSyclDeviceRef DRef,
                           DPCTLSyclAspectType AT)
{
    bool hasAspect = false;
    auto D = unwrap(DRef);
    if (D) {
        try {
            hasAspect = D->has(DPCTL_DPCTLAspectTypeToSyclAspect(AT));
        } catch (runtime_error const &re) {
            // \todo log error
            std::cerr << re.what() << '\n';
        }
    }
    return hasAspect;
}

#define declmethod(FUNC, NAME, TYPE)                                           \
    TYPE DPCTLDevice_##FUNC(__dpctl_keep const DPCTLSyclDeviceRef DRef)        \
    {                                                                          \
        TYPE result = 0;                                                       \
        auto D = unwrap(DRef);                                                 \
        if (D) {                                                               \
            try {                                                              \
                result = D->get_info<info::device::NAME>();                    \
            } catch (runtime_error const &re) {                                \
                std::cerr << re.what() << '\n';                                \
            }                                                                  \
        }                                                                      \
        return result;                                                         \
    }
declmethod(GetMaxReadImageArgs, max_read_image_args, uint32_t);
declmethod(GetMaxWriteImageArgs, max_write_image_args, uint32_t);
declmethod(GetImage2dMaxWidth, image2d_max_width, size_t);
declmethod(GetImage2dMaxHeight, image2d_max_height, size_t);
declmethod(GetImage3dMaxWidth, image3d_max_width, size_t);
declmethod(GetImage3dMaxHeight, image3d_max_height, size_t);
declmethod(GetImage3dMaxDepth, image3d_max_depth, size_t);
#undef declmethod

bool DPCTLDevice_GetSubGroupIndependentForwardProgress(
    __dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    bool SubGroupProgress = false;
    auto D = unwrap(DRef);
    if (D) {
        try {
            SubGroupProgress = D->get_info<
                info::device::sub_group_independent_forward_progress>();
        } catch (runtime_error const &re) {
            // \todo log error
            std::cerr << re.what() << '\n';
        }
    }
    return SubGroupProgress;
}

uint32_t DPCTLDevice_GetPreferredVectorWidthChar(
    __dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    size_t vector_width_char = 0;
    auto D = unwrap(DRef);
    if (D) {
        try {
            vector_width_char =
                D->get_info<info::device::preferred_vector_width_char>();
        } catch (runtime_error const &re) {
            // \todo log error
            std::cerr << re.what() << '\n';
        }
    }
    return vector_width_char;
}

uint32_t DPCTLDevice_GetPreferredVectorWidthShort(
    __dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    size_t vector_width_short = 0;
    auto D = unwrap(DRef);
    if (D) {
        try {
            vector_width_short =
                D->get_info<info::device::preferred_vector_width_short>();
        } catch (runtime_error const &re) {
            // \todo log error
            std::cerr << re.what() << '\n';
        }
    }
    return vector_width_short;
}

uint32_t DPCTLDevice_GetPreferredVectorWidthInt(
    __dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    size_t vector_width_int = 0;
    auto D = unwrap(DRef);
    if (D) {
        try {
            vector_width_int =
                D->get_info<info::device::preferred_vector_width_int>();
        } catch (runtime_error const &re) {
            // \todo log error
            std::cerr << re.what() << '\n';
        }
    }
    return vector_width_int;
}

uint32_t DPCTLDevice_GetPreferredVectorWidthLong(
    __dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    size_t vector_width_long = 0;
    auto D = unwrap(DRef);
    if (D) {
        try {
            vector_width_long =
                D->get_info<info::device::preferred_vector_width_long>();
        } catch (runtime_error const &re) {
            // \todo log error
            std::cerr << re.what() << '\n';
        }
    }
    return vector_width_long;
}

uint32_t DPCTLDevice_GetPreferredVectorWidthFloat(
    __dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    size_t vector_width_float = 0;
    auto D = unwrap(DRef);
    if (D) {
        try {
            vector_width_float =
                D->get_info<info::device::preferred_vector_width_float>();
        } catch (runtime_error const &re) {
            // \todo log error
            std::cerr << re.what() << '\n';
        }
    }
    return vector_width_float;
}

uint32_t DPCTLDevice_GetPreferredVectorWidthDouble(
    __dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    size_t vector_width_double = 0;
    auto D = unwrap(DRef);
    if (D) {
        try {
            vector_width_double =
                D->get_info<info::device::preferred_vector_width_double>();
        } catch (runtime_error const &re) {
            // \todo log error
            std::cerr << re.what() << '\n';
        }
    }
    return vector_width_double;
}

uint32_t DPCTLDevice_GetPreferredVectorWidthHalf(
    __dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    size_t vector_width_half = 0;
    auto D = unwrap(DRef);
    if (D) {
        try {
            vector_width_half =
                D->get_info<info::device::preferred_vector_width_half>();
        } catch (runtime_error const &re) {
            // \todo log error
            std::cerr << re.what() << '\n';
        }
    }
    return vector_width_half;
}

__dpctl_give DPCTLSyclDeviceRef
DPCTLDevice_GetParentDevice(__dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    auto D = unwrap(DRef);
    if (D) {
        try {
            auto parent_D = D->get_info<info::device::parent_device>();
            return wrap(new device(parent_D));
        } catch (invalid_object_error const &ioe) {
            // not a sub device
            return nullptr;
        } catch (runtime_error const &re) {
            // \todo log error
            std::cerr << re.what() << '\n';
            return nullptr;
        }
    }
    else
        return nullptr;
}

__dpctl_give DPCTLDeviceVectorRef
DPCTLDevice_CreateSubDevicesEqually(__dpctl_keep const DPCTLSyclDeviceRef DRef,
                                    size_t count)
{
    vector_class<DPCTLSyclDeviceRef> *Devices = nullptr;
    if (DRef) {
        if (count == 0) {
            std::cerr << "Can not create sub-devices with zero compute units"
                      << '\n';
            return nullptr;
        }
        auto D = unwrap(DRef);
        try {
            auto subDevices = D->create_sub_devices<
                info::partition_property::partition_equally>(count);
            Devices = new vector_class<DPCTLSyclDeviceRef>();
            for (const auto &sd : subDevices) {
                Devices->emplace_back(wrap(new device(sd)));
            }
        } catch (std::bad_alloc const &ba) {
            delete Devices;
            std::cerr << ba.what() << '\n';
            return nullptr;
        } catch (feature_not_supported const &fnse) {
            delete Devices;
            std::cerr << fnse.what() << '\n';
            return nullptr;
        } catch (runtime_error const &re) {
            delete Devices;
            // \todo log error
            std::cerr << re.what() << '\n';
            return nullptr;
        }
    }
    return wrap(Devices);
}

__dpctl_give DPCTLDeviceVectorRef
DPCTLDevice_CreateSubDevicesByCounts(__dpctl_keep const DPCTLSyclDeviceRef DRef,
                                     __dpctl_keep size_t *counts,
                                     size_t ncounts)
{
    vector_class<DPCTLSyclDeviceRef> *Devices = nullptr;
    std::vector<size_t> vcounts(ncounts);
    vcounts.assign(counts, counts + ncounts);
    size_t min_elem = *std::min_element(vcounts.begin(), vcounts.end());
    if (min_elem == 0) {
        std::cerr << "Can not create sub-devices with zero compute units"
                  << '\n';
        return nullptr;
    }
    if (DRef) {
        auto D = unwrap(DRef);
        vector_class<std::remove_pointer<decltype(D)>::type> subDevices;
        try {
            subDevices = D->create_sub_devices<
                info::partition_property::partition_by_counts>(vcounts);
        } catch (feature_not_supported const &fnse) {
            std::cerr << fnse.what() << '\n';
            return nullptr;
        } catch (runtime_error const &re) {
            // \todo log error
            std::cerr << re.what() << '\n';
            return nullptr;
        }
        try {
            Devices = new vector_class<DPCTLSyclDeviceRef>();
            for (const auto &sd : subDevices) {
                Devices->emplace_back(wrap(new device(sd)));
            }
        } catch (std::bad_alloc const &ba) {
            delete Devices;
            std::cerr << ba.what() << '\n';
            return nullptr;
        } catch (runtime_error const &re) {
            delete Devices;
            // \todo log error
            std::cerr << re.what() << '\n';
            return nullptr;
        }
    }
    return wrap(Devices);
}

__dpctl_give DPCTLDeviceVectorRef DPCTLDevice_CreateSubDevicesByAffinity(
    __dpctl_keep const DPCTLSyclDeviceRef DRef,
    DPCTLPartitionAffinityDomainType PartitionAffinityDomainTy)
{
    vector_class<DPCTLSyclDeviceRef> *Devices = nullptr;
    auto D = unwrap(DRef);
    if (D) {
        try {
            auto domain = DPCTL_DPCTLPartitionAffinityDomainTypeToSycl(
                PartitionAffinityDomainTy);
            auto subDevices = D->create_sub_devices<
                info::partition_property::partition_by_affinity_domain>(domain);
            Devices = new vector_class<DPCTLSyclDeviceRef>();
            for (const auto &sd : subDevices) {
                Devices->emplace_back(wrap(new device(sd)));
            }
        } catch (std::bad_alloc const &ba) {
            delete Devices;
            std::cerr << ba.what() << '\n';
            return nullptr;
        } catch (feature_not_supported const &fnse) {
            delete Devices;
            std::cerr << fnse.what() << '\n';
            return nullptr;
        } catch (runtime_error const &re) {
            delete Devices;
            // \todo log error
            std::cerr << re.what() << '\n';
            return nullptr;
        }
    }
    return wrap(Devices);
}

1	//===--- dpctl_sycl_device_interface.cpp - Implements C API for sycl::device =//
2	//
3	// Data Parallel Control (dpctl)
4	//
5	// Copyright 2020-2021 Intel Corporation
6	//
7	// Licensed under the Apache License, Version 2.0 (the "License");
8	// you may not use this file except in compliance with the License.
9	// You may obtain a copy of the License at
10	//
11	// http://www.apache.org/licenses/LICENSE-2.0
12	//
13	// Unless required by applicable law or agreed to in writing, software
14	// distributed under the License is distributed on an "AS IS" BASIS,
15	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16	// See the License for the specific language governing permissions and
17	// limitations under the License.
18	//
19	//===----------------------------------------------------------------------===//
20	///
21	/// \file
22	/// This file implements the data types and functions declared in
23	/// dpctl_sycl_device_interface.h.
24	///
25	//===----------------------------------------------------------------------===//
26
27	#include "dpctl_sycl_device_interface.h"
28	#include "../helper/include/dpctl_utils_helper.h"
29	#include "Support/CBindingWrapping.h"
30	#include "dpctl_sycl_device_manager.h"
31	#include <CL/sycl.hpp> /* SYCL headers */
32	#include <algorithm>
33	#include <cstring>
34
35	using namespace cl::sycl;
36
37	namespace
38	{
39	// Create wrappers for C Binding types (see CBindingWrapping.h).
40	DEFINE_SIMPLE_CONVERSION_FUNCTIONS(device, DPCTLSyclDeviceRef)
41	DEFINE_SIMPLE_CONVERSION_FUNCTIONS(device_selector, DPCTLSyclDeviceSelectorRef)
42	DEFINE_SIMPLE_CONVERSION_FUNCTIONS(platform, DPCTLSyclPlatformRef)
43	DEFINE_SIMPLE_CONVERSION_FUNCTIONS(vector_class<DPCTLSyclDeviceRef>,
44	DPCTLDeviceVectorRef)
45
46	} /* end of anonymous namespace */
47
48	__dpctl_give DPCTLSyclDeviceRef
49	DPCTLDevice_Copy(__dpctl_keep const DPCTLSyclDeviceRef DRef)
50	{	10✔
51	auto Device = unwrap(DRef);	10✔
52	if (!Device) {	10✔
53	std::cerr << "Cannot copy DPCTLSyclDeviceRef as input is a nullptr\n";	×
54	return nullptr;	×
55	}	×
56	try {	10✔
57	auto CopiedDevice = new device(*Device);	10✔
58	return wrap(CopiedDevice);	10✔
59	} catch (std::bad_alloc const &ba) {	×
60	// \todo log error
61	std::cerr << ba.what() << '\n';	×
62	return nullptr;	×
63	}	×
64	}	10✔
65
66	__dpctl_give DPCTLSyclDeviceRef DPCTLDevice_Create()
67	{	×
68	try {	×
69	auto Device = new device();	×
70	return wrap(Device);	×
71	} catch (std::bad_alloc const &ba) {	×
72	// \todo log error
73	std::cerr << ba.what() << '\n';	×
74	return nullptr;	×
75	} catch (runtime_error const &re) {	×
76	// \todo log error
77	std::cerr << re.what() << '\n';	×
78	return nullptr;	×
79	}	×
80	}	×
81
82	__dpctl_give DPCTLSyclDeviceRef DPCTLDevice_CreateFromSelector(
83	__dpctl_keep const DPCTLSyclDeviceSelectorRef DSRef)
84	{	1,325✔
85	auto Selector = unwrap(DSRef);	1,325✔
86	if (!Selector)	1,325✔
87	// \todo : Log error
88	return nullptr;	8✔
89	try {	1,317✔
90	auto Device = new device(*Selector);	1,317✔
91	return wrap(Device);	1,317✔
92	} catch (std::bad_alloc const &ba) {	×
93	// \todo log error
94	std::cerr << ba.what() << '\n';	×
95	return nullptr;	×
96	} catch (runtime_error const &re) {	818✔
97	// \todo log error
98	std::cerr << re.what() << '\n';	818✔
99	return nullptr;	818✔
100	}	818✔
101	}	1,317✔
102
103	void DPCTLDevice_Delete(__dpctl_take DPCTLSyclDeviceRef DRef)
104	{	1,365✔
105	delete unwrap(DRef);	1,365✔
106	}	1,365✔
107
108	DPCTLSyclDeviceType
109	DPCTLDevice_GetDeviceType(__dpctl_keep const DPCTLSyclDeviceRef DRef)
110	{	12✔
111	DPCTLSyclDeviceType DTy = DPCTLSyclDeviceType::DPCTL_UNKNOWN_DEVICE;	12✔
112	auto D = unwrap(DRef);	12✔
113	if (D) {	12✔
114	try {	12✔
115	auto SyclDTy = D->get_info<info::device::device_type>();	12✔
116	DTy = DPCTL_SyclDeviceTypeToDPCTLDeviceType(SyclDTy);	12✔
117	} catch (runtime_error const &re) {	×
118	// \todo log error
119	std::cerr << re.what() << '\n';	×
120	}	×
121	}	12✔
122	return DTy;	12✔
123	}	12✔
124
125	bool DPCTLDevice_IsAccelerator(__dpctl_keep const DPCTLSyclDeviceRef DRef)
126	{	31✔
127	auto D = unwrap(DRef);	31✔
128	if (D) {	31✔
129	return D->is_accelerator();	31✔
130	}	31✔
131	return false;	×
132	}	×
133
134	bool DPCTLDevice_IsCPU(__dpctl_keep const DPCTLSyclDeviceRef DRef)
135	{	12✔
136	auto D = unwrap(DRef);	12✔
137	if (D) {	12✔
138	return D->is_cpu();	12✔
139	}	12✔
140	return false;	×
141	}	×
142
143	bool DPCTLDevice_IsGPU(__dpctl_keep const DPCTLSyclDeviceRef DRef)
144	{	10✔
145	auto D = unwrap(DRef);	10✔
146	if (D) {	10✔
147	return D->is_gpu();	10✔
148	}	10✔
149	return false;	×
150	}	×
151
152	bool DPCTLDevice_IsHost(__dpctl_keep const DPCTLSyclDeviceRef DRef)
153	{	15✔
154	auto D = unwrap(DRef);	15✔
155	if (D) {	15✔
156	return D->is_host();	15✔
157	}	15✔
158	return false;	×
159	}	×
160
161	DPCTLSyclBackendType
162	DPCTLDevice_GetBackend(__dpctl_keep const DPCTLSyclDeviceRef DRef)
163	{	15✔
164	DPCTLSyclBackendType BTy = DPCTLSyclBackendType::DPCTL_UNKNOWN_BACKEND;	15✔
165	auto D = unwrap(DRef);	15✔
166	if (D) {	15✔
167	BTy = DPCTL_SyclBackendToDPCTLBackendType(	15✔
168	D->get_platform().get_backend());	15✔
169	}	15✔
170	return BTy;	15✔
171	}	15✔
172
173	uint32_t
174	DPCTLDevice_GetMaxComputeUnits(__dpctl_keep const DPCTLSyclDeviceRef DRef)
175	{	42✔
176	uint32_t nComputeUnits = 0;	42✔
177	auto D = unwrap(DRef);	42✔
178	if (D) {	42✔
179	try {	42✔
180	nComputeUnits = D->get_info<info::device::max_compute_units>();	42✔
181	} catch (runtime_error const &re) {	×
182	// \todo log error
183	std::cerr << re.what() << '\n';	×
184	}	×
185	}	42✔
186	return nComputeUnits;	42✔
187	}	42✔
188
189	uint32_t
190	DPCTLDevice_GetMaxWorkItemDims(__dpctl_keep const DPCTLSyclDeviceRef DRef)
191	{	10✔
192	uint32_t maxWorkItemDims = 0;	10✔
193	auto D = unwrap(DRef);	10✔
194	if (D) {	10✔
195	try {	10✔
196	maxWorkItemDims =	10✔
197	D->get_info<info::device::max_work_item_dimensions>();	10✔
198	} catch (runtime_error const &re) {	×
199	// \todo log error
200	std::cerr << re.what() << '\n';	×
201	}	×
202	}	10✔
203	return maxWorkItemDims;	10✔
204	}	10✔
205
206	__dpctl_keep size_t *
207	DPCTLDevice_GetMaxWorkItemSizes(__dpctl_keep const DPCTLSyclDeviceRef DRef)
208	{	10✔
209	size_t *sizes = nullptr;	10✔
210	auto D = unwrap(DRef);	10✔
211	if (D) {	10✔
212	try {	10✔
213	auto id_sizes = D->get_info<info::device::max_work_item_sizes>();	10✔
214	sizes = new size_t[3];	10✔
215	for (auto i = 0ul; i < 3; ++i) {	40✔
216	sizes[i] = id_sizes[i];	30✔
217	}	30✔
218	} catch (std::bad_alloc const &ba) {	×
219	// \todo log error
220	std::cerr << ba.what() << '\n';	×
221	} catch (runtime_error const &re) {	×
222	// \todo log error
223	std::cerr << re.what() << '\n';	×
224	}	×
225	}	10✔
226	return sizes;	10✔
227	}	10✔
228
229	size_t
230	DPCTLDevice_GetMaxWorkGroupSize(__dpctl_keep const DPCTLSyclDeviceRef DRef)
231	{	10✔
232	size_t max_wg_size = 0;	10✔
233	auto D = unwrap(DRef);	10✔
234	if (D) {	10✔
235	try {	10✔
236	max_wg_size = D->get_info<info::device::max_work_group_size>();	10✔
237	} catch (runtime_error const &re) {	×
238	// \todo log error
239	std::cerr << re.what() << '\n';	×
240	}	×
241	}	10✔
242	return max_wg_size;	10✔
243	}	10✔
244
245	uint32_t
246	DPCTLDevice_GetMaxNumSubGroups(__dpctl_keep const DPCTLSyclDeviceRef DRef)
247	{	10✔
248	size_t max_nsubgroups = 0;	10✔
249	auto D = unwrap(DRef);	10✔
250	if (D) {	10✔
251	try {	10✔
252	max_nsubgroups = D->get_info<info::device::max_num_sub_groups>();	10✔
253	} catch (runtime_error const &re) {	×
254	// \todo log error
255	std::cerr << re.what() << '\n';	×
256	}	×
257	}	10✔
258	return max_nsubgroups;	10✔
259	}	10✔
260
261	__dpctl_give DPCTLSyclPlatformRef
262	DPCTLDevice_GetPlatform(__dpctl_keep const DPCTLSyclDeviceRef DRef)
263	{	10✔
264	DPCTLSyclPlatformRef PRef = nullptr;	10✔
265	auto D = unwrap(DRef);	10✔
266	if (D) {	10✔
267	try {	10✔
268	PRef = wrap(new platform(D->get_platform()));	10✔
269	} catch (std::bad_alloc const &ba) {	×
270	std::cerr << ba.what() << '\n';	×
271	}	×
272	}	10✔
273	return PRef;	10✔
274	}	10✔
275
276	__dpctl_give const char *
277	DPCTLDevice_GetName(__dpctl_keep const DPCTLSyclDeviceRef DRef)
278	{	10✔
279	char *cstr_name = nullptr;	10✔
280	auto D = unwrap(DRef);	10✔
281	if (D) {	10✔
282	try {	10✔
283	auto name = D->get_info<info::device::name>();	10✔
284	auto cstr_len = name.length() + 1;	10✔
285	cstr_name = new char[cstr_len];	10✔
286	#ifdef _WIN32
287	strncpy_s(cstr_name, cstr_len, name.c_str(), cstr_len);
288	#else
289	std::strncpy(cstr_name, name.c_str(), cstr_len);	10✔
290	#endif	10✔
291	} catch (std::bad_alloc const &ba) {	×
292	// \todo log error
293	std::cerr << ba.what() << '\n';	×
294	} catch (runtime_error const &re) {	×
295	// \todo log error
296	std::cerr << re.what() << '\n';	×
297	}	×
298	}	10✔
299	return cstr_name;	10✔
300	}	10✔
301
302	__dpctl_give const char *
303	DPCTLDevice_GetVendor(__dpctl_keep const DPCTLSyclDeviceRef DRef)
304	{	10✔
305	char *cstr_vendor = nullptr;	10✔
306	auto D = unwrap(DRef);	10✔
307	if (D) {	10✔
308	try {	10✔
309	auto vendor = D->get_info<info::device::vendor>();	10✔
310	auto cstr_len = vendor.length() + 1;	10✔
311	cstr_vendor = new char[cstr_len];	10✔
312	#ifdef _WIN32
313	strncpy_s(cstr_vendor, cstr_len, vendor.c_str(), cstr_len);
314	#else
315	std::strncpy(cstr_vendor, vendor.c_str(), cstr_len);	10✔
316	#endif	10✔
317	} catch (std::bad_alloc const &ba) {	×
318	// \todo log error
319	std::cerr << ba.what() << '\n';	×
320	} catch (runtime_error const &re) {	×
321	// \todo log error
322	std::cerr << re.what() << '\n';	×
323	}	×
324	}	10✔
325	return cstr_vendor;	10✔
326	}	10✔
327
328	__dpctl_give const char *
329	DPCTLDevice_GetDriverVersion(__dpctl_keep const DPCTLSyclDeviceRef DRef)
330	{	10✔
331	char *cstr_driver = nullptr;	10✔
332	auto D = unwrap(DRef);	10✔
333	if (D) {	10✔
334	try {	10✔
335	auto driver = D->get_info<info::device::driver_version>();	10✔
336	auto cstr_len = driver.length() + 1;	10✔
337	cstr_driver = new char[cstr_len];	10✔
338	#ifdef _WIN32
339	strncpy_s(cstr_driver, cstr_len, driver.c_str(), cstr_len);
340	#else
341	std::strncpy(cstr_driver, driver.c_str(), cstr_len);	10✔
342	#endif	10✔
343	} catch (std::bad_alloc const &ba) {	×
344	// \todo log error
345	std::cerr << ba.what() << '\n';	×
346	} catch (runtime_error const &re) {	×
347	// \todo log error
348	std::cerr << re.what() << '\n';	×
349	}	×
350	}	10✔
351	return cstr_driver;	10✔
352	}	10✔
353
354	bool DPCTLDevice_IsHostUnifiedMemory(__dpctl_keep const DPCTLSyclDeviceRef DRef)
355	{	×
356	bool ret = false;	×
357	auto D = unwrap(DRef);	×
358	if (D) {	×
359	try {	×
360	ret = D->get_info<info::device::host_unified_memory>();	×
361	} catch (runtime_error const &re) {	×
362	// \todo log error
363	std::cerr << re.what() << '\n';	×
364	}	×
365	}	×
366	return ret;	×
367	}	×
368
369	bool DPCTLDevice_AreEq(__dpctl_keep const DPCTLSyclDeviceRef DRef1,
370	__dpctl_keep const DPCTLSyclDeviceRef DRef2)
371	{	18✔
372	auto D1 = unwrap(DRef1);	18✔
373	auto D2 = unwrap(DRef2);	18✔
374	if (D1 && D2)	18✔
375	return D1 == D2;	18✔
376	else	×
377	return false;	×
378	}	18✔
379
380	bool DPCTLDevice_HasAspect(__dpctl_keep const DPCTLSyclDeviceRef DRef,
381	DPCTLSyclAspectType AT)
382	{	107✔
383	bool hasAspect = false;	107✔
384	auto D = unwrap(DRef);	107✔
385	if (D) {	107✔
386	try {	107✔
387	hasAspect = D->has(DPCTL_DPCTLAspectTypeToSyclAspect(AT));	107✔
388	} catch (runtime_error const &re) {	×
389	// \todo log error
390	std::cerr << re.what() << '\n';	×
391	}	×
392	}	107✔
393	return hasAspect;	107✔
394	}	107✔
395
396	#define declmethod(FUNC, NAME, TYPE) \
397	TYPE DPCTLDevice_##FUNC(__dpctl_keep const DPCTLSyclDeviceRef DRef) \
398	{ \	70✔
399	TYPE result = 0; \	70✔
400	auto D = unwrap(DRef); \	70✔
401	if (D) { \	70✔
402	try { \	70✔
403	result = D->get_info<info::device::NAME>(); \	70✔
404	} catch (runtime_error const &re) { \	×
405	std::cerr << re.what() << '\n'; \	×
406	} \	×
407	} \	70✔
408	return result; \	70✔
409	}	70✔
410	declmethod(GetMaxReadImageArgs, max_read_image_args, uint32_t);
411	declmethod(GetMaxWriteImageArgs, max_write_image_args, uint32_t);
412	declmethod(GetImage2dMaxWidth, image2d_max_width, size_t);
413	declmethod(GetImage2dMaxHeight, image2d_max_height, size_t);
414	declmethod(GetImage3dMaxWidth, image3d_max_width, size_t);
415	declmethod(GetImage3dMaxHeight, image3d_max_height, size_t);
416	declmethod(GetImage3dMaxDepth, image3d_max_depth, size_t);
417	#undef declmethod
418
419	bool DPCTLDevice_GetSubGroupIndependentForwardProgress(
420	__dpctl_keep const DPCTLSyclDeviceRef DRef)
421	{	10✔
422	bool SubGroupProgress = false;	10✔
423	auto D = unwrap(DRef);	10✔
424	if (D) {	10✔
425	try {	10✔
426	SubGroupProgress = D->get_info<	10✔
427	info::device::sub_group_independent_forward_progress>();	10✔
428	} catch (runtime_error const &re) {	×
429	// \todo log error
430	std::cerr << re.what() << '\n';	×
431	}	×
432	}	10✔
433	return SubGroupProgress;	10✔
434	}	10✔
435
436	uint32_t DPCTLDevice_GetPreferredVectorWidthChar(
437	__dpctl_keep const DPCTLSyclDeviceRef DRef)
438	{	10✔
439	size_t vector_width_char = 0;	10✔
440	auto D = unwrap(DRef);	10✔
441	if (D) {	10✔
442	try {	10✔
443	vector_width_char =	10✔
444	D->get_info<info::device::preferred_vector_width_char>();	10✔
445	} catch (runtime_error const &re) {	×
446	// \todo log error
447	std::cerr << re.what() << '\n';	×
448	}	×
449	}	10✔
450	return vector_width_char;	10✔
451	}	10✔
452
453	uint32_t DPCTLDevice_GetPreferredVectorWidthShort(
454	__dpctl_keep const DPCTLSyclDeviceRef DRef)
455	{	10✔
456	size_t vector_width_short = 0;	10✔
457	auto D = unwrap(DRef);	10✔
458	if (D) {	10✔
459	try {	10✔
460	vector_width_short =	10✔
461	D->get_info<info::device::preferred_vector_width_short>();	10✔
462	} catch (runtime_error const &re) {	×
463	// \todo log error
464	std::cerr << re.what() << '\n';	×
465	}	×
466	}	10✔
467	return vector_width_short;	10✔
468	}	10✔
469
470	uint32_t DPCTLDevice_GetPreferredVectorWidthInt(
471	__dpctl_keep const DPCTLSyclDeviceRef DRef)
472	{	10✔
473	size_t vector_width_int = 0;	10✔
474	auto D = unwrap(DRef);	10✔
475	if (D) {	10✔
476	try {	10✔
477	vector_width_int =	10✔
478	D->get_info<info::device::preferred_vector_width_int>();	10✔
479	} catch (runtime_error const &re) {	×
480	// \todo log error
481	std::cerr << re.what() << '\n';	×
482	}	×
483	}	10✔
484	return vector_width_int;	10✔
485	}	10✔
486
487	uint32_t DPCTLDevice_GetPreferredVectorWidthLong(
488	__dpctl_keep const DPCTLSyclDeviceRef DRef)
489	{	10✔
490	size_t vector_width_long = 0;	10✔
491	auto D = unwrap(DRef);	10✔
492	if (D) {	10✔
493	try {	10✔
494	vector_width_long =	10✔
495	D->get_info<info::device::preferred_vector_width_long>();	10✔
496	} catch (runtime_error const &re) {	×
497	// \todo log error
498	std::cerr << re.what() << '\n';	×
499	}	×
500	}	10✔
501	return vector_width_long;	10✔
502	}	10✔
503
504	uint32_t DPCTLDevice_GetPreferredVectorWidthFloat(
505	__dpctl_keep const DPCTLSyclDeviceRef DRef)
506	{	10✔
507	size_t vector_width_float = 0;	10✔
508	auto D = unwrap(DRef);	10✔
509	if (D) {	10✔
510	try {	10✔
511	vector_width_float =	10✔
512	D->get_info<info::device::preferred_vector_width_float>();	10✔
513	} catch (runtime_error const &re) {	×
514	// \todo log error
515	std::cerr << re.what() << '\n';	×
516	}	×
517	}	10✔
518	return vector_width_float;	10✔
519	}	10✔
520
521	uint32_t DPCTLDevice_GetPreferredVectorWidthDouble(
522	__dpctl_keep const DPCTLSyclDeviceRef DRef)
523	{	10✔
524	size_t vector_width_double = 0;	10✔
525	auto D = unwrap(DRef);	10✔
526	if (D) {	10✔
527	try {	10✔
528	vector_width_double =	10✔
529	D->get_info<info::device::preferred_vector_width_double>();	10✔
530	} catch (runtime_error const &re) {	×
531	// \todo log error
532	std::cerr << re.what() << '\n';	×
533	}	×
534	}	10✔
535	return vector_width_double;	10✔
536	}	10✔
537
538	uint32_t DPCTLDevice_GetPreferredVectorWidthHalf(
539	__dpctl_keep const DPCTLSyclDeviceRef DRef)
540	{	10✔
541	size_t vector_width_half = 0;	10✔
542	auto D = unwrap(DRef);	10✔
543	if (D) {	10✔
544	try {	10✔
545	vector_width_half =	10✔
546	D->get_info<info::device::preferred_vector_width_half>();	10✔
547	} catch (runtime_error const &re) {	×
548	// \todo log error
549	std::cerr << re.what() << '\n';	×
550	}	×
551	}	10✔
552	return vector_width_half;	10✔
553	}	10✔
554
555	__dpctl_give DPCTLSyclDeviceRef
556	DPCTLDevice_GetParentDevice(__dpctl_keep const DPCTLSyclDeviceRef DRef)
557	{	20✔
558	auto D = unwrap(DRef);	20✔
559	if (D) {	20✔
560	try {	20✔
561	auto parent_D = D->get_info<info::device::parent_device>();	20✔
562	return wrap(new device(parent_D));	20✔
563	} catch (invalid_object_error const &ioe) {	10✔
564	// not a sub device
565	return nullptr;	10✔
566	} catch (runtime_error const &re) {	×
567	// \todo log error
568	std::cerr << re.what() << '\n';	×
569	return nullptr;	×
570	}	×
571	}	×
572	else	×
573	return nullptr;	×
574	}	20✔
575
576	__dpctl_give DPCTLDeviceVectorRef
577	DPCTLDevice_CreateSubDevicesEqually(__dpctl_keep const DPCTLSyclDeviceRef DRef,
578	size_t count)
579	{	20✔
580	vector_class<DPCTLSyclDeviceRef> *Devices = nullptr;	20✔
581	if (DRef) {	20✔
582	if (count == 0) {	20✔
583	std::cerr << "Can not create sub-devices with zero compute units"	10✔
584	<< '\n';	10✔
585	return nullptr;	10✔
586	}	10✔
587	auto D = unwrap(DRef);	10✔
588	try {	10✔
589	auto subDevices = D->create_sub_devices<	10✔
590	info::partition_property::partition_equally>(count);	10✔
591	Devices = new vector_class<DPCTLSyclDeviceRef>();	10✔
592	for (const auto &sd : subDevices) {	20✔
593	Devices->emplace_back(wrap(new device(sd)));	20✔
594	}	20✔
595	} catch (std::bad_alloc const &ba) {	×
596	delete Devices;	×
597	std::cerr << ba.what() << '\n';	×
598	return nullptr;	×
599	} catch (feature_not_supported const &fnse) {	×
600	delete Devices;	×
601	std::cerr << fnse.what() << '\n';	×
602	return nullptr;	×
603	} catch (runtime_error const &re) {	×
604	delete Devices;	×
605	// \todo log error
606	std::cerr << re.what() << '\n';	×
607	return nullptr;	×
608	}	×
609	}	10✔
610	return wrap(Devices);	10✔
611	}	10✔
612
613	__dpctl_give DPCTLDeviceVectorRef
614	DPCTLDevice_CreateSubDevicesByCounts(__dpctl_keep const DPCTLSyclDeviceRef DRef,
615	__dpctl_keep size_t *counts,
616	size_t ncounts)
617	{	22✔
618	vector_class<DPCTLSyclDeviceRef> *Devices = nullptr;	22✔
619	std::vector<size_t> vcounts(ncounts);	22✔
620	vcounts.assign(counts, counts + ncounts);	22✔
621	size_t min_elem = *std::min_element(vcounts.begin(), vcounts.end());	22✔
622	if (min_elem == 0) {	22✔
623	std::cerr << "Can not create sub-devices with zero compute units"	10✔
624	<< '\n';	10✔
625	return nullptr;	10✔
626	}	10✔
627	if (DRef) {	12✔
628	auto D = unwrap(DRef);	12✔
629	vector_class<std::remove_pointer<decltype(D)>::type> subDevices;	12✔
630	try {	12✔
631	subDevices = D->create_sub_devices<	12✔
632	info::partition_property::partition_by_counts>(vcounts);	12✔
NEW 633	} catch (feature_not_supported const &fnse) {	×
NEW 634	std::cerr << fnse.what() << '\n';	×
NEW 635	return nullptr;	×
NEW 636	} catch (runtime_error const &re) {	×
637	// \todo log error
NEW 638	std::cerr << re.what() << '\n';	×
NEW 639	return nullptr;	×
NEW 640	}	×
641	try {	12✔
642	Devices = new vector_class<DPCTLSyclDeviceRef>();	12✔
643	for (const auto &sd : subDevices) {	24✔
644	Devices->emplace_back(wrap(new device(sd)));	24✔
645	}	24✔
646	} catch (std::bad_alloc const &ba) {	×
647	delete Devices;	×
648	std::cerr << ba.what() << '\n';	×
649	return nullptr;	×
650	} catch (runtime_error const &re) {	×
651	delete Devices;	×
652	// \todo log error
653	std::cerr << re.what() << '\n';	×
654	return nullptr;	×
655	}	×
656	}	12✔
657	return wrap(Devices);	12✔
658	}	12✔
659
660	__dpctl_give DPCTLDeviceVectorRef DPCTLDevice_CreateSubDevicesByAffinity(
661	__dpctl_keep const DPCTLSyclDeviceRef DRef,
662	DPCTLPartitionAffinityDomainType PartitionAffinityDomainTy)
663	{	60✔
664	vector_class<DPCTLSyclDeviceRef> *Devices = nullptr;	60✔
665	auto D = unwrap(DRef);	60✔
666	if (D) {	60✔
667	try {	60✔
668	auto domain = DPCTL_DPCTLPartitionAffinityDomainTypeToSycl(	60✔
669	PartitionAffinityDomainTy);	60✔
670	auto subDevices = D->create_sub_devices<	60✔
671	info::partition_property::partition_by_affinity_domain>(domain);	60✔
672	Devices = new vector_class<DPCTLSyclDeviceRef>();	60✔
673	for (const auto &sd : subDevices) {	×
674	Devices->emplace_back(wrap(new device(sd)));	×
675	}	×
676	} catch (std::bad_alloc const &ba) {	×
677	delete Devices;	×
678	std::cerr << ba.what() << '\n';	×
679	return nullptr;	×
680	} catch (feature_not_supported const &fnse) {	60✔
681	delete Devices;	60✔
682	std::cerr << fnse.what() << '\n';	60✔
683	return nullptr;	60✔
684	} catch (runtime_error const &re) {	×
685	delete Devices;	×
686	// \todo log error
687	std::cerr << re.what() << '\n';	×
688	return nullptr;	×
689	}	×
690	}	×
691	return wrap(Devices);	×
692	}	×

IntelPython / dpctl / 883600720

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