880490031

Build Type

push

github

Committed by GitHub

Commit Message

Fix an issue identified by klockwork. (#478)

Run Details

64 of 120 branches covered (53.33%)

Branch coverage included in aggregate %.

1 of 2 new or added lines in 1 file covered. (50.0%)

1 existing line in 1 file now uncovered.

2853 of 4674 relevant lines covered (61.04%)

10.12 hits per line

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

65.94

/dpctl-capi/source/dpctl_sycl_platform_interface.cpp

//=== dpctl_sycl_platform_interface.cpp - Implements C API for sycl::platform //
//
//                      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_platform_interface.h.
///
//===----------------------------------------------------------------------===//

#include "dpctl_sycl_platform_interface.h"
#include "../helper/include/dpctl_utils_helper.h"
#include "Support/CBindingWrapping.h"
#include <CL/sycl.hpp>
#include <iomanip>
#include <iostream>
#include <set>
#include <sstream>

using namespace cl::sycl;

namespace
{
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(platform, DPCTLSyclPlatformRef);
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(device_selector, DPCTLSyclDeviceSelectorRef);
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(vector_class<DPCTLSyclPlatformRef>,
                                   DPCTLPlatformVectorRef);
} // namespace

__dpctl_give DPCTLSyclPlatformRef
DPCTLPlatform_Copy(__dpctl_keep const DPCTLSyclPlatformRef PRef)
{
    auto Platform = unwrap(PRef);
    if (!Platform) {
        std::cerr << "Cannot copy DPCTLSyclPlatformRef as input is a nullptr\n";
        return nullptr;
    }
    try {
        auto CopiedPlatform = new platform(*Platform);
        return wrap(CopiedPlatform);
    } catch (std::bad_alloc const &ba) {
        // \todo log error
        std::cerr << ba.what() << '\n';
        return nullptr;
    }
}

__dpctl_give DPCTLSyclPlatformRef DPCTLPlatform_Create()
{
    DPCTLSyclPlatformRef PRef = nullptr;
    try {
        auto P = new platform();
        PRef = wrap(P);
    } catch (std::bad_alloc const &ba) {
        std::cerr << ba.what() << '\n';
    }
    return PRef;
}

__dpctl_give DPCTLSyclPlatformRef DPCTLPlatform_CreateFromSelector(
    __dpctl_keep const DPCTLSyclDeviceSelectorRef DSRef)
{
    DPCTLSyclPlatformRef PRef = nullptr;
    auto DS = unwrap(DSRef);
    if (DS) {
        platform *P = nullptr;
        try {
            P = new platform(*DS);
            PRef = wrap(P);
        } catch (std::bad_alloc const &ba) {
            std::cerr << ba.what() << '\n';
            return nullptr;
        } catch (runtime_error const &re) {
            delete P;
            std::cerr << re.what() << '\n';
            return nullptr;
        }
    }
    else {
        std::cerr << "Device selector pointer cannot be NULL\n";
    }

    return PRef;
}

void DPCTLPlatform_Delete(__dpctl_take DPCTLSyclPlatformRef PRef)
{
    auto P = unwrap(PRef);
    delete P;
}

DPCTLSyclBackendType
DPCTLPlatform_GetBackend(__dpctl_keep const DPCTLSyclPlatformRef PRef)
{
    DPCTLSyclBackendType BTy = DPCTLSyclBackendType::DPCTL_UNKNOWN_BACKEND;
    auto P = unwrap(PRef);
    if (P) {
        BTy = DPCTL_SyclBackendToDPCTLBackendType(P->get_backend());
    }
    else {
        std::cerr << "Backend cannot be looked up for a NULL platform\n";
    }
    return BTy;
}

__dpctl_give const char *
DPCTLPlatform_GetName(__dpctl_keep const DPCTLSyclPlatformRef PRef)
{
    char *cstr_name = nullptr;
    auto P = unwrap(PRef);
    if (P) {
        try {
            auto name = P->get_info<info::platform::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';
        }
    }
    else {
        std::cerr << "Name cannot be looked up for a NULL platform\n";
    }
    return cstr_name;
}

__dpctl_give const char *
DPCTLPlatform_GetVendor(__dpctl_keep const DPCTLSyclPlatformRef PRef)
{
    char *cstr_vendor = nullptr;
    auto P = unwrap(PRef);
    if (P) {
        try {
            auto vendor = P->get_info<info::platform::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';
        }
    }
    else {
        std::cerr << "Vendor cannot be looked up for a NULL platform\n";
    }
    return cstr_vendor;
}

__dpctl_give const char *
DPCTLPlatform_GetVersion(__dpctl_keep const DPCTLSyclPlatformRef PRef)
{
    char *cstr_driver = nullptr;
    auto P = unwrap(PRef);
    if (P) {
        try {
            auto driver = P->get_info<info::platform::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';
        }
    }
    else {
        std::cerr << "Driver version cannot be looked up for a NULL platform\n";
    }
    return cstr_driver;
}

__dpctl_give DPCTLPlatformVectorRef DPCTLPlatform_GetPlatforms()
{
    vector_class<DPCTLSyclPlatformRef> *Platforms = nullptr;

    auto platforms = platform::get_platforms();

    try {
        Platforms = new vector_class<DPCTLSyclPlatformRef>();
        Platforms->reserve(platforms.size());
    } catch (std::bad_alloc const &ba) {
        return nullptr;
    }

    // populate the vector
    for (const auto &P : platforms) {
        Platforms->emplace_back(wrap(new platform(P)));
    }

    // the wrap function is defined inside dpctl_vector_templ.cpp
    return wrap(Platforms);
}

1	//=== dpctl_sycl_platform_interface.cpp - Implements C API for sycl::platform //
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
23	/// dpctl_sycl_platform_interface.h.
24	///
25	//===----------------------------------------------------------------------===//
26
27	#include "dpctl_sycl_platform_interface.h"
28	#include "../helper/include/dpctl_utils_helper.h"
29	#include "Support/CBindingWrapping.h"
30	#include <CL/sycl.hpp>
31	#include <iomanip>
32	#include <iostream>
33	#include <set>
34	#include <sstream>
35
36	using namespace cl::sycl;
37
38	namespace
39	{
40	DEFINE_SIMPLE_CONVERSION_FUNCTIONS(platform, DPCTLSyclPlatformRef);
41	DEFINE_SIMPLE_CONVERSION_FUNCTIONS(device_selector, DPCTLSyclDeviceSelectorRef);
42	DEFINE_SIMPLE_CONVERSION_FUNCTIONS(vector_class<DPCTLSyclPlatformRef>,
43	DPCTLPlatformVectorRef);
44	} // namespace
45
46	__dpctl_give DPCTLSyclPlatformRef
47	DPCTLPlatform_Copy(__dpctl_keep const DPCTLSyclPlatformRef PRef)
48	{	5✔
49	auto Platform = unwrap(PRef);	5✔
50	if (!Platform) {	5✔
51	std::cerr << "Cannot copy DPCTLSyclPlatformRef as input is a nullptr\n";	×
52	return nullptr;	×
53	}	×
54	try {	5✔
55	auto CopiedPlatform = new platform(*Platform);	5✔
56	return wrap(CopiedPlatform);	5✔
57	} catch (std::bad_alloc const &ba) {	×
58	// \todo log error
59	std::cerr << ba.what() << '\n';	×
60	return nullptr;	×
61	}	×
62	}	5✔
63
64	__dpctl_give DPCTLSyclPlatformRef DPCTLPlatform_Create()
65	{	8✔
66	DPCTLSyclPlatformRef PRef = nullptr;	8✔
67	try {	8✔
68	auto P = new platform();	8✔
69	PRef = wrap(P);	8✔
70	} catch (std::bad_alloc const &ba) {	×
71	std::cerr << ba.what() << '\n';	×
72	}	×
73	return PRef;	8✔
74	}	8✔
75
76	__dpctl_give DPCTLSyclPlatformRef DPCTLPlatform_CreateFromSelector(
77	__dpctl_keep const DPCTLSyclDeviceSelectorRef DSRef)
78	{	81✔
79	DPCTLSyclPlatformRef PRef = nullptr;	81✔
80	auto DS = unwrap(DSRef);	81✔
81	if (DS) {	81✔
82	platform *P = nullptr;	81✔
83	try {	81✔
84	P = new platform(*DS);	81✔
85	PRef = wrap(P);	81✔
86	} catch (std::bad_alloc const &ba) {	×
87	std::cerr << ba.what() << '\n';	×
NEW 88	return nullptr;	×
89	} catch (runtime_error const &re) {	51✔
90	delete P;	51✔
91	std::cerr << re.what() << '\n';	51✔
92	return nullptr;	51✔
93	}	51✔
UNCOV 94	}	×
95	else {	×
96	std::cerr << "Device selector pointer cannot be NULL\n";	×
97	}	×
98
99	return PRef;	30✔
100	}	81✔
101
102	void DPCTLPlatform_Delete(__dpctl_take DPCTLSyclPlatformRef PRef)
103	{	107✔
104	auto P = unwrap(PRef);	107✔
105	delete P;	107✔
106	}	107✔
107
108	DPCTLSyclBackendType
109	DPCTLPlatform_GetBackend(__dpctl_keep const DPCTLSyclPlatformRef PRef)
110	{	9✔
111	DPCTLSyclBackendType BTy = DPCTLSyclBackendType::DPCTL_UNKNOWN_BACKEND;	9✔
112	auto P = unwrap(PRef);	9✔
113	if (P) {	9✔
114	BTy = DPCTL_SyclBackendToDPCTLBackendType(P->get_backend());	9✔
115	}	9✔
116	else {	×
117	std::cerr << "Backend cannot be looked up for a NULL platform\n";	×
118	}	×
119	return BTy;	9✔
120	}	9✔
121
122	__dpctl_give const char *
123	DPCTLPlatform_GetName(__dpctl_keep const DPCTLSyclPlatformRef PRef)
124	{	9✔
125	char *cstr_name = nullptr;	9✔
126	auto P = unwrap(PRef);	9✔
127	if (P) {	9✔
128	try {	9✔
129	auto name = P->get_info<info::platform::name>();	9✔
130	auto cstr_len = name.length() + 1;	9✔
131	cstr_name = new char[cstr_len];	9✔
132	#ifdef _WIN32
133	strncpy_s(cstr_name, cstr_len, name.c_str(), cstr_len);
134	#else
135	std::strncpy(cstr_name, name.c_str(), cstr_len);	9✔
136	#endif	9✔
137	} catch (std::bad_alloc const &ba) {	×
138	// \todo log error
139	std::cerr << ba.what() << '\n';	×
140	} catch (runtime_error const &re) {	×
141	// \todo log error
142	std::cerr << re.what() << '\n';	×
143	}	×
144	}	9✔
145	else {	×
146	std::cerr << "Name cannot be looked up for a NULL platform\n";	×
147	}	×
148	return cstr_name;	9✔
149	}	9✔
150
151	__dpctl_give const char *
152	DPCTLPlatform_GetVendor(__dpctl_keep const DPCTLSyclPlatformRef PRef)
153	{	9✔
154	char *cstr_vendor = nullptr;	9✔
155	auto P = unwrap(PRef);	9✔
156	if (P) {	9✔
157	try {	9✔
158	auto vendor = P->get_info<info::platform::vendor>();	9✔
159	auto cstr_len = vendor.length() + 1;	9✔
160	cstr_vendor = new char[cstr_len];	9✔
161	#ifdef _WIN32
162	strncpy_s(cstr_vendor, cstr_len, vendor.c_str(), cstr_len);
163	#else
164	std::strncpy(cstr_vendor, vendor.c_str(), cstr_len);	9✔
165	#endif	9✔
166	} catch (std::bad_alloc const &ba) {	×
167	// \todo log error
168	std::cerr << ba.what() << '\n';	×
169	} catch (runtime_error const &re) {	×
170	// \todo log error
171	std::cerr << re.what() << '\n';	×
172	}	×
173	}	9✔
174	else {	×
175	std::cerr << "Vendor cannot be looked up for a NULL platform\n";	×
176	}	×
177	return cstr_vendor;	9✔
178	}	9✔
179
180	__dpctl_give const char *
181	DPCTLPlatform_GetVersion(__dpctl_keep const DPCTLSyclPlatformRef PRef)
182	{	9✔
183	char *cstr_driver = nullptr;	9✔
184	auto P = unwrap(PRef);	9✔
185	if (P) {	9✔
186	try {	9✔
187	auto driver = P->get_info<info::platform::version>();	9✔
188	auto cstr_len = driver.length() + 1;	9✔
189	cstr_driver = new char[cstr_len];	9✔
190	#ifdef _WIN32
191	strncpy_s(cstr_driver, cstr_len, driver.c_str(), cstr_len);
192	#else
193	std::strncpy(cstr_driver, driver.c_str(), cstr_len);	9✔
194	#endif	9✔
195	} catch (std::bad_alloc const &ba) {	×
196	// \todo log error
197	std::cerr << ba.what() << '\n';	×
198	} catch (runtime_error const &re) {	×
199	// \todo log error
200	std::cerr << re.what() << '\n';	×
201	}	×
202	}	9✔
203	else {	×
204	std::cerr << "Driver version cannot be looked up for a NULL platform\n";	×
205	}	×
206	return cstr_driver;	9✔
207	}	9✔
208
209	__dpctl_give DPCTLPlatformVectorRef DPCTLPlatform_GetPlatforms()
210	{	1✔
211	vector_class<DPCTLSyclPlatformRef> *Platforms = nullptr;	1✔
212
213	auto platforms = platform::get_platforms();	1✔
214
215	try {	1✔
216	Platforms = new vector_class<DPCTLSyclPlatformRef>();	1✔
217	Platforms->reserve(platforms.size());	1✔
218	} catch (std::bad_alloc const &ba) {	×
219	return nullptr;	×
220	}	×
221
222	// populate the vector
223	for (const auto &P : platforms) {	3✔
224	Platforms->emplace_back(wrap(new platform(P)));	3✔
225	}	3✔
226
227	// the wrap function is defined inside dpctl_vector_templ.cpp
228	return wrap(Platforms);	1✔
229	}	1✔

IntelPython / dpctl / 880490031

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