872829829

Build Type

github

Committed by GitHub

Commit Message

Merge 8afd60e4a into c1d7bccdf

Pull Request Pull Request #465: Addressed klocwork_dpctl_issues

Run Details

64 of 120 branches covered (53.33%)

Branch coverage included in aggregate %.

11 of 30 new or added lines in 5 files covered. (36.67%)

10 existing lines in 2 files now uncovered.

2856 of 4690 relevant lines covered (60.9%)

10.1 hits per line

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

74.63

/dpctl-capi/source/dpctl_sycl_device_manager.cpp

//===-------- dpctl_sycl_device_manager.cpp - helpers for sycl devices ------=//
//
//                      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 functions declared in dpctl_sycl_device_manager.h.
///
//===----------------------------------------------------------------------===//

#include "dpctl_sycl_device_manager.h"
#include "../helper/include/dpctl_utils_helper.h"
#include "Support/CBindingWrapping.h"
#include "dpctl_sycl_enum_types.h"
#include <CL/sycl.hpp> /* SYCL headers   */
#include <iomanip>
#include <iostream>
#include <unordered_map>

using namespace cl::sycl;

namespace
{

// Create wrappers for C Binding types (see CBindingWrapping.h).
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(device, DPCTLSyclDeviceRef)
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(context, DPCTLSyclContextRef)

/*
 * Helper function to print the metadata for a sycl::device.
 */
void print_device_info(const device &Device)
{
    std::stringstream ss;

    ss << std::setw(4) << " " << std::left << std::setw(16) << "Name"
       << Device.get_info<info::device::name>() << '\n'
       << std::setw(4) << " " << std::left << std::setw(16) << "Driver version"
       << Device.get_info<info::device::driver_version>() << '\n'
       << std::setw(4) << " " << std::left << std::setw(16) << "Vendor"
       << Device.get_info<info::device::vendor>() << '\n'
       << std::setw(4) << " " << std::left << std::setw(16) << "Profile"
       << Device.get_info<info::device::profile>() << '\n'
       << std::setw(4) << " " << std::left << std::setw(16) << "Filter string"
       << Device.get_platform().get_backend() << ":"
       << DPCTL_DeviceTypeToStr(Device.get_info<info::device::device_type>())
       << ":" << DPCTL_GetRelativeDeviceId(Device) << '\n';

    std::cout << ss.str();
}

struct DeviceCacheBuilder
{
    using DeviceCache = std::unordered_map<device, context>;
    /* This function implements a workaround to the current lack of a
     * default context per root device in DPC++. The map stores a "default"
     * context for each root device, and the QMgrHelper uses the map
     * whenever it creates a new queue for a root device. By doing so, we
     * avoid the performance overhead of context creation for every queue.
     *
     * The singleton pattern implemented here ensures that the map is
     * created once in a thread-safe manner. Since, the map is ony read
     * post-creation we do not need any further protection to ensure
     * thread-safety.
     */
    static const DeviceCache &getDeviceCache()
    {
        static DeviceCache *cache = new DeviceCache([] {
            DeviceCache cache_l;
            default_selector mRanker;
            auto Platforms = platform::get_platforms();
            for (const auto &P : Platforms) {
                auto Devices = P.get_devices();
                for (const auto &D : Devices) {
                    if (mRanker(D) < 0)
                        continue;
                    auto entry = cache_l.emplace(D, D);
                    if (!entry.second) {
                        std::cerr << "Fatal Error during device cache "
                                     "construction.\n";
                        std::terminate();
                    }
                }
            }
            return cache_l;
        }());

        return *cache;
    }
};

} // namespace

#undef EL
#define EL Device
#include "dpctl_vector_templ.cpp"
#undef EL

DPCTLSyclContextRef
DPCTLDeviceMgr_GetCachedContext(__dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    DPCTLSyclContextRef CRef = nullptr;

    auto Device = unwrap(DRef);
    if (!Device)
        return CRef;

    auto &cache = DeviceCacheBuilder::getDeviceCache();
    auto entry = cache.find(*Device);
    if (entry != cache.end()) {
        context *ContextPtr = nullptr;
        try {
            ContextPtr = new context(entry->second);
            CRef = wrap(ContextPtr);
        } catch (std::bad_alloc const &ba) {
            std::cerr << ba.what() << std::endl;
            delete ContextPtr;
            CRef = nullptr;
        }
    }
    else {
        std::cerr << "No cached default context for device" << std::endl;
    }
    return CRef;
}

__dpctl_give DPCTLDeviceVectorRef
DPCTLDeviceMgr_GetDevices(int device_identifier)
{
    vector_class<DPCTLSyclDeviceRef> *Devices = nullptr;

    try {
        Devices = new vector_class<DPCTLSyclDeviceRef>();
    } catch (std::bad_alloc const &ba) {
        delete Devices;
        return nullptr;
    }
    const auto &root_devices = device::get_devices();
    default_selector mRanker;

    for (const auto &root_device : root_devices) {
        if (mRanker(root_device) < 0)
            continue;
        auto Bty(DPCTL_SyclBackendToDPCTLBackendType(
            root_device.get_platform().get_backend()));
        auto Dty(DPCTL_SyclDeviceTypeToDPCTLDeviceType(
            root_device.get_info<info::device::device_type>()));
        if ((device_identifier & Bty) && (device_identifier & Dty)) {
            Devices->emplace_back(wrap(new device(root_device)));
        }
    }
    // the wrap function is defined inside dpctl_vector_templ.cpp
    return wrap(Devices);
}

int DPCTLDeviceMgr_GetPositionInDevices(__dpctl_keep DPCTLSyclDeviceRef DRef,
                                        int device_identifier)
{
    constexpr int not_found = -1;
    if (!DRef) {
        return not_found;
    }

    const auto &root_devices = device::get_devices();
    default_selector mRanker;
    int index = not_found;
    auto reference_device = *(unwrap(DRef));

    for (const auto &root_device : root_devices) {
        if (mRanker(root_device) < 0)
            continue;
        auto Bty(DPCTL_SyclBackendToDPCTLBackendType(
            root_device.get_platform().get_backend()));
        auto Dty(DPCTL_SyclDeviceTypeToDPCTLDeviceType(
            root_device.get_info<info::device::device_type>()));
        if ((device_identifier & Bty) && (device_identifier & Dty)) {
            ++index;
            if (root_device == reference_device)
                return index;
        }
    }
    return not_found;
}

/*!
 * Returns the number of available devices for a specific backend and device
 * type combination.
 */
size_t DPCTLDeviceMgr_GetNumDevices(int device_identifier)
{
    size_t nDevices = 0;
    auto &cache = DeviceCacheBuilder::getDeviceCache();
    for (const auto &entry : cache) {
        auto Bty(DPCTL_SyclBackendToDPCTLBackendType(
            entry.first.get_platform().get_backend()));
        auto Dty(DPCTL_SyclDeviceTypeToDPCTLDeviceType(
            entry.first.get_info<info::device::device_type>()));
        if ((device_identifier & Bty) && (device_identifier & Dty))
            ++nDevices;
    }
    return nDevices;
}

/*!
 * Prints some of the device info metadata for the device corresponding to the
 * specified sycl::queue. Currently, device name, driver version, device
 * vendor, and device profile are printed out. More attributed may be added
 * later.
 */
void DPCTLDeviceMgr_PrintDeviceInfo(__dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    auto Device = unwrap(DRef);
    if (Device)
        print_device_info(*Device);
    else
        std::cout << "Device is not valid (NULL). Cannot print device info.\n";
}

int64_t DPCTLDeviceMgr_GetRelativeId(__dpctl_keep const DPCTLSyclDeviceRef DRef)
{
    auto Device = unwrap(DRef);

    if (Device)
        return DPCTL_GetRelativeDeviceId(*Device);

    return -1;
}

1	//===-------- dpctl_sycl_device_manager.cpp - helpers for sycl devices ------=//
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 functions declared in dpctl_sycl_device_manager.h.
23	///
24	//===----------------------------------------------------------------------===//
25
26	#include "dpctl_sycl_device_manager.h"
27	#include "../helper/include/dpctl_utils_helper.h"
28	#include "Support/CBindingWrapping.h"
29	#include "dpctl_sycl_enum_types.h"
30	#include <CL/sycl.hpp> /* SYCL headers */
31	#include <iomanip>
32	#include <iostream>
33	#include <unordered_map>
34
35	using namespace cl::sycl;
36
37	namespace
38	{
39
40	// Create wrappers for C Binding types (see CBindingWrapping.h).
41	DEFINE_SIMPLE_CONVERSION_FUNCTIONS(device, DPCTLSyclDeviceRef)
42	DEFINE_SIMPLE_CONVERSION_FUNCTIONS(context, DPCTLSyclContextRef)
43
44	/*
45	* Helper function to print the metadata for a sycl::device.
46	*/
47	void print_device_info(const device &Device)
48	{	5✔
49	std::stringstream ss;	5✔
50
51	ss << std::setw(4) << " " << std::left << std::setw(16) << "Name"	5✔
52	<< Device.get_info<info::device::name>() << '\n'	5✔
53	<< std::setw(4) << " " << std::left << std::setw(16) << "Driver version"	5✔
54	<< Device.get_info<info::device::driver_version>() << '\n'	5✔
55	<< std::setw(4) << " " << std::left << std::setw(16) << "Vendor"	5✔
56	<< Device.get_info<info::device::vendor>() << '\n'	5✔
57	<< std::setw(4) << " " << std::left << std::setw(16) << "Profile"	5✔
58	<< Device.get_info<info::device::profile>() << '\n'	5✔
59	<< std::setw(4) << " " << std::left << std::setw(16) << "Filter string"	5✔
60	<< Device.get_platform().get_backend() << ":"	5✔
61	<< DPCTL_DeviceTypeToStr(Device.get_info<info::device::device_type>())	5✔
62	<< ":" << DPCTL_GetRelativeDeviceId(Device) << '\n';	5✔
63
64	std::cout << ss.str();	5✔
65	}	5✔
66
67	struct DeviceCacheBuilder
68	{
69	using DeviceCache = std::unordered_map<device, context>;
70	/* This function implements a workaround to the current lack of a
71	* default context per root device in DPC++. The map stores a "default"
72	* context for each root device, and the QMgrHelper uses the map
73	* whenever it creates a new queue for a root device. By doing so, we
74	* avoid the performance overhead of context creation for every queue.
75	*
76	* The singleton pattern implemented here ensures that the map is
77	* created once in a thread-safe manner. Since, the map is ony read
78	* post-creation we do not need any further protection to ensure
79	* thread-safety.
80	*/
81	static const DeviceCache &getDeviceCache()
82	{	17✔
83	static DeviceCache *cache = new DeviceCache([] {	1✔
84	DeviceCache cache_l;	1✔
85	default_selector mRanker;	1✔
86	auto Platforms = platform::get_platforms();	1✔
87	for (const auto &P : Platforms) {	3✔
88	auto Devices = P.get_devices();	3✔
89	for (const auto &D : Devices) {	3✔
90	if (mRanker(D) < 0)	3✔
91	continue;	1✔
92	auto entry = cache_l.emplace(D, D);	2✔
93	if (!entry.second) {	2✔
94	std::cerr << "Fatal Error during device cache "	×
95	"construction.\n";	×
96	std::terminate();	×
97	}	×
98	}	2✔
99	}	3✔
100	return cache_l;	1✔
101	}());	1✔
102
103	return *cache;	17✔
104	}	17✔
105	};
106
107	} // namespace
108
109	#undef EL
110	#define EL Device
111	#include "dpctl_vector_templ.cpp"
112	#undef EL
113
114	DPCTLSyclContextRef
115	DPCTLDeviceMgr_GetCachedContext(__dpctl_keep const DPCTLSyclDeviceRef DRef)
116	{	27✔
117	DPCTLSyclContextRef CRef = nullptr;	27✔
118
119	auto Device = unwrap(DRef);	27✔
120	if (!Device)	27✔
121	return CRef;	10✔
122
123	auto &cache = DeviceCacheBuilder::getDeviceCache();	17✔
124	auto entry = cache.find(*Device);	17✔
125	if (entry != cache.end()) {	17✔
126	context *ContextPtr = nullptr;	16✔
127	try {	16✔
128	ContextPtr = new context(entry->second);	16✔
129	CRef = wrap(ContextPtr);	16✔
130	} catch (std::bad_alloc const &ba) {	×
131	std::cerr << ba.what() << std::endl;	×
NEW 132	delete ContextPtr;	×
133	CRef = nullptr;	×
134	}	×
135	}	16✔
136	else {	1✔
137	std::cerr << "No cached default context for device" << std::endl;	1✔
138	}	1✔
139	return CRef;	17✔
140	}	17✔
141
142	__dpctl_give DPCTLDeviceVectorRef
143	DPCTLDeviceMgr_GetDevices(int device_identifier)
144	{	8✔
145	vector_class<DPCTLSyclDeviceRef> *Devices = nullptr;	8✔
146
147	try {	8✔
148	Devices = new vector_class<DPCTLSyclDeviceRef>();	8✔
149	} catch (std::bad_alloc const &ba) {	×
NEW 150	delete Devices;	×
151	return nullptr;	×
152	}	×
153	const auto &root_devices = device::get_devices();	8✔
154	default_selector mRanker;	8✔
155
156	for (const auto &root_device : root_devices) {	24✔
157	if (mRanker(root_device) < 0)	24✔
158	continue;	8✔
159	auto Bty(DPCTL_SyclBackendToDPCTLBackendType(	16✔
160	root_device.get_platform().get_backend()));	16✔
161	auto Dty(DPCTL_SyclDeviceTypeToDPCTLDeviceType(	16✔
162	root_device.get_info<info::device::device_type>()));	16✔
163	if ((device_identifier & Bty) && (device_identifier & Dty)) {	16✔
164	Devices->emplace_back(wrap(new device(root_device)));	2✔
165	}	2✔
166	}	16✔
167	// the wrap function is defined inside dpctl_vector_templ.cpp
168	return wrap(Devices);	8✔
169	}	8✔
170
171	int DPCTLDeviceMgr_GetPositionInDevices(__dpctl_keep DPCTLSyclDeviceRef DRef,
172	int device_identifier)
173	{	2✔
174	constexpr int not_found = -1;	2✔
175	if (!DRef) {	2✔
176	return not_found;	×
177	}	×
178
179	const auto &root_devices = device::get_devices();	2✔
180	default_selector mRanker;	2✔
181	int index = not_found;	2✔
182	auto reference_device = *(unwrap(DRef));	2✔
183
184	for (const auto &root_device : root_devices) {	3✔
185	if (mRanker(root_device) < 0)	3✔
186	continue;	×
187	auto Bty(DPCTL_SyclBackendToDPCTLBackendType(	3✔
188	root_device.get_platform().get_backend()));	3✔
189	auto Dty(DPCTL_SyclDeviceTypeToDPCTLDeviceType(	3✔
190	root_device.get_info<info::device::device_type>()));	3✔
191	if ((device_identifier & Bty) && (device_identifier & Dty)) {	3✔
192	++index;	2✔
193	if (root_device == reference_device)	2✔
194	return index;	2✔
195	}	2✔
196	}	3✔
197	return not_found;	×
198	}	2✔
199
200	/*!
201	* Returns the number of available devices for a specific backend and device
202	* type combination.
203	*/
204	size_t DPCTLDeviceMgr_GetNumDevices(int device_identifier)
205	{	×
206	size_t nDevices = 0;	×
207	auto &cache = DeviceCacheBuilder::getDeviceCache();	×
208	for (const auto &entry : cache) {	×
209	auto Bty(DPCTL_SyclBackendToDPCTLBackendType(	×
210	entry.first.get_platform().get_backend()));	×
211	auto Dty(DPCTL_SyclDeviceTypeToDPCTLDeviceType(	×
212	entry.first.get_info<info::device::device_type>()));	×
213	if ((device_identifier & Bty) && (device_identifier & Dty))	×
214	++nDevices;	×
215	}	×
216	return nDevices;	×
217	}	×
218
219	/*!
220	* Prints some of the device info metadata for the device corresponding to the
221	* specified sycl::queue. Currently, device name, driver version, device
222	* vendor, and device profile are printed out. More attributed may be added
223	* later.
224	*/
225	void DPCTLDeviceMgr_PrintDeviceInfo(__dpctl_keep const DPCTLSyclDeviceRef DRef)
226	{	5✔
227	auto Device = unwrap(DRef);	5✔
228	if (Device)	5✔
229	print_device_info(*Device);	5✔
230	else	×
231	std::cout << "Device is not valid (NULL). Cannot print device info.\n";	×
232	}	5✔
233
234	int64_t DPCTLDeviceMgr_GetRelativeId(__dpctl_keep const DPCTLSyclDeviceRef DRef)
235	{	1✔
236	auto Device = unwrap(DRef);	1✔
237
238	if (Device)	1✔
239	return DPCTL_GetRelativeDeviceId(*Device);	1✔
240
241	return -1;	×
242	}	×

IntelPython / dpctl / 872829829

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