Enabled code-style for OpenVINO folder (#3385)

inference-engine/CMakeLists.txt

@@ -89,11 +89,6 @@ endfunction()
 # they must be built even if samples build is disabled (required for tests and tools).
 ie_build_samples()
 
-file(GLOB_RECURSE SAMPLES_SOURCES samples/*.cpp samples/*.hpp samples/*.h)
-add_cpplint_target(sample_cpplint
-    FOR_SOURCES ${SAMPLES_SOURCES}
-    EXCLUDE_PATTERNS "thirdparty/*" "pugixml/*")
-
 if (ENABLE_PYTHON)
     add_subdirectory(ie_bridges/python)
 endif()

openvino/conditional_compilation/CMakeLists.txt

@@ -44,3 +44,6 @@ elseif(SELECTIVE_BUILD STREQUAL "ON")
 
     ov_force_include(${TARGET_NAME} INTERFACE ${GENERATED_HEADER})
 endif()
+
+file(GLOB_RECURSE hdrs "${CMAKE_CURRENT_SOURCE_DIR}/include/*.h")
+add_cpplint_target(${TARGET_NAME}_cpplint FOR_SOURCES ${hdrs})

openvino/conditional_compilation/include/openvino/cc/factory.h

@@ -21,124 +21,127 @@
 #include <type_traits>
 #include <unordered_map>
 
-namespace openvino
+namespace openvino {
-{
+namespace cc {
-    namespace cc
-    {
-        template<typename Key, typename T>
-        class Factory;
 
-        template<typename Key, typename T, typename ...Args>
+template<typename Key, typename T>
-        class Factory<Key, T(Args...)> {
+class Factory;
-            Factory(Factory const&) = delete;
-            Factory& operator=(Factory const&) = delete;
 
-        public:
+template<typename Key, typename T, typename ...Args>
-            using builder_t = std::function<T(Args...)>;
+class Factory<Key, T(Args...)> {
+    Factory(Factory const&) = delete;
+    Factory& operator=(Factory const&) = delete;
 
-            Factory(const std::string & name)
+public:
-                : name(name) {}
+    using builder_t = std::function<T(Args...)>;
 
-        #ifdef SELECTIVE_BUILD
+    Factory(const std::string & name)
-            #define registerNodeIfRequired(Module, Name, key, Impl)       \
+        : name(name) {}
-                OV_CC_EXPAND(OV_CC_CAT(registerImpl, OV_CC_SCOPE_IS_ENABLED(OV_CC_CAT3(Module, _, Name)))<Impl>(key))
-            #define createNodeIfRegistered(Module, key, ...) createImpl(key, __VA_ARGS__)
 
-            template<typename Impl>
+#ifdef SELECTIVE_BUILD
-            void registerImpl0(const Key &) {
+    #define registerNodeIfRequired(Module, Name, key, Impl)       \
-            }
+        OV_CC_EXPAND(OV_CC_CAT(registerImpl, OV_CC_SCOPE_IS_ENABLED(OV_CC_CAT3(Module, _, Name)))<Impl>(key))
+    #define createNodeIfRegistered(Module, key, ...) createImpl(key, __VA_ARGS__)
 
-            template<typename Impl>
+    template<typename Impl>
-            void registerImpl1(const Key & key) {
+    void registerImpl0(const Key &) {
-                builders[key] = [](Args... args) -> T {
+    }
-                    Impl *impl = new Impl(args...);
-                    return static_cast<T>(impl);
-                };
-            }
 
-            T createImpl(const Key & key, Args... args) {
+    template<typename Impl>
-                auto builder = builders.find(key);
+    void registerImpl1(const Key & key) {
-                if (builder != builders.end()) {
+        builders[key] = [](Args... args) -> T {
-                    return builder->second(args...);
+            Impl *impl = new Impl(args...);
-                }
+            return static_cast<T>(impl);
-                return nullptr;
-            }
-        #elif defined(SELECTIVE_BUILD_ANALYZER)
-            #define registerNodeIfRequired(Module, Name, key, Impl) registerImpl<OV_CC_CAT(FACTORY_, Module), Impl>(key, OV_CC_TOSTRING(Name))
-            #define createNodeIfRegistered(Module, key, ...) createImpl<OV_CC_CAT(FACTORY_, Module)>(key, __VA_ARGS__)
-
-            template<openvino::itt::domain_t(*domain)(), typename Impl>
-            void registerImpl(const Key & key, const char *typeName) {
-                const std::string task_name = "REG$" + name + "$" + to_string(key) + "$" + typeName;
-                openvino::itt::ScopedTask<domain> task(openvino::itt::handle(task_name));
-                builders[key] = [](Args... args) -> T {
-                    Impl *impl = new Impl(args...);
-                    return static_cast<T>(impl);
-                };
-            }
-
-            template<openvino::itt::domain_t(*domain)()>
-            T createImpl(const Key & key, Args... args) {
-                auto builder = builders.find(key);
-                if (builder != builders.end()) {
-                    const std::string task_name = "CREATE$" + name + "$" + to_string(key);
-                    openvino::itt::ScopedTask<domain> task(openvino::itt::handle(task_name));
-                    return builder->second(args...);
-                }
-                return nullptr;
-            }
-        #else
-            #define registerNodeIfRequired(Module, Name, key, Impl) registerImpl<Impl>(key)
-            #define createNodeIfRegistered(Module, key, ...) createImpl(key, __VA_ARGS__)
-
-            template<typename Impl>
-            void registerImpl(const Key & key) {
-                builders[key] = [](Args... args) -> T {
-                    Impl *impl = new Impl(args...);
-                    return static_cast<T>(impl);
-                };
-            }
-
-            T createImpl(const Key & key, Args... args) {
-                auto builder = builders.find(key);
-                if (builder != builders.end()) {
-                    return builder->second(args...);
-                }
-                return nullptr;
-            }
-        #endif
-
-            template<typename Fn>
-            void foreach(Fn fn) const {
-                for (auto itm : builders)
-                    fn(itm);
-            }
-
-            size_t size() const noexcept {
-                return builders.size();
-            }
-
-        private:
-            const std::string & to_string(const std::string & str) const noexcept {
-                return str;
-            }
-
-            template<typename V,
-                    typename std::enable_if<std::is_enum<V>::value, bool>::type = true>
-            std::string to_string(V val) const {
-                return std::to_string(static_cast<int>(val));
-            }
-
-            template<typename V,
-                    typename std::enable_if<!std::is_enum<V>::value, bool>::type = true>
-            std::string to_string(V val) const {
-                return std::to_string(val);
-            }
-
-            using map_t = std::unordered_map<Key, builder_t>;
-
-            const std::string name;
-            map_t builders;
         };
     }
-}
+
+    T createImpl(const Key & key, Args... args) {
+        auto builder = builders.find(key);
+        if (builder != builders.end()) {
+            return builder->second(args...);
+        }
+        return nullptr;
+    }
+
+#elif defined(SELECTIVE_BUILD_ANALYZER)
+    #define registerNodeIfRequired(Module, Name, key, Impl) registerImpl<OV_CC_CAT(FACTORY_, Module), Impl>(key, OV_CC_TOSTRING(Name))
+    #define createNodeIfRegistered(Module, key, ...) createImpl<OV_CC_CAT(FACTORY_, Module)>(key, __VA_ARGS__)
+
+    template<openvino::itt::domain_t(*domain)(), typename Impl>
+    void registerImpl(const Key & key, const char *typeName) {
+        const std::string task_name = "REG$" + name + "$" + to_string(key) + "$" + typeName;
+        openvino::itt::ScopedTask<domain> task(openvino::itt::handle(task_name));
+        builders[key] = [](Args... args) -> T {
+            Impl *impl = new Impl(args...);
+            return static_cast<T>(impl);
+        };
+    }
+
+    template<openvino::itt::domain_t(*domain)()>
+    T createImpl(const Key & key, Args... args) {
+        auto builder = builders.find(key);
+        if (builder != builders.end()) {
+            const std::string task_name = "CREATE$" + name + "$" + to_string(key);
+            openvino::itt::ScopedTask<domain> task(openvino::itt::handle(task_name));
+            return builder->second(args...);
+        }
+        return nullptr;
+    }
+
+#else
+
+    #define registerNodeIfRequired(Module, Name, key, Impl) registerImpl<Impl>(key)
+    #define createNodeIfRegistered(Module, key, ...) createImpl(key, __VA_ARGS__)
+
+    template<typename Impl>
+    void registerImpl(const Key & key) {
+        builders[key] = [](Args... args) -> T {
+            Impl *impl = new Impl(args...);
+            return static_cast<T>(impl);
+        };
+    }
+
+    T createImpl(const Key & key, Args... args) {
+        auto builder = builders.find(key);
+        if (builder != builders.end()) {
+            return builder->second(args...);
+        }
+        return nullptr;
+    }
+#endif
+
+    template<typename Fn>
+    void foreach(Fn fn) const {
+        for (auto itm : builders)
+            fn(itm);
+    }
+
+    size_t size() const noexcept {
+        return builders.size();
+    }
+
+private:
+    const std::string & to_string(const std::string & str) const noexcept {
+        return str;
+    }
+
+    template<typename V,
+            typename std::enable_if<std::is_enum<V>::value, bool>::type = true>
+    std::string to_string(V val) const {
+        return std::to_string(static_cast<int>(val));
+    }
+
+    template<typename V,
+            typename std::enable_if<!std::is_enum<V>::value, bool>::type = true>
+    std::string to_string(V val) const {
+        return std::to_string(val);
+    }
+
+    using map_t = std::unordered_map<Key, builder_t>;
+
+    const std::string name;
+    map_t builders;
+};
+
+}  // namespace cc
+}  // namespace openvino

openvino/conditional_compilation/include/openvino/cc/selective_build.h

@@ -70,50 +70,52 @@
 #include <openvino/itt.hpp>
 
 #ifdef SELECTIVE_BUILD_ANALYZER
-#include <string>
+# include <string>
 #endif
 
 #include <utility>
 #include <tuple>
 
-namespace openvino
+namespace openvino {
-{
+namespace cc {
-    namespace cc
+
-    {
 #ifndef SELECTIVE_BUILD_ANALYZER
-        namespace internal
-        {
-            template<typename C, typename T>
-            struct case_wrapper {
-                using type = T;
-                const C value {};
 
-                case_wrapper(C && val)
+namespace internal {
-                    : value(std::forward<C>(val))
-                {}
-            };
 
-            template<typename T, typename C>
+template<typename C, typename T>
-            case_wrapper<C, T> make_case_wrapper(C && val) {
+struct case_wrapper {
-                return case_wrapper<C, T>(std::forward<C>(val));
+    using type = T;
-            }
+    const C value {};
 
-            template<template<typename...> class Fn, typename Ctx, typename T, typename Case>
+    case_wrapper(C && val)
-            bool match(Ctx && ctx, T && val, Case && cs) {
+        : value(std::forward<C>(val))
-                const bool is_matched = val == cs.value;
+    {}
-                if (is_matched)
+};
-                    Fn<typename Case::type>()(std::forward<Ctx>(ctx));
-                return is_matched;
-            }
 
-            template<template<typename...> class Fn, typename Ctx, typename T, typename Case, typename ...Cases>
+template<typename T, typename C>
-            bool match(Ctx && ctx, T && val, Case && cs, Cases&&... cases) {
+case_wrapper<C, T> make_case_wrapper(C && val) {
-                if (match<Fn>(std::forward<Ctx>(ctx), std::forward<T>(val), std::forward<Case>(cs)))
+    return case_wrapper<C, T>(std::forward<C>(val));
-                    return true;
+}
-                return match<Fn>(std::forward<Ctx>(ctx), std::forward<T>(val), std::forward<Cases>(cases)...);
+
-            }
+template<template<typename...> class Fn, typename Ctx, typename T, typename Case>
-        }   // namespace internal
+bool match(Ctx && ctx, T && val, Case && cs) {
-#endif
+    const bool is_matched = val == cs.value;
+    if (is_matched)
+        Fn<typename Case::type>()(std::forward<Ctx>(ctx));
+    return is_matched;
+}
+
+template<template<typename...> class Fn, typename Ctx, typename T, typename Case, typename ...Cases>
+bool match(Ctx && ctx, T && val, Case && cs, Cases&&... cases) {
+    if (match<Fn>(std::forward<Ctx>(ctx), std::forward<T>(val), std::forward<Case>(cs)))
+        return true;
+    return match<Fn>(std::forward<Ctx>(ctx), std::forward<T>(val), std::forward<Cases>(cases)...);
+}
+
+}  // namespace internal
+
+#endif  // SELECTIVE_BUILD_ANALYZER
 
 // Macros for names concatenation
 #define OV_CC_CAT_(x, y) x ## y
@@ -137,52 +139,53 @@ namespace openvino
     OV_ITT_DOMAIN(OV_CC_CAT(SWITCH_, Module));  /* Domain for switch/cases */                       \
     OV_ITT_DOMAIN(OV_CC_CAT(FACTORY_, Module)); /* Domain for factories */
 
-namespace internal
+namespace internal {
-{
-    template<typename C, typename T>
-    struct case_wrapper {
-        using type = T;
-        const C value {};
-        const char *name = nullptr;
 
-        case_wrapper(C && val, const char *name)
+template<typename C, typename T>
-            : value(std::forward<C>(val))
+struct case_wrapper {
-            , name(name)
+    using type = T;
-        {}
+    const C value {};
-    };
+    const char *name = nullptr;
 
-    template<typename T, typename C>
+    case_wrapper(C && val, const char *name)
-    case_wrapper<C, T> make_case_wrapper(C && val, const char *name) {
+        : value(std::forward<C>(val))
-        return case_wrapper<C, T>(std::forward<C>(val), name);
+        , name(name)
+    {}
+};
+
+template<typename T, typename C>
+case_wrapper<C, T> make_case_wrapper(C && val, const char *name) {
+    return case_wrapper<C, T>(std::forward<C>(val), name);
+}
+
+template<openvino::itt::domain_t(*domain)(),
+        template<typename...> class Fn,
+        typename Ctx,
+        typename T,
+        typename Case>
+bool match(char const *region, Ctx && ctx, T && val, Case && cs) {
+    const bool is_matched = val == cs.value;
+    if (is_matched) {
+        openvino::itt::ScopedTask<domain> task(
+            openvino::itt::handle<struct OV_CC_CAT(Task_, __LINE__)>(
+                std::string(region) + "$" + cs.name));
+        Fn<typename Case::type>()(std::forward<Ctx>(ctx));
     }
+    return is_matched;
+}
 
-    template<openvino::itt::domain_t(*domain)(),
+template<openvino::itt::domain_t(*domain)(),
-            template<typename...> class Fn,
+        template<typename...> class Fn,
-            typename Ctx,
+        typename Ctx,
-            typename T,
+        typename T,
-            typename Case>
+        typename Case, typename ...Cases>
-    bool match(char const *region, Ctx && ctx, T && val, Case && cs) {
+bool match(char const *region, Ctx && ctx, T && val, Case && cs, Cases&&... cases) {
-        const bool is_matched = val == cs.value;
+    if (match<domain, Fn>(region, std::forward<Ctx>(ctx), std::forward<T>(val), std::forward<Case>(cs)))
-        if (is_matched) {
+        return true;
-            openvino::itt::ScopedTask<domain> task(
+    return match<domain, Fn>(region, std::forward<Ctx>(ctx), std::forward<T>(val), std::forward<Cases>(cases)...);
-                openvino::itt::handle<struct OV_CC_CAT(Task_, __LINE__)>(
+}
-                    std::string(region) + "$" + cs.name));
-            Fn<typename Case::type>()(std::forward<Ctx>(ctx));
-        }
-        return is_matched;
-    }
 
-    template<openvino::itt::domain_t(*domain)(),
+}  // namespace internal
-            template<typename...> class Fn,
-            typename Ctx,
-            typename T,
-            typename Case, typename ...Cases>
-    bool match(char const *region, Ctx && ctx, T && val, Case && cs, Cases&&... cases) {
-        if (match<domain, Fn>(region, std::forward<Ctx>(ctx), std::forward<T>(val), std::forward<Case>(cs)))
-            return true;
-        return match<domain, Fn>(region, std::forward<Ctx>(ctx), std::forward<T>(val), std::forward<Cases>(cases)...);
-    }
-}   // namespace internal
 
 #define OV_SCOPE(Module, region, ...)                                                       \
     OV_ITT_SCOPED_TASK(OV_CC_CAT(SIMPLE_, Module), OV_CC_TOSTRING(region));                 \
@@ -261,5 +264,5 @@ namespace internal
 
 #endif
 
-    }
+}  // namespace cc
-}
+}  // namespace openvino

openvino/itt/CMakeLists.txt

@@ -18,7 +18,7 @@ set(TARGET_NAME itt)
 
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
-file(GLOB_RECURSE SOURCES "src/*.cpp")
+file(GLOB_RECURSE SOURCES "src/*.cpp" "src/*.hpp")
 
 if(ENABLE_PROFILING_ITT)
     if(DEFINED INTEL_VTUNE_DIR OR DEFINED ENV{INTEL_VTUNE_DIR})
@@ -71,3 +71,5 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 endif()
 
 target_include_directories(${TARGET_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+
+add_cpplint_target(${TARGET_NAME}_cpplint FOR_TARGETS ${TARGET_NAME})

openvino/itt/src/itt.cpp

@@ -21,62 +21,59 @@
 #include <ittnotify.h>
 #endif
 
-namespace openvino
+namespace openvino {
-{
+namespace itt {
-    namespace itt
+namespace internal {
-    {
+
-        namespace internal
-        {
 #ifdef ENABLE_PROFILING_ITT
-            static size_t callStackDepth()
-            {
-                static const char *env = std::getenv("OPENVINO_TRACE_DEPTH");
-                static const size_t depth = env ? std::strtoul(env, nullptr, 10): 0;
-                return depth;
-            }
 
-            static thread_local uint32_t call_stack_depth = 0;
+static size_t callStackDepth() {
-
+    static const char *env = std::getenv("OPENVINO_TRACE_DEPTH");
-            domain_t domain(char const* name)
+    static const size_t depth = env ? std::strtoul(env, nullptr, 10): 0;
-            {
+    return depth;
-                return reinterpret_cast<domain_t>(__itt_domain_create(name));
-            }
-
-            handle_t handle(char const* name)
-            {
-                return reinterpret_cast<handle_t>(__itt_string_handle_create(name));
-            }
-
-            void taskBegin(domain_t d, handle_t t)
-            {
-                if (!callStackDepth() || call_stack_depth++ < callStackDepth())
-                    __itt_task_begin(reinterpret_cast<__itt_domain*>(d),
-                                    __itt_null,
-                                    __itt_null,
-                                    reinterpret_cast<__itt_string_handle*>(t));
-            }
-
-            void taskEnd(domain_t d)
-            {
-                if (!callStackDepth() || call_stack_depth-- > 0)
-                    __itt_task_end(reinterpret_cast<__itt_domain*>(d));
-            }
-
-            void threadName(const char* name)
-            {
-                __itt_thread_set_name(name);
-            }
-#else
-            domain_t domain(char const *) { return nullptr; }
-
-            handle_t handle(char const *) { return nullptr; }
-
-            void taskBegin(domain_t, handle_t) { }
-
-            void taskEnd(domain_t) { }
-
-            void threadName(const char *) { }
-#endif
-        }
-    }
 }
+
+static thread_local uint32_t call_stack_depth = 0;
+
+domain_t domain(char const* name) {
+    return reinterpret_cast<domain_t>(__itt_domain_create(name));
+}
+
+handle_t handle(char const* name) {
+    return reinterpret_cast<handle_t>(__itt_string_handle_create(name));
+}
+
+void taskBegin(domain_t d, handle_t t) {
+    if (!callStackDepth() || call_stack_depth++ < callStackDepth())
+        __itt_task_begin(reinterpret_cast<__itt_domain*>(d),
+                        __itt_null,
+                        __itt_null,
+                        reinterpret_cast<__itt_string_handle*>(t));
+}
+
+void taskEnd(domain_t d) {
+    if (!callStackDepth() || call_stack_depth-- > 0)
+        __itt_task_end(reinterpret_cast<__itt_domain*>(d));
+}
+
+void threadName(const char* name) {
+    __itt_thread_set_name(name);
+}
+
+#else
+
+domain_t domain(char const *) { return nullptr; }
+
+handle_t handle(char const *) { return nullptr; }
+
+void taskBegin(domain_t, handle_t) { }
+
+void taskEnd(domain_t) { }
+
+void threadName(const char *) { }
+
+#endif  // ENABLE_PROFILING_ITT
+
+}  // namespace internal
+}  // namespace itt
+}  // namespace openvino