diff --git a/cpp/daal/include/services/cpu_type.h b/cpp/daal/include/services/cpu_type.h index b76dba88e24..16504bcf247 100644 --- a/cpp/daal/include/services/cpu_type.h +++ b/cpp/daal/include/services/cpu_type.h @@ -40,5 +40,25 @@ enum CpuType lastCpuType = rv64 #endif }; + +/** + * Supported CPU features. + * The features are defined as bit masks in order to allow for easy combination of features. + * For example, (avx512_bf16 | avx512_vnni) will return a bit mask that indicates both the avx512_bf16 + * and avx512_vnni features are supported. + * This allows for easy checking if a specific feature is supported by using a bitwise AND operation. + * For example, (cpuFeatures & avx512_bf16) will return true if the avx512_bf16 feature is supported. + */ +enum CpuFeature +{ + unknown = 0ULL, /*!< Unknown features */ +#if defined(TARGET_X86_64) + sstep = (1ULL << 0), /*!< Intel(R) SpeedStep */ + tb = (1ULL << 1), /*!< Intel(R) Turbo Boost */ + avx512_bf16 = (1ULL << 2), /*!< AVX-512 bfloat16 */ + avx512_vnni = (1ULL << 3), /*!< AVX-512 Vector Neural Network Instructions (VNNI) */ + tb3 = (1ULL << 4), /*!< Intel(R) Turbo Boost Max 3.0 */ +#endif +}; } // namespace daal #endif diff --git a/cpp/daal/src/services/compiler/generic/env_detect_features.cpp b/cpp/daal/src/services/compiler/generic/env_detect_features.cpp index a755d389338..dd87f96498f 100644 --- a/cpp/daal/src/services/compiler/generic/env_detect_features.cpp +++ b/cpp/daal/src/services/compiler/generic/env_detect_features.cpp @@ -22,8 +22,8 @@ //-- */ -#include "services/env_detect.h" #include "services/daal_defines.h" +#include "services/internal/daal_kernel_defines.h" #if defined(TARGET_X86_64) #include @@ -103,6 +103,14 @@ DAAL_EXPORT bool daal_check_is_intel_cpu() return result; } +/// Check if the result of CPUID instruction contains the required mask. +/// +/// \param eax Input EAX register value passed to CPUID. +/// \param ecx Input ECX register value passed to CPUID. +/// \param abcd_index The index of the output register to check: +/// 0 - EAX, 1 - EBX, 2 - ECX, 3 - EDX. +/// \param mask The bit mask to check in the output register. +/// \return 1 if the mask is present in the output register, 0 otherwise. static int check_cpuid(uint32_t eax, uint32_t ecx, int abcd_index, uint32_t mask) { if (daal_get_max_extension_support() < eax) @@ -219,6 +227,7 @@ DAAL_EXPORT int __daal_serv_cpu_detect(int enable) #if defined(__APPLE__) __daal_serv_CPUHasAVX512f_enable_it_mac(); #endif + if (check_avx512_features() && daal_check_is_intel_cpu()) { return daal::avx512; @@ -236,6 +245,84 @@ DAAL_EXPORT int __daal_serv_cpu_detect(int enable) return daal::sse2; } + +int __daal_internal_enabled_cpu_detect() +{ + #ifdef DAAL_KERNEL_AVX512 + if (check_avx512_features() && daal_check_is_intel_cpu()) + { + return daal::avx512; + } + #endif + + #ifdef DAAL_KERNEL_AVX2 + if (check_avx2_features()) + { + return daal::avx2; + } + #endif + + #ifdef DAAL_KERNEL_SSE42 + if (check_sse42_features()) + { + return daal::sse42; + } + #endif + + return daal::sse2; +} + +DAAL_EXPORT int daal_enabled_cpu_detect() +{ + // We cache the result in a static variable here. + static const int result = __daal_internal_enabled_cpu_detect(); + return result; +} + + /// Check if the CPU supports the specified feature + /// \param result The result of the CPU feature detection of type DAAL_UINT64. + /// A combination of CPU features. + /// \param eax Input EAX register value passed to CPUID. + /// \param ecx Input ECX register value passed to CPUID. + /// \param abcd_id The index of the output register to check: + /// 0 - EAX, 1 - EBX, 2 - ECX, 3 - EDX. + /// \param bit The bit position in the output register to check. + /// \param feature The CPU feature to check of type daal::CpuFeature. + #define DAAL_TEST_CPU_FEATURE(result, eax, ecx, abcd_id, bit, feature) \ + if (check_cpuid(eax, ecx, abcd_id, (1 << bit))) \ + { \ + result |= feature; \ + } + +DAAL_UINT64 __daal_internal_serv_cpu_feature_detect() +{ + DAAL_UINT64 result = daal::CpuFeature::unknown; + if (!daal_check_is_intel_cpu()) + { + return result; + } + + if (check_avx512_features()) + { + DAAL_TEST_CPU_FEATURE(result, 7, 1, 0, 5, daal::CpuFeature::avx512_bf16); + DAAL_TEST_CPU_FEATURE(result, 7, 0, 2, 11, daal::CpuFeature::avx512_vnni); + } + DAAL_TEST_CPU_FEATURE(result, 1, 0, 2, 7, daal::CpuFeature::sstep); + DAAL_TEST_CPU_FEATURE(result, 6, 0, 0, 1, daal::CpuFeature::tb); + DAAL_TEST_CPU_FEATURE(result, 6, 0, 0, 14, daal::CpuFeature::tb3); + + return result; +} + + #undef DAAL_TEST_CPU_FEATURE + +DAAL_EXPORT DAAL_UINT64 daal_serv_cpu_feature_detect() +{ + // We cache the result in a static variable here. + static const DAAL_UINT64 result = __daal_internal_serv_cpu_feature_detect(); + return result; +} + #elif defined(TARGET_ARM) static bool check_sve_features() { @@ -253,6 +340,17 @@ DAAL_EXPORT int __daal_serv_cpu_detect(int enable) return -1; } +DAAL_EXPORT int daal_enabled_cpu_detect() +{ + #ifdef DAAL_KERNEL_SVE + if (check_sve_features()) + { + return daal::sve; + } + #endif + return -1; +} + void run_cpuid(uint32_t eax, uint32_t ecx, uint32_t * abcd) { // TODO: ARM implementation for cpuid @@ -262,12 +360,23 @@ bool daal_check_is_intel_cpu() { return false; } + +DAAL_EXPORT DAAL_UINT64 daal_serv_cpu_feature_detect() +{ + return daal::CpuFeature::unknown; +} + #elif defined(TARGET_RISCV64) DAAL_EXPORT int __daal_serv_cpu_detect(int enable) { return daal::rv64; } +DAAL_EXPORT int daal_enabled_cpu_detect() +{ + return daal::rv64; +} + void run_cpuid(uint32_t eax, uint32_t ecx, uint32_t * abcd) { // TODO: riscv64 implementation for cpuid @@ -277,4 +386,9 @@ bool daal_check_is_intel_cpu() { return false; } + +DAAL_EXPORT DAAL_UINT64 daal_serv_cpu_feature_detect() +{ + return daal::CpuFeature::unknown; +} #endif diff --git a/cpp/daal/src/services/service_defines.h b/cpp/daal/src/services/service_defines.h index 54e510afef4..23ba19197ca 100644 --- a/cpp/daal/src/services/service_defines.h +++ b/cpp/daal/src/services/service_defines.h @@ -30,6 +30,8 @@ #include "services/cpu_type.h" DAAL_EXPORT int __daal_serv_cpu_detect(int); +DAAL_EXPORT int daal_enabled_cpu_detect(); +DAAL_EXPORT DAAL_UINT64 daal_serv_cpu_feature_detect(); void run_cpuid(uint32_t eax, uint32_t ecx, uint32_t * abcd); DAAL_EXPORT bool daal_check_is_intel_cpu(); diff --git a/cpp/oneapi/dal/detail/cpu.cpp b/cpp/oneapi/dal/detail/cpu.cpp index 43192ad2f44..a7e58893411 100644 --- a/cpp/oneapi/dal/detail/cpu.cpp +++ b/cpp/oneapi/dal/detail/cpu.cpp @@ -39,15 +39,18 @@ ONEDAL_EXPORT cpu_extension from_daal_cpu_type(int cpu_type) { } ONEDAL_EXPORT cpu_extension detect_top_cpu_extension() { -#if defined(TARGET_ARM) - return detail::cpu_extension::sve; -#elif defined(TARGET_RISCV64) - return detail::cpu_extension::rv64; -#endif const auto daal_cpu = __daal_serv_cpu_detect(0); + return from_daal_cpu_type(daal_cpu); +} +ONEDAL_EXPORT cpu_extension detect_onedal_cpu_extension() { + const auto daal_cpu = daal_enabled_cpu_detect(); return from_daal_cpu_type(daal_cpu); } +uint64_t detect_cpu_features() { + return daal_serv_cpu_feature_detect(); +} + } // namespace v1 } // namespace oneapi::dal::detail diff --git a/cpp/oneapi/dal/detail/cpu.hpp b/cpp/oneapi/dal/detail/cpu.hpp index e979ca62c27..d2e3a71b825 100644 --- a/cpp/oneapi/dal/detail/cpu.hpp +++ b/cpp/oneapi/dal/detail/cpu.hpp @@ -19,6 +19,9 @@ #include #include "oneapi/dal/common.hpp" +#include +#include + // TODO: Clean up this redefinition and import the defines globally. #if defined(__x86_64__) || defined(__x86_64) || defined(__amd64) || defined(_M_AMD64) #define TARGET_X86_64 @@ -35,27 +38,76 @@ namespace oneapi::dal::detail { namespace v1 { +/// CPU vendor enumeration. enum class cpu_vendor { unknown = 0, intel = 1, amd = 2, arm = 3, riscv64 = 4 }; +/// CPU extension enumeration. +/// This enum is used to represent the highest supported CPU extension. enum class cpu_extension : uint64_t { none = 0U, #if defined(TARGET_X86_64) - sse2 = 1U << 0, - sse42 = 1U << 2, - avx2 = 1U << 4, - avx512 = 1U << 5 + sse2 = 1U << 0, /// Intel(R) Streaming SIMD Extensions 2 (Intel(R) SSE2) + sse42 = 1U << 2, /// Intel(R) Streaming SIMD Extensions 4.2 (Intel(R) SSE4.2) + avx2 = 1U << 4, /// Intel(R) Advanced Vector Extensions 2 (Intel(R) AVX2) + avx512 = + 1U + << 5 /// Intel(R) Xeon(R) processors based on Intel(R) Advanced Vector Extensions 512 (Intel(R) AVX-512) #elif defined(TARGET_ARM) - sve = 1U << 0 + sve = 1U << 0 /// Arm(R) processors based on Arm's Scalable Vector Extension (SVE) #elif defined(TARGET_RISCV64) - rv64 = 1U << 0 + rv64 = 1U << 0 /// RISC-V 64-bit architecture +#endif +}; + +enum class cpu_feature : uint64_t { + unknown = 0ULL, +#if defined(TARGET_X86_64) + sstep = 1ULL << 0, /// Intel(R) SpeedStep + tb = 1ULL << 1, /// Intel(R) Turbo Boost + avx512_bf16 = 1ULL << 2, /// AVX512 bfloat16 + avx512_vnni = 1ULL << 3, /// AVX512 VNNI + tb3 = 1ULL << 4 /// Intel(R) Turbo Boost Max 3.0 +#endif +}; + +/// A map of CPU features to their string representations. +/// This map is used to convert CPU feature bitmasks to human-readable strings. +/// Keys are bitflags representing CPU features. They are defined in daal::CpuFeature enumeration. +static const std::map cpu_feature_map = { + { uint64_t(cpu_feature::unknown), "Unknown" }, +#if defined(TARGET_X86_64) + { uint64_t(cpu_feature::sstep), "Intel(R) SpeedStep" }, + { uint64_t(cpu_feature::tb), "Intel(R) Turbo Boost" }, + { uint64_t(cpu_feature::avx512_bf16), "AVX-512 bfloat16" }, + { uint64_t(cpu_feature::avx512_vnni), "AVX-512 VNNI" }, + { uint64_t(cpu_feature::tb3), "Intel(R) Turbo Boost Max 3.0" } #endif }; +/// Converts a DAAL CPU extension value to oneDAL enumeration. +/// @param ext The DAAL CPU extension value. +/// @return The corresponding oneDAL CPU extension value. ONEDAL_EXPORT cpu_extension from_daal_cpu_type(int); + +/// Detects the highest supported CPU extension. +/// @return The corresponding oneDAL CPU extension value. ONEDAL_EXPORT cpu_extension detect_top_cpu_extension(); +/// Detects the highest CPU extension used by oneDAL. +/// If REQCPU was used, it might be different from the one returned by detect_top_cpu_extension. +/// @return The corresponding oneDAL CPU extension value. +ONEDAL_EXPORT cpu_extension detect_onedal_cpu_extension(); + +/// Detects the CPU features. +/// @return Bitmask representing the supported CPU features. +/// @note The bitmask is a combination of the CPU feature bitflags defined in daal::CpuFeature enumeration. +uint64_t detect_cpu_features(); + } // namespace v1 using v1::cpu_vendor; using v1::cpu_extension; +using v1::cpu_feature_map; using v1::detect_top_cpu_extension; +using v1::detect_onedal_cpu_extension; +using v1::detect_cpu_features; } // namespace oneapi::dal::detail diff --git a/cpp/oneapi/dal/detail/cpu_info.cpp b/cpp/oneapi/dal/detail/cpu_info.cpp index 78e879e1920..224cacc25b6 100644 --- a/cpp/oneapi/dal/detail/cpu_info.cpp +++ b/cpp/oneapi/dal/detail/cpu_info.cpp @@ -39,16 +39,6 @@ cpu_info::cpu_info() { #endif } -cpu_info::cpu_info(const cpu_extension cpu_extension_) { -#if defined(TARGET_X86_64) - impl_ = detail::pimpl(std::make_unique(cpu_extension_)); -#elif defined(TARGET_ARM) - impl_ = detail::pimpl(std::make_unique(cpu_extension_)); -#elif defined(TARGET_RISCV64) - impl_ = detail::pimpl(std::make_unique(cpu_extension_)); -#endif -} - detail::cpu_vendor cpu_info::get_cpu_vendor() const { return impl_->get_cpu_vendor(); } @@ -57,6 +47,14 @@ detail::cpu_extension cpu_info::get_top_cpu_extension() const { return impl_->get_top_cpu_extension(); } +detail::cpu_extension cpu_info::get_onedal_cpu_extension() const { + return impl_->get_onedal_cpu_extension(); +} + +uint64_t cpu_info::get_cpu_features() const { + return impl_->get_cpu_features(); +} + std::string cpu_info::dump() const { return impl_->dump(); } diff --git a/cpp/oneapi/dal/detail/cpu_info.hpp b/cpp/oneapi/dal/detail/cpu_info.hpp index 7f2e3fdf663..234e7821cd0 100644 --- a/cpp/oneapi/dal/detail/cpu_info.hpp +++ b/cpp/oneapi/dal/detail/cpu_info.hpp @@ -25,10 +25,11 @@ namespace v1 { class cpu_info : public cpu_info_iface { public: cpu_info(); - explicit cpu_info(const cpu_extension cpu_extension_); cpu_vendor get_cpu_vendor() const override; cpu_extension get_top_cpu_extension() const override; + cpu_extension get_onedal_cpu_extension() const override; + uint64_t get_cpu_features() const override; std::string dump() const override; diff --git a/cpp/oneapi/dal/detail/cpu_info_arm_impl.hpp b/cpp/oneapi/dal/detail/cpu_info_arm_impl.hpp index 6513ce5e5f0..c84200f4537 100644 --- a/cpp/oneapi/dal/detail/cpu_info_arm_impl.hpp +++ b/cpp/oneapi/dal/detail/cpu_info_arm_impl.hpp @@ -24,13 +24,10 @@ namespace v1 { class cpu_info_arm : public cpu_info_impl { public: cpu_info_arm() { - info_["top_cpu_extension"] = cpu_extension::sve; - info_["vendor"] = cpu_vendor::arm; - } - - explicit cpu_info_arm(const cpu_extension cpu_extension) { - info_["top_cpu_extension"] = cpu_extension; + info_["top_cpu_extension"] = detect_top_cpu_extension(); + info_["onedal_cpu_extension"] = detect_onedal_cpu_extension(); info_["vendor"] = cpu_vendor::arm; + info_["cpu_features"] = detect_cpu_features(); } }; diff --git a/cpp/oneapi/dal/detail/cpu_info_iface.hpp b/cpp/oneapi/dal/detail/cpu_info_iface.hpp index 272f6bd38ca..d0a04638ca3 100644 --- a/cpp/oneapi/dal/detail/cpu_info_iface.hpp +++ b/cpp/oneapi/dal/detail/cpu_info_iface.hpp @@ -31,6 +31,14 @@ class cpu_info_iface { /// The highest supported CPU extension virtual cpu_extension get_top_cpu_extension() const = 0; + /// The highest used by oneDAL CPU extension + /// If REQCPU make flag was used, it might be different from the one returned by get_top_cpu_extension. + virtual cpu_extension get_onedal_cpu_extension() const = 0; + + /// The CPU features avaliable on the system + /// @return The CPU features bitmask + virtual uint64_t get_cpu_features() const = 0; + /// The dump of all supported CPU features in the format: /// feature 1: value1; feature2: value2; ... virtual std::string dump() const = 0; diff --git a/cpp/oneapi/dal/detail/cpu_info_impl.cpp b/cpp/oneapi/dal/detail/cpu_info_impl.cpp index d562d33888e..5f0c24a6618 100644 --- a/cpp/oneapi/dal/detail/cpu_info_impl.cpp +++ b/cpp/oneapi/dal/detail/cpu_info_impl.cpp @@ -52,6 +52,43 @@ std::string ONEDAL_EXPORT to_string(cpu_extension extension) { return extension_str; } +template +void to_stream(const std::any& value, std::ostream& ss) { + T typed_value = std::any_cast(value); + ss << to_string(typed_value); +} + +void any_to_stream(const std::any& value, std::ostream& ss) { + const std::type_info& ti = value.type(); + if (ti == typeid(cpu_extension)) { + to_stream(value, ss); + } + else if (ti == typeid(cpu_vendor)) { + to_stream(value, ss); + } + else { + throw unimplemented{ dal::detail::error_messages::unsupported_data_type() }; + } +} + +void cpu_features_to_stream(const std::any& value, std::ostream& ss) { + std::uint64_t cpu_features = std::any_cast(value); + if (cpu_features == 0) { + const auto entry = cpu_feature_map.find(0); + if (entry == cpu_feature_map.end()) { + throw invalid_argument{ error_messages::invalid_key() }; + } + ss << entry->second; + } + else { + for (const auto& [key, feature] : cpu_feature_map) { + if (key && (cpu_features & key) != 0) { + ss << feature << ", "; + } + } + } +} + cpu_vendor cpu_info_impl::get_cpu_vendor() const { const auto entry = info_.find("vendor"); if (entry == info_.end()) { @@ -68,34 +105,36 @@ cpu_extension cpu_info_impl::get_top_cpu_extension() const { return std::any_cast(entry->second); } +cpu_extension cpu_info_impl::get_onedal_cpu_extension() const { + const auto entry = info_.find("onedal_cpu_extension"); + if (entry == info_.end()) { + throw invalid_argument{ error_messages::invalid_key() }; + } + return std::any_cast(entry->second); +} + +uint64_t cpu_info_impl::get_cpu_features() const { + const auto entry = info_.find("cpu_features"); + if (entry == info_.end()) { + throw invalid_argument{ error_messages::invalid_key() }; + } + return std::any_cast(entry->second); +} + std::string cpu_info_impl::dump() const { std::ostringstream ss; for (auto const& [name, value] : info_) { ss << name << " : "; - print_any(value, ss); + if (name == "cpu_features") { + cpu_features_to_stream(value, ss); + } + else { + any_to_stream(value, ss); + } ss << "; "; } return std::move(ss).str(); } -template -void cpu_info_impl::print(const std::any& value, std::ostringstream& ss) const { - T typed_value = std::any_cast(value); - ss << to_string(typed_value); -} - -void cpu_info_impl::print_any(const std::any& value, std::ostringstream& ss) const { - const std::type_info& ti = value.type(); - if (ti == typeid(cpu_extension)) { - print(value, ss); - } - else if (ti == typeid(cpu_vendor)) { - print(value, ss); - } - else { - throw unimplemented{ dal::detail::error_messages::unsupported_data_type() }; - } -} - } // namespace v1 } // namespace oneapi::dal::detail diff --git a/cpp/oneapi/dal/detail/cpu_info_impl.hpp b/cpp/oneapi/dal/detail/cpu_info_impl.hpp index 7e9d32e7806..f4fe99c5d73 100644 --- a/cpp/oneapi/dal/detail/cpu_info_impl.hpp +++ b/cpp/oneapi/dal/detail/cpu_info_impl.hpp @@ -34,15 +34,14 @@ class cpu_info_impl : public cpu_info_iface { cpu_extension get_top_cpu_extension() const override; + cpu_extension get_onedal_cpu_extension() const override; + + uint64_t get_cpu_features() const override; + std::string dump() const override; protected: std::map info_; - - template - void print(const std::any& value, std::ostringstream& ss) const; - - void print_any(const std::any& value, std::ostringstream& ss) const; }; } // namespace v1 diff --git a/cpp/oneapi/dal/detail/cpu_info_riscv64_impl.hpp b/cpp/oneapi/dal/detail/cpu_info_riscv64_impl.hpp index 9f9d3d894d6..e5b3d0fecf2 100644 --- a/cpp/oneapi/dal/detail/cpu_info_riscv64_impl.hpp +++ b/cpp/oneapi/dal/detail/cpu_info_riscv64_impl.hpp @@ -24,13 +24,10 @@ namespace v1 { class cpu_info_riscv64 : public cpu_info_impl { public: cpu_info_riscv64() { - info_["top_cpu_extension"] = cpu_extension::rv64; - info_["vendor"] = cpu_vendor::riscv64; - } - - explicit cpu_info_riscv64(const cpu_extension cpu_extension) { - info_["top_cpu_extension"] = cpu_extension; + info_["top_cpu_extension"] = detect_top_cpu_extension(); + info_["onedal_cpu_extension"] = detect_onedal_cpu_extension(); info_["vendor"] = cpu_vendor::riscv64; + info_["cpu_features"] = detect_cpu_features(); } }; diff --git a/cpp/oneapi/dal/detail/cpu_info_x86_impl.hpp b/cpp/oneapi/dal/detail/cpu_info_x86_impl.hpp index 1a32e0653af..ca2a197f8dc 100644 --- a/cpp/oneapi/dal/detail/cpu_info_x86_impl.hpp +++ b/cpp/oneapi/dal/detail/cpu_info_x86_impl.hpp @@ -27,12 +27,9 @@ class cpu_info_x86 : public cpu_info_impl { public: cpu_info_x86() { info_["top_cpu_extension"] = detect_top_cpu_extension(); + info_["onedal_cpu_extension"] = detect_onedal_cpu_extension(); info_["vendor"] = (daal_check_is_intel_cpu() ? cpu_vendor::intel : cpu_vendor::amd); - } - - explicit cpu_info_x86(const cpu_extension cpu_extension) { - info_["top_cpu_extension"] = cpu_extension; - info_["vendor"] = (daal_check_is_intel_cpu() ? cpu_vendor::intel : cpu_vendor::amd); + info_["cpu_features"] = detect_cpu_features(); } }; diff --git a/cpp/oneapi/dal/detail/global_context_impl.cpp b/cpp/oneapi/dal/detail/global_context_impl.cpp deleted file mode 100644 index 6fc0af4f9b9..00000000000 --- a/cpp/oneapi/dal/detail/global_context_impl.cpp +++ /dev/null @@ -1,32 +0,0 @@ -/******************************************************************************* -* Copyright contributors to the oneDAL project -* -* 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. -*******************************************************************************/ - -#include "oneapi/dal/detail/cpu.hpp" -#include "oneapi/dal/detail/global_context_impl.hpp" -#include - -namespace oneapi::dal::detail { -namespace v1 { - -global_context_impl::global_context_impl() : cpu_info_(dal::detail::detect_top_cpu_extension()) { - using daal::services::Environment; - // Call to `getCpuId` changes global settings, in particular, - // changes default number of threads in the threading layer - Environment::getInstance()->getCpuId(); -} - -} // namespace v1 -} // namespace oneapi::dal::detail diff --git a/cpp/oneapi/dal/detail/global_context_impl.hpp b/cpp/oneapi/dal/detail/global_context_impl.hpp index 66d1132100c..b8ac016512d 100644 --- a/cpp/oneapi/dal/detail/global_context_impl.hpp +++ b/cpp/oneapi/dal/detail/global_context_impl.hpp @@ -23,8 +23,6 @@ namespace v1 { class global_context_impl : public global_context_iface { public: - global_context_impl(); - const cpu_info_iface &get_cpu_info() const { return cpu_info_; }