26851423195

Committed 02 Jun 2026 10:20PM UTC coverage: 75.45% (+0.06%) from 75.39%

Build # 26851423195

Build Type

Pull #2250

github

Committed by

web-flow

Commit Message

Merge 3b675fcbf into e5aeac39b

Pull Request Pull Request #2250: Remove `python-gil` requirement and enable free-threaded Python

Coverage Stats

824 of 1146 branches covered (71.9%)

Branch coverage included in aggregate %.

21 of 22 new or added lines in 2 files covered. (95.45%)

5 existing lines in 2 files now uncovered.

3196 of 4182 relevant lines covered (76.42%)

272.85 hits per line

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

74.07

/libsyclinterface/helper/source/dpctl_error_handlers.cpp

//===-- dpctl_async_error_handler.h - An async error handler     -*-C++-*- ===//
//
//                      Data Parallel Control (dpctl)
//
// Copyright 2020-2025 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
/// A functor to use for passing an error handler callback function to sycl
/// context and queue constructors.
//===----------------------------------------------------------------------===//

#include "dpctl_error_handlers.h"
#include "dpctl_service.h"
#include <cstring>
#include <sstream>
#ifdef _WIN32
#include <cstdlib>
#include <stddef.h>
#endif
#ifdef ENABLE_GLOG
#include <glog/logging.h>
#endif

void DPCTL_AsyncErrorHandler::operator()(const sycl::exception_list &exceptions)
{
    for (std::exception_ptr const &e : exceptions) {
        try {
            std::rethrow_exception(e);
        } catch (sycl::exception const &e) {
            error_handler(e, __FILE__, __func__, __LINE__);
            auto err_code = e.code().value();
            handler_(static_cast<int>(err_code));
        }
    }
}

namespace
{
int requested_verbosity_level(void)
{
    char *verbose = nullptr;

#ifdef _WIN32
    size_t len = 0;
    _dupenv_s(&verbose, &len, "DPCTL_VERBOSITY");
#else
    verbose = std::getenv("DPCTL_VERBOSITY");
#endif

    int requested_level = 0;

    if (verbose) {
        if (!std::strncmp(verbose, "none", 4))
            requested_level = error_level::none;
        else if (!std::strncmp(verbose, "error", 5))
            requested_level = error_level::error;
        else if (!std::strncmp(verbose, "warning", 7))
            requested_level = error_level::warning;
    }

#ifdef _WIN32
    if (verbose)
        free(verbose);
#endif

    return requested_level;
}

void output_message(std::string ss_str, error_level error_type)
{
#ifdef ENABLE_GLOG
    switch (error_type) {
    case error_level::error:
        LOG(ERROR) << "[ERR] " << ss_str;
        break;
    case error_level::warning:
        LOG(WARNING) << "[WARN] " << ss_str;
        break;
    default:
        LOG(FATAL) << "[FATAL] " << ss_str;
    }
#else
    switch (error_type) {
    case error_level::error:
        std::cerr << "[ERR] " << ss_str;
        break;
    case error_level::warning:
        std::cerr << "[WARN] " << ss_str;
        break;
    default:
        std::cerr << "[FATAL] " << ss_str;
    }
#endif
}

} // namespace

void error_handler(const std::exception &e,
                   const char *file_name,
                   const char *func_name,
                   int line_num,
                   error_level error_type)
{
    int requested_level = requested_verbosity_level();
    int error_level = static_cast<int>(error_type);

    bool to_output = requested_level >= error_level;

    if (to_output) {
        std::stringstream ss;
        ss << e.what() << " in " << func_name << " at " << file_name << ":"
           << line_num << std::endl;

        output_message(ss.str(), error_type);
    }
}

void error_handler(const std::string &what,
                   const char *file_name,
                   const char *func_name,
                   int line_num,
                   error_level error_type)
{
    int requested_level = requested_verbosity_level();
    int error_level = static_cast<int>(error_type);

    bool to_output = requested_level >= error_level;

    if (to_output) {
        std::stringstream ss;
        ss << what << " in " << func_name << " at " << file_name << ":"
           << line_num << std::endl;

        output_message(ss.str(), error_type);
    }
}

1	//===-- dpctl_async_error_handler.h - An async error handler --C++-- ===//
2	//
3	// Data Parallel Control (dpctl)
4	//
5	// Copyright 2020-2025 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	/// A functor to use for passing an error handler callback function to sycl
23	/// context and queue constructors.
24	//===----------------------------------------------------------------------===//
25
26	#include "dpctl_error_handlers.h"
27	#include "dpctl_service.h"
28	#include <cstring>
29	#include <sstream>
30	#ifdef _WIN32
31	#include <cstdlib>
32	#include <stddef.h>
33	#endif
34	#ifdef ENABLE_GLOG
35	#include <glog/logging.h>
36	#endif
37
38	void DPCTL_AsyncErrorHandler::operator()(const sycl::exception_list &exceptions)
UNCOV 39	{	×
40	for (std::exception_ptr const &e : exceptions) {	×
41	try {	×
42	std::rethrow_exception(e);	×
43	} catch (sycl::exception const &e) {	×
44	error_handler(e, __FILE__, __func__, __LINE__);	×
45	auto err_code = e.code().value();	×
46	handler_(static_cast<int>(err_code));	×
47	}	×
48	}	×
49	}	×
50
51	namespace
52	{
53	int requested_verbosity_level(void)
54	{	3,872✔
55	char *verbose = nullptr;	3,872✔
56
57	#ifdef _WIN32
58	size_t len = 0;
59	_dupenv_s(&verbose, &len, "DPCTL_VERBOSITY");
60	#else
61	verbose = std::getenv("DPCTL_VERBOSITY");	3,872✔
62	#endif	3,872✔
63
64	int requested_level = 0;	3,872✔
65
66	if (verbose) {	3,872✔
67	if (!std::strncmp(verbose, "none", 4))	2,008!
UNCOV 68	requested_level = error_level::none;	×
69	else if (!std::strncmp(verbose, "error", 5))	2,008!
UNCOV 70	requested_level = error_level::error;	×
71	else if (!std::strncmp(verbose, "warning", 7))	2,008!
72	requested_level = error_level::warning;	2,008✔
73	}	2,008✔
74
75	#ifdef _WIN32
76	if (verbose)
77	free(verbose);
78	#endif
79
80	return requested_level;	3,872✔
81	}	3,872✔
82
83	void output_message(std::string ss_str, error_level error_type)
84	{	2,008✔
85	#ifdef ENABLE_GLOG
86	switch (error_type) {
87	case error_level::error:
88	LOG(ERROR) << "[ERR] " << ss_str;
89	break;
90	case error_level::warning:
91	LOG(WARNING) << "[WARN] " << ss_str;
92	break;
93	default:
94	LOG(FATAL) << "[FATAL] " << ss_str;
95	}
96	#else
97	switch (error_type) {	2,008✔
98	case error_level::error:	1,604✔
99	std::cerr << "[ERR] " << ss_str;	1,604✔
100	break;	1,604✔
101	case error_level::warning:	404✔
102	std::cerr << "[WARN] " << ss_str;	404✔
103	break;	404✔
UNCOV 104	default:	×
105	std::cerr << "[FATAL] " << ss_str;	×
106	}	2,008✔
107	#endif	2,008✔
108	}	2,008✔
109
110	} // namespace
111
112	void error_handler(const std::exception &e,
113	const char *file_name,
114	const char *func_name,
115	int line_num,
116	error_level error_type)
117	{	3,432✔
118	int requested_level = requested_verbosity_level();	3,432✔
119	int error_level = static_cast<int>(error_type);	3,432✔
120
121	bool to_output = requested_level >= error_level;	3,432✔
122
123	if (to_output) {	3,432✔
124	std::stringstream ss;	1,603✔
125	ss << e.what() << " in " << func_name << " at " << file_name << ":"	1,603✔
126	<< line_num << std::endl;	1,603✔
127
128	output_message(ss.str(), error_type);	1,603✔
129	}	1,603✔
130	}	3,432✔
131
132	void error_handler(const std::string &what,
133	const char *file_name,
134	const char *func_name,
135	int line_num,
136	error_level error_type)
137	{	440✔
138	int requested_level = requested_verbosity_level();	440✔
139	int error_level = static_cast<int>(error_type);	440✔
140
141	bool to_output = requested_level >= error_level;	440✔
142
143	if (to_output) {	440✔
144	std::stringstream ss;	405✔
145	ss << what << " in " << func_name << " at " << file_name << ":"	405✔
146	<< line_num << std::endl;	405✔
147
148	output_message(ss.str(), error_type);	405✔
149	}	405✔
150	}	440✔

IntelPython / dpctl / 26851423195

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