Add files using upload-large-folder tool

.gitattributes

@@ -902,3 +902,4 @@ videochat2/lib/python3.10/site-packages/tensorflow/compiler/tf2tensorrt/_pywrap_
 videochat2/lib/python3.10/site-packages/tensorflow/compiler/mlir/quantization/tensorflow/python/pywrap_function_lib.so filter=lfs diff=lfs merge=lfs -text
 videochat2/lib/python3.10/site-packages/tensorflow/compiler/mlir/quantization/tensorflow/python/pywrap_quantize_model.so filter=lfs diff=lfs merge=lfs -text
 videochat2/lib/python3.10/site-packages/torchvision/_C.so filter=lfs diff=lfs merge=lfs -text
+videochat2/lib/python3.10/site-packages/tensorflow/compiler/mlir/quantization/tensorflow/calibrator/pywrap_calibration.so filter=lfs diff=lfs merge=lfs -text

videochat2/lib/python3.10/site-packages/tensorflow/compiler/mlir/quantization/tensorflow/calibrator/pywrap_calibration.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:da88dc5c45d96c2d1f088cc4d0eba821029954006f09ee74c8aa343caebf28c3
+size 1825945

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/include/dnnl.hpp

@@ -0,0 +1,22 @@
+/*******************************************************************************
+* Copyright 2020 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.
+*******************************************************************************/
+
+#ifndef DNNL_HPP
+#define DNNL_HPP
+
+#include "oneapi/dnnl/dnnl.hpp"
+
+#endif /* DNNL_HPP */

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/include/dnnl_config.h

@@ -0,0 +1,22 @@
+/*******************************************************************************
+* Copyright 2020 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.
+*******************************************************************************/
+
+#ifndef DNNL_CONFIG_H
+#define DNNL_CONFIG_H
+
+#include "oneapi/dnnl/dnnl_config.h"
+
+#endif /* DNNL_CONFIG_H */

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/include/dnnl_debug.h

@@ -0,0 +1,22 @@
+/*******************************************************************************
+* Copyright 2020 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.
+*******************************************************************************/
+
+#ifndef DNNL_DEBUG_H
+#define DNNL_DEBUG_H
+
+#include "oneapi/dnnl/dnnl_debug.h"
+
+#endif /* DNNL_DEBUG_H */

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/include/dnnl_ocl.h

@@ -0,0 +1,22 @@
+/*******************************************************************************
+* Copyright 2020 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.
+*******************************************************************************/
+
+#ifndef DNNL_OCL_H
+#define DNNL_OCL_H
+
+#include "oneapi/dnnl/dnnl_ocl.h"
+
+#endif /* DNNL_OCL_H */

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/include/dnnl_ocl.hpp

@@ -0,0 +1,22 @@
+/*******************************************************************************
+* Copyright 2020 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.
+*******************************************************************************/
+
+#ifndef DNNL_OCL_HPP
+#define DNNL_OCL_HPP
+
+#include "oneapi/dnnl/dnnl_ocl.hpp"
+
+#endif /* DNNL_OCL_HPP */

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/include/dnnl_sycl.h

@@ -0,0 +1,22 @@
+/*******************************************************************************
+* Copyright 2020 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.
+*******************************************************************************/
+
+#ifndef DNNL_SYCL_H
+#define DNNL_SYCL_H
+
+#include "oneapi/dnnl/dnnl_sycl.h"
+
+#endif /* DNNL_SYCL_H */

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/include/dnnl_sycl_types.h

@@ -0,0 +1,22 @@
+/*******************************************************************************
+* Copyright 2020 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.
+*******************************************************************************/
+
+#ifndef DNNL_SYCL_TYPES_H
+#define DNNL_SYCL_TYPES_H
+
+#include "oneapi/dnnl/dnnl_sycl_types.h"
+
+#endif /* DNNL_SYCL_TYPES_H */

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/include/dnnl_threadpool.h

@@ -0,0 +1,22 @@
+/*******************************************************************************
+* Copyright 2020 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.
+*******************************************************************************/
+
+#ifndef DNNL_THREADPOOL_H
+#define DNNL_THREADPOOL_H
+
+#include "oneapi/dnnl/dnnl_threadpool.h"
+
+#endif /* DNNL_THREADPOOL_H */

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/include/dnnl_threadpool_iface.hpp

@@ -0,0 +1,22 @@
+/*******************************************************************************
+* Copyright 2020 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.
+*******************************************************************************/
+
+#ifndef DNNL_THREADPOOL_IFACE_HPP
+#define DNNL_THREADPOOL_IFACE_HPP
+
+#include "oneapi/dnnl/dnnl_threadpool_iface.hpp"
+
+#endif /* DNNL_THREADPOOL_IFACE_HPP */

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/include/dnnl_types.h

@@ -0,0 +1,22 @@
+/*******************************************************************************
+* Copyright 2020 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.
+*******************************************************************************/
+
+#ifndef DNNL_TYPES_H
+#define DNNL_TYPES_H
+
+#include "oneapi/dnnl/dnnl_types.h"
+
+#endif /* DNNL_TYPES_H */

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/include/dnnl_version.h

@@ -0,0 +1,22 @@
+/*******************************************************************************
+* Copyright 2020 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.
+*******************************************************************************/
+
+#ifndef DNNL_VERSION_H
+#define DNNL_VERSION_H
+
+#include "oneapi/dnnl/dnnl_version.h"
+
+#endif /* DNNL_VERSION_H */

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/include/oneapi/dnnl/dnnl_common.h

@@ -0,0 +1,175 @@
+/*******************************************************************************
+* Copyright 2022-2023 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
+/// C common API
+
+#ifndef ONEAPI_DNNL_DNNL_COMMON_H
+#define ONEAPI_DNNL_DNNL_COMMON_H
+
+#include "oneapi/dnnl/dnnl_common_types.h"
+#include "oneapi/dnnl/dnnl_config.h"
+#include "oneapi/dnnl/dnnl_version.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// @addtogroup dnnl_api  oneDNN API
+/// @{
+
+/// @addtogroup dnnl_api_common Common API
+/// @{
+
+/// @addtogroup dnnl_api_engine Engine
+/// @{
+
+/// Returns the number of engines of a particular kind.
+///
+/// @param kind Kind of engines to count.
+/// @returns Count of the engines.
+size_t DNNL_API dnnl_engine_get_count(dnnl_engine_kind_t kind);
+
+/// Creates an engine.
+///
+/// @param engine Output engine.
+/// @param kind Engine kind.
+/// @param index Engine index that should be between 0 and the count of
+///     engines of the requested kind.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_engine_create(
+        dnnl_engine_t *engine, dnnl_engine_kind_t kind, size_t index);
+
+/// Returns the kind of an engine.
+///
+/// @param engine Engine to query.
+/// @param kind Output engine kind.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_engine_get_kind(
+        dnnl_engine_t engine, dnnl_engine_kind_t *kind);
+
+/// Destroys an engine.
+///
+/// @param engine Engine to destroy.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_engine_destroy(dnnl_engine_t engine);
+
+/// @} dnnl_api_engine
+
+/// @addtogroup dnnl_api_stream Stream
+/// @{
+
+/// Creates an execution stream.
+///
+/// @param stream Output execution stream.
+/// @param engine Engine to create the execution stream on.
+/// @param flags Stream behavior flags (@sa dnnl_stream_flags_t).
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_stream_create(
+        dnnl_stream_t *stream, dnnl_engine_t engine, unsigned flags);
+
+/// Returns the engine of a stream object.
+///
+/// @param stream Stream object.
+/// @param engine Output engine on which the stream is created.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_stream_get_engine(
+        const_dnnl_stream_t stream, dnnl_engine_t *engine);
+
+/// Waits for all primitives in the execution stream to finish computations.
+///
+/// @param stream Execution stream.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_stream_wait(dnnl_stream_t stream);
+
+/// Destroys an execution stream.
+///
+/// @param stream Execution stream to destroy.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_stream_destroy(dnnl_stream_t stream);
+
+/// @} dnnl_api_stream
+
+/// @addtogroup dnnl_api_fpmath_mode Floating-point Math Mode
+/// @{
+
+/// Returns the floating-point math mode that will be used by default
+/// for all subsequently created primitives.
+///
+/// @param mode Output FP math mode.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_get_default_fpmath_mode(dnnl_fpmath_mode_t *mode);
+
+/// Sets the floating-point math mode that will be used by default
+/// for all subsequently created primitives.
+///
+/// @param mode FP math mode. The possible values are:
+///     #dnnl_fpmath_mode_strict,
+///     #dnnl_fpmath_mode_bf16,
+///     #dnnl_fpmath_mode_f16,
+///     #dnnl_fpmath_mode_tf32,
+///     #dnnl_fpmath_mode_any.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_set_default_fpmath_mode(dnnl_fpmath_mode_t mode);
+
+/// @} dnnl_api_fpmath_mode
+
+/// @addtogroup dnnl_api_service
+/// @{
+
+/// Configures verbose output to stdout.
+///
+/// @note
+///     Enabling verbose output affects performance.
+///     This setting overrides the ONEDNN_VERBOSE environment variable.
+///
+/// @param level Verbosity level:
+///  - 0: no verbose output (default),
+///  - 1: primitive and graph information at execution,
+///  - 2: primitive and graph information at creation/compilation and execution.
+/// @returns #dnnl_invalid_arguments/#dnnl::status::invalid_arguments if the
+///     @p level value is invalid, and #dnnl_success/#dnnl::status::success on
+///     success.
+dnnl_status_t DNNL_API dnnl_set_verbose(int level);
+
+/// Returns library version information.
+/// @returns Pointer to a constant structure containing
+///  - major: major version number,
+///  - minor: minor version number,
+///  - patch: patch release number,
+///  - hash: git commit hash.
+const dnnl_version_t DNNL_API *dnnl_version(void);
+
+/// @} dnnl_api_service
+
+/// @} dnnl_api_common
+
+/// @} dnnl_api
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ONEAPI_DNNL_DNNL_COMMON_H */

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/include/oneapi/dnnl/dnnl_common_types.h

@@ -0,0 +1,210 @@
+/*******************************************************************************
+* Copyright 2022-2023 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
+/// C API common types definitions
+
+#ifndef ONEAPI_DNNL_DNNL_COMMON_TYPES_H
+#define ONEAPI_DNNL_DNNL_COMMON_TYPES_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// @cond DO_NOT_DOCUMENT_THIS
+#include <stddef.h>
+#include <stdint.h>
+
+#include "oneapi/dnnl/dnnl_config.h"
+
+/// @endcond
+
+/// @addtogroup dnnl_api oneDNN API
+/// @{
+
+/// @addtogroup dnnl_api_common Common API
+/// @{
+
+/// @addtogroup dnnl_api_utils
+/// @{
+
+/// Status values returned by the library functions.
+typedef enum {
+    /// The operation was successful
+    dnnl_success = 0,
+    /// The operation failed due to an out-of-memory condition
+    dnnl_out_of_memory = 1,
+    /// The operation failed because of incorrect function arguments
+    dnnl_invalid_arguments = 2,
+    /// The operation failed because requested functionality is not implemented
+    dnnl_unimplemented = 3,
+    /// The last available implementation is reached
+    dnnl_last_impl_reached = 4,
+    /// Primitive or engine failed on execution
+    dnnl_runtime_error = 5,
+    /// Queried element is not required for given primitive
+    dnnl_not_required = 6,
+    /// The graph is not legitimate
+    dnnl_invalid_graph = 7,
+    /// The operation is not legitimate according to op schema
+    dnnl_invalid_graph_op = 8,
+    /// The shape cannot be inferred or compiled
+    dnnl_invalid_shape = 9,
+    /// The data type cannot be inferred or compiled
+    dnnl_invalid_data_type = 10,
+} dnnl_status_t;
+
+/// @} dnnl_api_utils
+
+/// @addtogroup dnnl_api_data_types Data types
+/// @{
+
+/// Data type specification
+typedef enum {
+    /// Undefined data type, used for empty memory descriptors.
+    dnnl_data_type_undef = 0,
+    /// 16-bit/half-precision floating point.
+    dnnl_f16 = 1,
+    /// non-standard 16-bit (bfloat16 w/ 7 bit mantissa) floating point.
+    dnnl_bf16 = 2,
+    /// 32-bit/single-precision floating point.
+    dnnl_f32 = 3,
+    /// 32-bit signed integer.
+    dnnl_s32 = 4,
+    /// 8-bit signed integer.
+    dnnl_s8 = 5,
+    /// 8-bit unsigned integer.
+    dnnl_u8 = 6,
+    /// 64-bit/double-precision floating point.
+    dnnl_f64 = 7,
+    /// Boolean data type. Size is C++ implementation defined.
+    dnnl_boolean = 8,
+
+    /// Parameter to allow internal only data_types without undefined behavior.
+    /// This parameter is chosen to be valid for so long as sizeof(int) >= 2.
+    dnnl_data_type_max = 0x7fff,
+} dnnl_data_type_t;
+
+/// Maximum number of dimensions a tensor can have. Only restricts the amount
+/// of space used for the tensor description. Individual computational
+/// primitives may support only tensors of certain dimensions.
+#define DNNL_MAX_NDIMS 12
+
+/// A type to describe tensor dimension.
+typedef int64_t dnnl_dim_t;
+
+/// A type to describe tensor dimensions.
+typedef dnnl_dim_t dnnl_dims_t[DNNL_MAX_NDIMS];
+
+/// @} dnnl_api_data_types
+
+/// @addtogroup dnnl_api_fpmath_mode Floating-point Math Mode
+/// @{
+
+/// Floating-point math mode
+typedef enum {
+    /// Default behavior, no downconversions allowed
+    dnnl_fpmath_mode_strict,
+    /// Implicit f32->bf16 conversions allowed
+    dnnl_fpmath_mode_bf16,
+    /// Implicit f32->f16 conversions allowed
+    dnnl_fpmath_mode_f16,
+    /// Implicit f32->f16, f32->tf32 or f32->bf16 conversions allowed
+    dnnl_fpmath_mode_any,
+    /// Implicit f32->tf32 conversions allowed
+    dnnl_fpmath_mode_tf32,
+} dnnl_fpmath_mode_t;
+
+/// @} dnnl_api_fpmath_mode
+
+/// @addtogroup dnnl_api_engine Engine
+/// @{
+
+/// @brief Kinds of engines.
+typedef enum {
+    /// An unspecified engine.
+    dnnl_any_engine,
+    /// CPU engine.
+    dnnl_cpu,
+    /// GPU engine.
+    dnnl_gpu,
+} dnnl_engine_kind_t;
+
+/// @struct dnnl_engine
+/// @brief An opaque structure to describe an engine.
+struct dnnl_engine;
+/// @brief An engine handle.
+typedef struct dnnl_engine *dnnl_engine_t;
+#if 0
+// FIXME: looks like this never happens
+/// @brief A constant engine handle.
+typedef const struct dnnl_engine *const_dnnl_engine_t;
+#endif
+
+/// @} dnnl_api_engine
+
+/// @addtogroup dnnl_api_stream Stream
+/// @{
+
+/// @brief Stream flags.
+typedef enum {
+    // In-order execution.
+    dnnl_stream_in_order = 0x1U,
+    /// Out-of-order execution.
+    dnnl_stream_out_of_order = 0x2U,
+    /// Default stream configuration.
+    dnnl_stream_default_flags = dnnl_stream_in_order,
+#ifdef DNNL_EXPERIMENTAL_PROFILING
+    /// Enables profiling capabilities.
+    dnnl_stream_profiling = 0x4U,
+#endif
+} dnnl_stream_flags_t;
+
+/// @struct dnnl_stream
+/// An opaque structure to describe an execution stream.
+struct dnnl_stream;
+/// An execution stream handle.
+typedef struct dnnl_stream *dnnl_stream_t;
+/// A constant execution stream handle.
+typedef const struct dnnl_stream *const_dnnl_stream_t;
+
+/// @} dnnl_api_stream
+
+/// @addtogroup dnnl_api_service
+/// @{
+
+/// Structure containing version information as per [Semantic
+/// Versioning](https://semver.org)
+typedef struct {
+    int major; ///< Major version
+    int minor; ///< Minor version
+    int patch; ///< Patch version
+    const char *hash; ///< Git hash of the sources (may be absent)
+    unsigned cpu_runtime; ///< CPU runtime
+    unsigned gpu_runtime; ///< GPU runtime
+} dnnl_version_t;
+
+/// @} dnnl_api_service
+
+/// @} dnnl_api_common
+
+/// @} dnnl_api
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/include/oneapi/dnnl/dnnl_config.h

@@ -0,0 +1,200 @@
+/*******************************************************************************
+* Copyright 2019-2023 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.
+*******************************************************************************/
+
+#ifndef ONEAPI_DNNL_DNNL_CONFIG_H
+#define ONEAPI_DNNL_DNNL_CONFIG_H
+
+/// @cond DO_NOT_DOCUMENT_THIS
+
+// All symbols shall be internal unless marked as DNNL_API
+#if defined _WIN32 || defined __CYGWIN__
+#define DNNL_HELPER_DLL_IMPORT __declspec(dllimport)
+#define DNNL_HELPER_DLL_EXPORT __declspec(dllexport)
+#else
+#if __GNUC__ >= 4
+#define DNNL_HELPER_DLL_IMPORT __attribute__((visibility("default")))
+#define DNNL_HELPER_DLL_EXPORT __attribute__((visibility("default")))
+#else
+#define DNNL_HELPER_DLL_IMPORT
+#define DNNL_HELPER_DLL_EXPORT
+#endif
+#endif
+
+#ifdef DNNL_DLL
+#ifdef DNNL_DLL_EXPORTS
+#define DNNL_API DNNL_HELPER_DLL_EXPORT
+#else
+#define DNNL_API DNNL_HELPER_DLL_IMPORT
+#endif
+#else
+#define DNNL_API
+#endif
+
+#if defined(__GNUC__)
+#define DNNL_DEPRECATED __attribute__((deprecated))
+#elif defined(_MSC_VER)
+#define DNNL_DEPRECATED __declspec(deprecated)
+#else
+#define DNNL_DEPRECATED
+#endif
+
+/// @endcond
+
+// clang-format off
+
+/// @addtogroup dnnl_api_service
+/// @{
+
+/// No runtime (disabled)
+#define DNNL_RUNTIME_NONE 0u
+
+/// Sequential runtime (CPU only)
+#define DNNL_RUNTIME_SEQ 1u
+
+/// OpenMP runtime (CPU only)
+#define DNNL_RUNTIME_OMP 2u
+
+/// TBB runtime (CPU only)
+#define DNNL_RUNTIME_TBB 4u
+
+/// Threadpool runtime (CPU only)
+#define DNNL_RUNTIME_THREADPOOL 8u
+
+/// OpenCL runtime
+#define DNNL_RUNTIME_OCL 256u
+
+/// SYCL runtime
+#define DNNL_RUNTIME_SYCL 512u
+
+/// DPC++ runtime
+#define DNNL_RUNTIME_DPCPP DNNL_RUNTIME_SYCL
+
+/// @} dnnl_api_service
+
+// oneDNN CPU threading runtime
+#define DNNL_CPU_THREADING_RUNTIME DNNL_RUNTIME_THREADPOOL
+
+// oneDNN CPU engine runtime
+#define DNNL_CPU_RUNTIME DNNL_RUNTIME_THREADPOOL
+
+// oneDNN GPU engine runtime
+#define DNNL_GPU_RUNTIME DNNL_RUNTIME_NONE
+
+// clang-format on
+
+#if defined(DNNL_CPU_RUNTIME) && defined(DNNL_GPU_RUNTIME)
+#if (DNNL_CPU_RUNTIME == DNNL_RUNTIME_OCL)
+#error "Unexpected DNNL_CPU_RUNTIME"
+#endif
+#if (DNNL_GPU_RUNTIME != DNNL_RUNTIME_NONE) \
+        && (DNNL_GPU_RUNTIME != DNNL_RUNTIME_OCL) \
+        && (DNNL_GPU_RUNTIME != DNNL_RUNTIME_SYCL)
+#error "Unexpected DNNL_GPU_RUNTIME"
+#endif
+#if (DNNL_CPU_RUNTIME == DNNL_RUNTIME_NONE \
+        && DNNL_GPU_RUNTIME == DNNL_RUNTIME_NONE)
+#error "At least one runtime must be specified"
+#endif
+#else
+#error "BOTH DNNL_CPU_RUNTIME and DNNL_GPU_RUNTIME must be defined"
+#endif
+
+// For SYCL CPU, a primitive may be created and executed in different threads
+// hence the global scratchpad does not work. This enables concurrent execution
+// when CPU runtime is SYCL to avoid the issue.
+#if DNNL_CPU_RUNTIME == DNNL_RUNTIME_SYCL
+#ifndef DNNL_ENABLE_CONCURRENT_EXEC
+#define DNNL_ENABLE_CONCURRENT_EXEC
+#endif
+#endif
+
+// When defined, primitive cache stores runtime objects.
+#undef DNNL_USE_RT_OBJECTS_IN_PRIMITIVE_CACHE
+
+// When defined, DPCPP is supported.
+#undef DNNL_WITH_SYCL
+
+// When defined, Level Zero is supported.
+#undef DNNL_WITH_LEVEL_ZERO
+
+// When defined, SYCL CUDA backend is used.
+#undef DNNL_SYCL_CUDA
+
+// When defined, SYCL HIP backend is used.
+#undef DNNL_SYCL_HIP
+
+// When defined, stack checker is enabled.
+#undef DNNL_ENABLE_STACK_CHECKER
+
+// When defined, experimental features are enabled.
+#undef DNNL_EXPERIMENTAL
+
+// When defined, experimental functionality for sparse domain is enabled.
+#undef DNNL_EXPERIMENTAL_SPARSE
+
+// When defined, graph component is enabled.
+#undef ONEDNN_BUILD_GRAPH
+
+// When defined, experimental profiling capabilities are enabled.
+#undef DNNL_EXPERIMENTAL_PROFILING
+
+// List of configurating build controls
+// Workload controls
+#define BUILD_TRAINING 1
+#define BUILD_INFERENCE 0
+// Primitive controls
+#define BUILD_PRIMITIVE_ALL 1
+#define BUILD_BATCH_NORMALIZATION 0
+#define BUILD_BINARY 0
+#define BUILD_CONCAT 0
+#define BUILD_CONVOLUTION 0
+#define BUILD_DECONVOLUTION 0
+#define BUILD_ELTWISE 0
+#define BUILD_GROUP_NORMALIZATION 1
+#define BUILD_INNER_PRODUCT 0
+#define BUILD_LAYER_NORMALIZATION 0
+#define BUILD_LRN 0
+#define BUILD_MATMUL 0
+#define BUILD_POOLING 0
+#define BUILD_PRELU 0
+#define BUILD_REDUCTION 0
+#define BUILD_REORDER 0
+#define BUILD_RESAMPLING 0
+#define BUILD_RNN 0
+#define BUILD_SHUFFLE 0
+#define BUILD_SOFTMAX 0
+#define BUILD_SUM 0
+// Primitives CPU ISA controls
+#define BUILD_PRIMITIVE_CPU_ISA_ALL 1
+#define BUILD_SSE41 0
+#define BUILD_AVX2 0
+#define BUILD_AVX512 0
+#define BUILD_AMX 0
+// Primitives GPU ISA controls
+#define BUILD_PRIMITIVE_GPU_ISA_ALL 0
+#define BUILD_GEN9 0
+#define BUILD_GEN11 0
+#define BUILD_XELP 0
+#define BUILD_XEHP 0
+#define BUILD_XEHPG 0
+#define BUILD_XEHPC 0
+// GeMM kernels ISA controls
+#define BUILD_GEMM_KERNELS_ALL 1
+#define BUILD_GEMM_KERNELS_NONE 0
+#define BUILD_GEMM_SSE41 1
+#define BUILD_GEMM_AVX2 1
+#define BUILD_GEMM_AVX512 1
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/include/oneapi/dnnl/dnnl_graph.hpp

@@ -0,0 +1,1510 @@
+/*******************************************************************************
+* Copyright 2020-2023 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.
+*******************************************************************************/
+
+#ifndef ONEAPI_DNNL_DNNL_GRAPH_HPP
+#define ONEAPI_DNNL_DNNL_GRAPH_HPP
+
+#include "oneapi/dnnl/dnnl_common.hpp"
+#include "oneapi/dnnl/dnnl_graph.h"
+
+#include <limits>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+/// @addtogroup dnnl_api
+/// @{
+
+/// @addtogroup dnnl_graph_api Graph API
+/// @{
+
+namespace dnnl {
+namespace graph {
+
+/// @cond DO_NOT_DOCUMENT_THIS
+
+// Alias for common engine and stream API.
+using engine = dnnl::engine;
+using stream = dnnl::stream;
+using fpmath_mode = dnnl::fpmath_mode;
+
+/// @endcond
+
+/// @addtogroup dnnl_graph_api_utils Utilities
+/// Utility types and definitions
+/// @{
+
+/// @cond DO_NOT_DOCUMENT_THIS
+
+/// A class that provides the destructor for a oneDNN graph C API handle.
+template <typename T>
+struct graph_handle_traits : public dnnl::handle_traits<T> {};
+
+template <>
+struct graph_handle_traits<dnnl_graph_op_t> {
+    static dnnl_status_t destructor(dnnl_graph_op_t p) {
+        return dnnl_graph_op_destroy(p);
+    }
+};
+
+template <>
+struct graph_handle_traits<dnnl_graph_graph_t> {
+    static dnnl_status_t destructor(dnnl_graph_graph_t p) {
+        return dnnl_graph_graph_destroy(p);
+    }
+};
+
+template <>
+struct graph_handle_traits<dnnl_graph_tensor_t> {
+    static dnnl_status_t destructor(dnnl_graph_tensor_t p) {
+        return dnnl_graph_tensor_destroy(p);
+    }
+};
+
+template <>
+struct graph_handle_traits<dnnl_graph_partition_t> {
+    static dnnl_status_t destructor(dnnl_graph_partition_t p) {
+        return dnnl_graph_partition_destroy(p);
+    }
+};
+
+template <>
+struct graph_handle_traits<dnnl_graph_compiled_partition_t> {
+    static dnnl_status_t destructor(dnnl_graph_compiled_partition_t p) {
+        return dnnl_graph_compiled_partition_destroy(p);
+    }
+};
+
+template <>
+struct graph_handle_traits<dnnl_graph_allocator_t> {
+    static dnnl_status_t destructor(dnnl_graph_allocator_t p) {
+        return dnnl_graph_allocator_destroy(p);
+    }
+};
+
+#define DNNL_GRAPH_HANDLE_ALIAS(type) \
+    using type##_handle = dnnl::handle<dnnl_graph_##type##_t, \
+            graph_handle_traits<dnnl_graph_##type##_t>>
+
+DNNL_GRAPH_HANDLE_ALIAS(allocator);
+DNNL_GRAPH_HANDLE_ALIAS(graph);
+DNNL_GRAPH_HANDLE_ALIAS(op);
+DNNL_GRAPH_HANDLE_ALIAS(tensor);
+DNNL_GRAPH_HANDLE_ALIAS(compiled_partition);
+DNNL_GRAPH_HANDLE_ALIAS(partition);
+
+#undef DNNL_GRAPH_HANDLE_ALIAS
+
+template <bool B>
+using req = typename std::enable_if<B, bool>::type;
+
+/// @endcond
+
+/// @} dnnl_graph_api_utils
+
+/// @addtogroup dnnl_graph_api_status Status
+/// Definitions of status values returned by the library functions.
+///
+/// @{
+
+/// Status values returned by the library functions.
+enum class status {
+    /// The operation was successful
+    success = dnnl_success,
+    /// The operation failed due to an out-of-memory condition
+    out_of_memory = dnnl_out_of_memory,
+    /// The operation failed because of incorrect function arguments
+    invalid_arguments = dnnl_invalid_arguments,
+    /// The operation failed because requested functionality is not implemented
+    unimplemented = dnnl_unimplemented,
+    /// The last available implementation is reached
+    last_impl_reached = dnnl_last_impl_reached,
+    /// Primitive or engine failed on execution
+    runtime_error = dnnl_runtime_error,
+    /// Queried element is not required for given primitive
+    not_required = dnnl_not_required,
+    /// The graph is not legitimate
+    invalid_graph = dnnl_invalid_graph,
+    /// The operation is not legitimate according to op schema
+    invalid_graph_op = dnnl_invalid_graph_op,
+    /// The shape cannot be inferred or compiled
+    invalid_shape = dnnl_invalid_shape,
+    /// The data type cannot be inferred or compiled
+    invalid_data_type = dnnl_invalid_data_type,
+};
+
+/// @} dnnl_api_status
+
+/// @addtogroup dnnl_graph_api_allocator Allocator
+///
+/// Definitions of allocator which is used to acquire memory resources in
+/// partition compilation and execution. SYCL allocator
+/// (#dnnl::graph::sycl_interop::make_allocator) should be used for SYCL runtime
+/// and host allocator should be used for non-SYCL.
+///
+/// @{
+
+/// Allocator
+class allocator : public allocator_handle {
+public:
+    using allocator_handle::handle;
+
+    /// Constructs an allocator according to given function pointers
+    ///
+    /// @param host_malloc A pointer to malloc function for CPU
+    /// @param host_free A pointer to free function for CPU
+    allocator(dnnl_graph_host_allocate_f host_malloc,
+            dnnl_graph_host_deallocate_f host_free) {
+        dnnl_graph_allocator_t a = nullptr;
+        error::wrap_c_api(
+                dnnl_graph_allocator_create(&a, host_malloc, host_free),
+                "could not create allocator for cpu");
+        reset(a);
+    }
+
+    /// Default constructor
+    allocator() {
+        dnnl_graph_allocator_t a = nullptr;
+        error::wrap_c_api(dnnl_graph_allocator_create(&a, nullptr, nullptr),
+                "could not create allocator");
+        reset(a);
+    }
+};
+
+/// @} dnnl_graph_api_allocator
+
+/// @addtogroup dnnl_graph_api_engine Engine
+/// @{
+
+/// This API is a supplement for existing onednn engine API.
+inline engine make_engine_with_allocator(
+        engine::kind kind, size_t index, const allocator &alloc) {
+    dnnl_engine_t c_engine;
+    error::wrap_c_api(
+            dnnl_graph_make_engine_with_allocator(&c_engine,
+                    static_cast<dnnl_engine_kind_t>(kind), index, alloc.get()),
+            "could not make an engine with allocator");
+    return engine(c_engine);
+}
+
+/// @} dnnl_graph_api_engine
+
+/// @addtogroup dnnl_graph_api_logical_tensor Logical Tensor
+///
+/// Logical tensor describes the meta-data of the input or output tensor, like
+/// elements data type, number of dimensions, size for each dimension (shape),
+/// layout, and the property of the tensor.
+///
+/// Each logical tensor has an unique ID. The library uses logical tensor IDs to
+/// build up the connections between operations if the output of one operation
+/// has the same ID as the input of another operation. The meta-data in a
+/// logical tensor may be enriched in the framework graph as it progresses
+/// toward final execution. For example, the library doesn't require detailed
+/// shape information at the operation and graph creation stage. But shape
+/// information of input logical tensor will be required at partition
+/// compilation stage. Logical tensor is not mutable. Users must create a new
+/// logical tensor with the same ID to pass any new additional information to
+/// oneDNN Graph API. Please note that the library also has unique IDs for
+/// operations. The ID should be unique among different logical tensors, but it
+/// can have the same value between a logical tensor and an operation.
+///
+/// @{
+
+/// Logical tensor object
+class logical_tensor {
+    friend class op;
+    friend class tensor;
+    friend class partition;
+    friend class compiled_partition;
+
+    dnnl_graph_logical_tensor_t data;
+
+public:
+    /// Integer type for representing dimension sizes and indices.
+    using dim = dnnl_dim_t;
+    /// Vector of dimensions. Implementations are free to force a limit on the
+    /// vector's length.
+    using dims = std::vector<dim>;
+
+    /// Data Type
+    enum class data_type {
+        undef = dnnl_data_type_undef,
+        /// 16-bit/half-precision floating point.
+        f16 = dnnl_f16,
+        /// non-standard 16-bit (bfloat16 w/ 7 bit mantissa) floating point.
+        bf16 = dnnl_bf16,
+        /// 32-bit/single-precision floating point.
+        f32 = dnnl_f32,
+        /// 32-bit signed integer.
+        s32 = dnnl_s32,
+        /// 8-bit signed integer.
+        s8 = dnnl_s8,
+        /// 8-bit unsigned integer.
+        u8 = dnnl_u8,
+        /// Boolean data type. Size is C++ implementation defined.
+        boolean = dnnl_boolean,
+    };
+
+    /// Layout type
+    enum class layout_type {
+        /// Undefined layout type.
+        undef = dnnl_graph_layout_type_undef,
+        /// Any means to let the library to decide the layout for a tensor
+        /// during partition compilation.
+        any = dnnl_graph_layout_type_any,
+        /// Strided means that the layout of a tensor is determined by the
+        /// strides field in the logical tensor.
+        strided = dnnl_graph_layout_type_strided,
+        /// Opaque means that the layout of a tensor is the library specific.
+        /// Usually, an opaque layout is generated by a partition which is
+        /// compiled with layout type any.
+        opaque = dnnl_graph_layout_type_opaque,
+    };
+
+    /// Tensor property
+    enum class property_type {
+        /// Undefined tensor property.
+        undef = dnnl_graph_tensor_property_undef,
+        /// Variable means the tensor may be changed during computation or
+        /// between different iterations.
+        variable = dnnl_graph_tensor_property_variable,
+        /// Constant means the tensor will keep unchanged during computation and
+        /// between different iterations. It's useful for the library to apply
+        /// optimizations for constant tensors or cache constant tensors inside
+        /// the library. For example, constant weight tensors in inference
+        /// scenarios.
+        constant = dnnl_graph_tensor_property_constant,
+    };
+
+    /// default constructor
+    /// construct an empty object
+    logical_tensor() = default;
+
+    /// Constructs a logical tensor object
+    explicit logical_tensor(const dnnl_graph_logical_tensor_t &c_data)
+        : data(c_data) {}
+
+    /// Copy
+    logical_tensor(const logical_tensor &other) = default;
+
+    /// Assign
+    logical_tensor &operator=(const logical_tensor &other) = default;
+
+    /// Constructs a logical tensor object with ID, data type, ndims, layout
+    /// type, and property type.
+    ///
+    /// @param tid Logical tensor ID.
+    /// @param dtype Elements data type.
+    /// @param ndims Number of dimensions. -1 means unknown (see
+    ///     #DNNL_GRAPH_UNKNOWN_NDIMS) and 0 means a scalar tensor.
+    /// @param ltype Layout type.
+    /// @param ptype Property type.
+    logical_tensor(size_t tid, data_type dtype, int32_t ndims,
+            layout_type ltype, property_type ptype = property_type::undef) {
+        dnnl_graph_logical_tensor_t val;
+        error::wrap_c_api(
+                dnnl_graph_logical_tensor_init(&val, tid, convert_to_c(dtype),
+                        ndims, convert_to_c(ltype), convert_to_c(ptype)),
+                "could not create logical_tensor with property");
+        data = val;
+    }
+
+    /// Delegated constructor.
+    ///
+    /// @param tid Logical tensor ID.
+    /// @param dtype Elements data type.
+    /// @param ltype Layout type.
+    logical_tensor(
+            size_t tid, data_type dtype, layout_type ltype = layout_type::undef)
+        : logical_tensor(tid, dtype, DNNL_GRAPH_UNKNOWN_NDIMS, ltype) {}
+
+    /// Constructs a logical tensor object with basic information and detailed
+    /// dims.
+    ///
+    /// @param tid Logical tensor ID.
+    /// @param dtype Elements data type.
+    /// @param adims Logical tensor dimensions. #DNNL_GRAPH_UNKNOWN_DIM means
+    ///     the size of that dimension is unknown. 0 is used to define
+    ///     zero-dimension tensor.
+    /// @param ltype Layout type. If it's strided, the strides field in the
+    ///     output logical tensor will be deduced accordingly.
+    /// @param ptype Property type.
+    logical_tensor(size_t tid, data_type dtype, const dims &adims,
+            layout_type ltype, property_type ptype = property_type::undef) {
+        dnnl_graph_logical_tensor_t val;
+        // if dimension size equals to 0, it's a scalar
+        if (adims.size() == 0)
+            error::wrap_c_api(dnnl_graph_logical_tensor_init(&val, tid,
+                                      convert_to_c(dtype), 0,
+                                      convert_to_c(ltype), convert_to_c(ptype)),
+                    "could not create logical_tensor with property");
+        else
+            error::wrap_c_api(
+                    dnnl_graph_logical_tensor_init_with_dims(&val, tid,
+                            convert_to_c(dtype),
+                            static_cast<int32_t>(adims.size()), adims.data(),
+                            convert_to_c(ltype), convert_to_c(ptype)),
+                    "could not create logical_tensor with dims and property");
+        data = val;
+    }
+
+    /// Constructs a logical tensor object with detailed dims and strides. The
+    /// layout_type of the output logical tensor object will always be strided.
+    ///
+    /// @param tid Logical tensor ID.
+    /// @param dtype Elements data type.
+    /// @param adims Logical tensor dimensions. #DNNL_GRAPH_UNKNOWN_DIM means
+    ///     the size of that dimension is unknown. 0 is used to define
+    ///     zero-dimension tensor.
+    /// @param strides Logical tensor strides.  #DNNL_GRAPH_UNKNOWN_DIM means
+    ///     the stride of the dimension is unknown. The library currently
+    ///      doesn't support other negative stride values.
+    /// @param ptype Property type.
+    logical_tensor(size_t tid, data_type dtype, const dims &adims,
+            const dims &strides, property_type ptype = property_type::undef) {
+        dnnl_graph_logical_tensor_t val;
+        // TODO(lvtao): check the size of adims and strides.
+        // They should be same.
+        error::wrap_c_api(
+                dnnl_graph_logical_tensor_init_with_strides(&val, tid,
+                        convert_to_c(dtype), static_cast<int32_t>(adims.size()),
+                        adims.data(), strides.data(), convert_to_c(ptype)),
+                "could not create logical_tensor with strides and property");
+        data = val;
+    }
+
+    /// Constructs a logical tensor object with detailed dims and an opaque
+    /// layout ID. layout_type of the output logical tensor object will always
+    /// be opaque.
+    ///
+    /// @param tid Logical tensor ID.
+    /// @param dtype Elements data type.
+    /// @param adims Logical tensor dimensions. #DNNL_GRAPH_UNKNOWN_DIM means
+    ///     the size of that dimension is unknown. 0 is used to define
+    ///     zero-dimension tensor.
+    /// @param lid Opaque layout id.
+    /// @param ptype Property type
+    logical_tensor(size_t tid, data_type dtype, const dims &adims, size_t lid,
+            property_type ptype = property_type::undef) {
+        dnnl_graph_logical_tensor_t val;
+
+        if (adims.size() == 0) {
+            error::wrap_c_api(dnnl_graph_logical_tensor_init(&val, tid,
+                                      convert_to_c(dtype), 0,
+                                      convert_to_c(layout_type::opaque),
+                                      convert_to_c(ptype)),
+                    "could not create logical_tensor");
+        } else {
+            error::wrap_c_api(
+                    dnnl_graph_logical_tensor_init_with_dims(&val, tid,
+                            convert_to_c(dtype),
+                            static_cast<int32_t>(adims.size()), adims.data(),
+                            convert_to_c(layout_type::opaque),
+                            convert_to_c(ptype)),
+                    "could not create logical_tensor with dims");
+        }
+
+        val.layout.layout_id = lid;
+        data = val;
+    }
+
+    /// Returns dimensions of a logical tensor.
+    ///
+    /// @returns A vector describing the size of each dimension.
+    dims get_dims() const {
+        if (data.ndims < 0) {
+            error::wrap_c_api(dnnl_invalid_arguments,
+                    "cannot return dims when ndims < 0");
+        }
+
+        return {data.dims, data.dims + data.ndims};
+    }
+
+    /// Returns the unique id of a logical tensor.
+    ///
+    /// @returns An integer value describing the ID.
+    size_t get_id() const { return data.id; }
+
+    /// Returns the data type of a logical tensor.
+    ///
+    /// @returns The data type.
+    data_type get_data_type() const {
+        return static_cast<data_type>(data.data_type);
+    }
+
+    /// Returns the property type of a logical tensor.
+    ///
+    /// @returns The property type.
+    property_type get_property_type() const {
+        return static_cast<property_type>(data.property);
+    }
+
+    /// Returns the layout type of a logical tensor.
+    ///
+    /// @returns The layout type.
+    layout_type get_layout_type() const {
+        return static_cast<layout_type>(data.layout_type);
+    }
+
+    /// Returns the layout ID of a logical tensor. The API should be called on a
+    /// logical tensor with opaque layout type. Otherwise, an exception will be
+    /// raised.
+    ///
+    /// @returns Layout ID.
+    size_t get_layout_id() const {
+        if (get_layout_type() != layout_type::opaque) {
+            error::wrap_c_api(
+                    dnnl_invalid_arguments, "layout type should be opaque");
+        }
+
+        return data.layout.layout_id;
+    }
+
+    /// Returns the strides of a logical tensor. The API should be called on a
+    /// logical tensor with strided layout type. Otherwise, an exception will be
+    /// raised.
+    ///
+    /// @returns A vector describing the stride size of each dimension.
+    dims get_strides() const {
+        if (get_layout_type() != layout_type::strided) {
+            error::wrap_c_api(
+                    dnnl_invalid_arguments, "layout type should be strided");
+        }
+
+        if (data.ndims < 0) {
+            error::wrap_c_api(dnnl_invalid_arguments,
+                    "cannot return strides when ndims < 0");
+        }
+
+        return {data.layout.strides, data.layout.strides + data.ndims};
+    }
+
+    /// Returns memory size in bytes required by this logical tensor.
+    ///
+    /// @returns The memory size in bytes.
+    size_t get_mem_size() const {
+        size_t size = 0;
+        error::wrap_c_api(dnnl_graph_logical_tensor_get_mem_size(&data, &size),
+                "could not get memory size from the logical_tensor");
+        return size;
+    }
+
+    /// Compares if two logical tenors are equal. Users can decide accordingly
+    /// if layout reordering is needed for two logical tensors. The method will
+    /// return true for below two circumstances:
+    ///
+    /// 1. the two logical tensors are equal regarding each field in the struct,
+    /// eg. id, ndims, dims, layout type, property, etc.
+    /// 2. If all other fields are equal but the layout types in two logical
+    /// tensors are different, the method will return true when the underlying
+    /// memory layout is the same. For example, one logical tensor has strided
+    /// layout type while the other one has opaque layout type, but underneath,
+    /// both layouts are NHWC, the method will still return true for this case.
+    ///
+    /// @param lt The input logical tensor to be compared.
+    /// @returns @c true if the two logical tensors are equal. @c false otherwise
+    bool is_equal(const logical_tensor &lt) const {
+        uint8_t equal = 0;
+        error::wrap_c_api(
+                dnnl_graph_logical_tensor_is_equal(&data, &lt.data, &equal),
+                "could not compare between the two logical tensors");
+        return equal != 0;
+    }
+
+private:
+    static dnnl_data_type_t convert_to_c(data_type dtype) {
+        return static_cast<dnnl_data_type_t>(dtype);
+    }
+
+    static dnnl_graph_layout_type_t convert_to_c(layout_type ltype) {
+        return static_cast<dnnl_graph_layout_type_t>(ltype);
+    }
+
+    static dnnl_graph_tensor_property_t convert_to_c(property_type ptype) {
+        return static_cast<dnnl_graph_tensor_property_t>(ptype);
+    }
+};
+
+/// @} dnnl_graph_api_logical_tensor
+
+/// @addtogroup dnnl_graph_api_tensor Tensor
+///
+/// Tensor is an abstraction for multi-dimensional input and output data needed
+/// in the execution of a compiled partition. A tensor object encapsulates a
+/// handle to a memory buffer allocated on a specific engine and a logical
+/// tensor which describes the dimensions, elements data type, and memory
+/// layout.
+///
+/// @{
+
+/// A tensor object
+class tensor : public tensor_handle {
+public:
+    /// Default constructor. Constructs an empty object.
+    tensor() = default;
+
+    /// Constructs a tensor object according to a given logical tensor, an
+    /// engine, and a memory handle.
+    ///
+    /// @param lt The given logical tensor
+    /// @param aengine Engine to store the data on.
+    /// @param handle Handle of memory buffer to use as an underlying storage.
+    tensor(const logical_tensor &lt, const engine &aengine, void *handle) {
+        dnnl_graph_tensor_t t = nullptr;
+        error::wrap_c_api(
+                dnnl_graph_tensor_create(&t, &(lt.data), aengine.get(), handle),
+                "could not create tensor object with the logical_tensor, "
+                "engine, and handle");
+        reset(t);
+    }
+
+    /// Returns the underlying memory buffer.
+    ///
+    /// On the CPU engine, or when using USM, this is a pointer to the
+    /// allocated memory.
+    void *get_data_handle() const {
+        void *handle = nullptr;
+        error::wrap_c_api(dnnl_graph_tensor_get_data_handle(get(), &handle),
+                "could not get data handle from the tensor");
+        return handle;
+    }
+
+    /// Sets the underlying memory handle.
+    ///
+    /// @param handle Memory handle.
+    void set_data_handle(void *handle) {
+        error::wrap_c_api(dnnl_graph_tensor_set_data_handle(get(), handle),
+                "setting data handle to the tensor failed");
+    }
+
+    /// Returns the associated engine.
+    ///
+    /// @returns An engine object
+    engine get_engine() const {
+        dnnl_engine_t c_engine = nullptr;
+        error::wrap_c_api(dnnl_graph_tensor_get_engine(get(), &c_engine),
+                "could not get an engine from a tensor object");
+        return engine(c_engine, true);
+    }
+};
+
+/// @} dnnl_graph_api_tensor
+
+/// @addtogroup dnnl_graph_api_compiled_partition Compiled Partition
+///
+/// A compiled partition represents the generated kernels specialized for a
+/// partition on a target hardware (engine) with input and output information
+/// specified by the logical tensors.
+///
+/// @{
+
+/// A compiled partition object.
+class compiled_partition : public compiled_partition_handle {
+public:
+    /// Default constructor. Constructs an empty object.
+    compiled_partition() = default;
+
+    /// Constructs a compiled partition object
+    compiled_partition(dnnl_graph_compiled_partition_t compiled_partition) {
+        reset(compiled_partition, false);
+    }
+
+    /// Queries an input or output logical tensor according to tensor ID. If the
+    /// tensor ID doesn't belong to any input or output of the compiled
+    /// partition, an exception will be raised by the API.
+    ///
+    /// @param tid The unique id of required tensor.
+    /// @returns The logical tensor.
+    logical_tensor query_logical_tensor(size_t tid) const {
+        dnnl_graph_logical_tensor_t lt;
+        error::wrap_c_api(dnnl_graph_compiled_partition_query_logical_tensor(
+                                  get(), tid, &lt),
+                "query logical tensor from compiled_partition failed");
+        return logical_tensor {lt};
+    }
+
+    /// Returns the hint of in-place pairs from a compiled partition. It
+    /// indicates that an input and an output of the partition can share the
+    /// same memory buffer for computation. In-place computation helps to reduce
+    /// the memory footprint and improves cache locality. But since the library
+    /// may not have a global view of user's application, it's possible that the
+    /// input tensor is used at other places in user's computation graph. In
+    /// this case, the user should take the in-place pair as a hint and pass a
+    /// different memory buffer for output tensor to avoid overwriting the input
+    /// memory buffer which will probably cause unexpected incorrect results.
+    ///
+    /// @returns A list of pairs of input and output IDs.
+    std::vector<std::pair<size_t, size_t>> get_inplace_ports() const {
+        size_t num = 0;
+        const dnnl_graph_inplace_pair_t *inplace_pairs;
+
+        error::wrap_c_api(dnnl_graph_compiled_partition_get_inplace_ports(
+                                  get(), &num, &inplace_pairs),
+                "could not get the in-place pairs from a compiled partition");
+        if (num == 0) return {};
+
+        std::vector<std::pair<size_t, size_t>> inplace_options;
+        inplace_options.reserve(num);
+        for (size_t i = 0; i < num; ++i) {
+            const dnnl_graph_inplace_pair_t *inplace_pair = inplace_pairs + i;
+            inplace_options.emplace_back(
+                    inplace_pair->input_id, inplace_pair->output_id);
+        }
+        return inplace_options;
+    }
+
+    /// Execute a compiled partition.
+    ///
+    /// @param astream Stream object to run over.
+    /// @param inputs A list of input tensors.
+    /// @param outputs A list of output tensors.
+    void execute(stream &astream, const std::vector<tensor> &inputs,
+            const std::vector<tensor> &outputs) const {
+        std::vector<const_dnnl_graph_tensor_t> c_inputs;
+        c_inputs.reserve(inputs.size());
+        for (auto &in : inputs) {
+            c_inputs.push_back(in.get());
+        }
+        std::vector<const_dnnl_graph_tensor_t> c_outputs;
+        c_outputs.reserve(outputs.size());
+        for (auto &out : outputs) {
+            c_outputs.push_back(out.get());
+        }
+
+        error::wrap_c_api(
+                dnnl_graph_compiled_partition_execute(get(), astream.get(),
+                        c_inputs.size(), c_inputs.data(), c_outputs.size(),
+                        c_outputs.data()),
+                "could not execute the compiled_partition");
+    }
+};
+
+/// @} dnnl_graph_api_compiled_partition
+
+/// @addtogroup dnnl_graph_api_op Op
+///
+/// OP is an abstraction of computation logic for deep neural network
+/// operations. An op object encapsulates an operation kind which describes the
+/// computation logic, an unique ID which differentiates operations with the
+/// same kind, and logical tensors which describes the input and output of the
+/// operation and its connections to other operations in the graph.
+///
+/// @{
+
+/// An op object.
+class op : public op_handle {
+public:
+    /// Kinds of operations
+    enum class kind {
+        Abs = dnnl_graph_op_abs,
+        AbsBackward = dnnl_graph_op_abs_backward,
+        Add = dnnl_graph_op_add,
+        AvgPool = dnnl_graph_op_avg_pool,
+        AvgPoolBackward = dnnl_graph_op_avg_pool_backward,
+        BatchNormForwardTraining = dnnl_graph_op_batch_norm_forward_training,
+        BatchNormInference = dnnl_graph_op_batch_norm_inference,
+        BatchNormTrainingBackward = dnnl_graph_op_batch_norm_backward,
+        BiasAdd = dnnl_graph_op_bias_add,
+        BiasAddBackward = dnnl_graph_op_bias_add_backward,
+        Clamp = dnnl_graph_op_clamp,
+        ClampBackward = dnnl_graph_op_clamp_backward,
+        Concat = dnnl_graph_op_concat,
+        Convolution = dnnl_graph_op_convolution,
+        ConvolutionBackwardData = dnnl_graph_op_convolution_backward_data,
+        ConvolutionBackwardWeights = dnnl_graph_op_convolution_backward_weights,
+        ConvTranspose = dnnl_graph_op_conv_transpose,
+        ConvTransposeBackwardData = dnnl_graph_op_conv_transpose_backward_data,
+        ConvTransposeBackwardWeights
+        = dnnl_graph_op_conv_transpose_backward_weights,
+        Dequantize = dnnl_graph_op_dequantize,
+        Divide = dnnl_graph_op_divide,
+        DynamicDequantize = dnnl_graph_op_dynamic_dequantize,
+        DynamicQuantize = dnnl_graph_op_dynamic_quantize,
+        Elu = dnnl_graph_op_elu,
+        EluBackward = dnnl_graph_op_elu_backward,
+        End = dnnl_graph_op_end,
+        Exp = dnnl_graph_op_exp,
+        GELU = dnnl_graph_op_gelu,
+        GELUBackward = dnnl_graph_op_gelu_backward,
+        HardSigmoid = dnnl_graph_op_hard_sigmoid,
+        HardSigmoidBackward = dnnl_graph_op_hard_sigmoid_backward,
+        HardSwish = dnnl_graph_op_hard_swish,
+        HardSwishBackward = dnnl_graph_op_hard_swish_backward,
+        Interpolate = dnnl_graph_op_interpolate,
+        InterpolateBackward = dnnl_graph_op_interpolate_backward,
+        LayerNorm = dnnl_graph_op_layer_norm,
+        LayerNormBackward = dnnl_graph_op_layer_norm_backward,
+        LeakyReLU = dnnl_graph_op_leaky_relu,
+        Log = dnnl_graph_op_log,
+        LogSoftmax = dnnl_graph_op_log_softmax,
+        LogSoftmaxBackward = dnnl_graph_op_log_softmax_backward,
+        MatMul = dnnl_graph_op_matmul,
+        Maximum = dnnl_graph_op_maximum,
+        MaxPool = dnnl_graph_op_max_pool,
+        MaxPoolBackward = dnnl_graph_op_max_pool_backward,
+        Minimum = dnnl_graph_op_minimum,
+        Mish = dnnl_graph_op_mish,
+        MishBackward = dnnl_graph_op_mish_backward,
+        Multiply = dnnl_graph_op_multiply,
+        Pow = dnnl_graph_op_pow,
+        PReLU = dnnl_graph_op_prelu,
+        PReLUBackward = dnnl_graph_op_prelu_backward,
+        Quantize = dnnl_graph_op_quantize,
+        Reciprocal = dnnl_graph_op_reciprocal,
+        ReduceL1 = dnnl_graph_op_reduce_l1,
+        ReduceL2 = dnnl_graph_op_reduce_l2,
+        ReduceMax = dnnl_graph_op_reduce_max,
+        ReduceMean = dnnl_graph_op_reduce_mean,
+        ReduceMin = dnnl_graph_op_reduce_min,
+        ReduceProd = dnnl_graph_op_reduce_prod,
+        ReduceSum = dnnl_graph_op_reduce_sum,
+        ReLU = dnnl_graph_op_relu,
+        ReLUBackward = dnnl_graph_op_relu_backward,
+        Reorder = dnnl_graph_op_reorder,
+        Round = dnnl_graph_op_round,
+        Select = dnnl_graph_op_select,
+        Sigmoid = dnnl_graph_op_sigmoid,
+        SigmoidBackward = dnnl_graph_op_sigmoid_backward,
+        SoftMax = dnnl_graph_op_softmax,
+        SoftMaxBackward = dnnl_graph_op_softmax_backward,
+        SoftPlus = dnnl_graph_op_softplus,
+        SoftPlusBackward = dnnl_graph_op_softplus_backward,
+        Sqrt = dnnl_graph_op_sqrt,
+        SqrtBackward = dnnl_graph_op_sqrt_backward,
+        Square = dnnl_graph_op_square,
+        SquaredDifference = dnnl_graph_op_squared_difference,
+        StaticReshape = dnnl_graph_op_static_reshape,
+        StaticTranspose = dnnl_graph_op_static_transpose,
+        Subtract = dnnl_graph_op_subtract,
+        Tanh = dnnl_graph_op_tanh,
+        TanhBackward = dnnl_graph_op_tanh_backward,
+        TypeCast = dnnl_graph_op_type_cast,
+        Wildcard = dnnl_graph_op_wildcard,
+        // Sentinel
+        LastSymbol = dnnl_graph_op_last_symbol,
+    };
+
+    /// Attributes of operations. Different operations support different
+    /// attributes. Check the document of each operation for what attributes are
+    /// supported and what are the potential values for them. Missing required
+    /// attribute or illegal attribute value may lead to failure when adding the
+    /// operation to a graph.
+    enum class attr {
+        /// Undefined op attribute.
+        undef = dnnl_graph_op_attr_undef,
+
+        // float32 attributes. The value of these attributes can be any single
+        // float32 number.
+
+        /// Specifies an alpha attribute to an op.
+        alpha = dnnl_graph_op_attr_alpha,
+        /// Specifies an beta attribute to an op.
+        beta = dnnl_graph_op_attr_beta,
+        /// Specifies an epsilon attribute to an op.
+        epsilon = dnnl_graph_op_attr_epsilon,
+        /// Specifies a max attribute to an op.
+        max = dnnl_graph_op_attr_max,
+        /// Specifies a min attribute to an op.
+        min = dnnl_graph_op_attr_min,
+        /// Specifies a momentum attribute to an op.
+        momentum = dnnl_graph_op_attr_momentum,
+
+        // float32 vector attributes. The value of these attributes can be a
+        // vector of float32 numbers.
+
+        /// Specifies a scales attribute to an op.
+        scales = dnnl_graph_op_attr_scales,
+
+        // int64_t attributes. The value of these attributes can be any single
+        // int64 number.
+
+        /// Specifies an axis attribute to an op.
+        axis = dnnl_graph_op_attr_axis,
+        /// Specifies a begin_norm_axis attribute to an op.
+        begin_norm_axis = dnnl_graph_op_attr_begin_norm_axis,
+        /// Specifies a groups attribute to an op.
+        groups = dnnl_graph_op_attr_groups,
+
+        // int64_t vector attributes. The value of these attributes can be a
+        // vector of int64 numbers.
+
+        /// Specifies an axes attribute to an op.
+        axes = dnnl_graph_op_attr_axes,
+        /// Specifies a dilations attribute to an op.
+        dilations = dnnl_graph_op_attr_dilations,
+        /// Specifies an dst_shape attribute to an op.
+        dst_shape = dnnl_graph_op_attr_dst_shape,
+        /// Specifies a kernel attribute to an op.
+        kernel = dnnl_graph_op_attr_kernel,
+        /// Specifies an order attribute to an op.
+        order = dnnl_graph_op_attr_order,
+        /// Specifies an output_padding attribute to an op.
+        output_padding = dnnl_graph_op_attr_output_padding,
+        /// Specifies a pads_begin attribute to an op.
+        pads_begin = dnnl_graph_op_attr_pads_begin,
+        /// Specifies a pads_end attribute to an op.
+        pads_end = dnnl_graph_op_attr_pads_end,
+        /// Specifies a shape attribute to an op.
+        shape = dnnl_graph_op_attr_shape,
+        /// Specifies a sizes attribute to an op.
+        sizes = dnnl_graph_op_attr_sizes,
+        /// Specifies an src_shape attribute to an op.
+        src_shape = dnnl_graph_op_attr_src_shape,
+        /// Specifies a strides attribute to an op.
+        strides = dnnl_graph_op_attr_strides,
+        /// Specifies a weight_shape attribute to an op.
+        weights_shape = dnnl_graph_op_attr_weights_shape,
+        /// Specifies a zps attribute to an op.
+        zps = dnnl_graph_op_attr_zps,
+
+        // bool attributes. The value of these attributes can be any single bool
+        // value.
+
+        /// Specifies an exclude_pad attribute to an op.
+        exclude_pad = dnnl_graph_op_attr_exclude_pad,
+        /// Specifies a keep_dims attribute to an op.
+        keep_dims = dnnl_graph_op_attr_keep_dims,
+        /// Specifies a keep_stats attribute to an op.
+        keep_stats = dnnl_graph_op_attr_keep_stats,
+        /// Specifies a per_channel_broadcast attribute to an op.
+        per_channel_broadcast = dnnl_graph_op_attr_per_channel_broadcast,
+        /// Specifies a special_zero attribute to an op.
+        special_zero = dnnl_graph_op_attr_special_zero,
+        /// Specifies a transpose_a attribute to an op.
+        transpose_a = dnnl_graph_op_attr_transpose_a,
+        /// Specifies a transpose_b attribute to an op.
+        transpose_b = dnnl_graph_op_attr_transpose_b,
+        /// Specifies an use_affine attribute to an op.
+        use_affine = dnnl_graph_op_attr_use_affine,
+        /// Specifies an use_dst attribute to an op.
+        use_dst = dnnl_graph_op_attr_use_dst,
+
+        // string attributes. The value of these attributes can be a string.
+
+        /// Specifies an auto_broadcast attribute to an op. The value can be
+        /// "none" or "numpy".
+        auto_broadcast = dnnl_graph_op_attr_auto_broadcast,
+        /// Specifies an auto_pad attribute to an op. The value can be "none",
+        /// "same_upper", "same_lower", or "valid".
+        auto_pad = dnnl_graph_op_attr_auto_pad,
+        /// Specifies an coordinate_transformation_mode attribute to an op. The
+        /// value can be "half_pixel" or "align_corners". The attribute is
+        /// defined for Interpolate operations.
+        coordinate_transformation_mode
+        = dnnl_graph_op_attr_coordinate_transformation_mode,
+        /// Specifies a data_format of an op. The value can be "NCX" or "NXC".
+        data_format = dnnl_graph_op_attr_data_format,
+        /// Specifies a mode attribute of an op. The value can be "nearest",
+        /// "linear", "bilinear", or "trilinear". The attribute is defined for
+        /// Interpolate operations.
+        mode = dnnl_graph_op_attr_mode,
+        /// Specifies a qtype attribute to an op. The value can be "per_channel"
+        /// or "per_tensor". The attribute is defined for quantization
+        /// operations.
+        qtype = dnnl_graph_op_attr_qtype,
+        /// Specifies a rounding_type attribute to an op. The value can be
+        /// "ceil" or "floor".
+        rounding_type = dnnl_graph_op_attr_rounding_type,
+        /// Specifies a weights_format of an op. The value can be "OIX", "XIO",
+        /// "IOX", or "XOI". Different operations may support different values.
+        weights_format = dnnl_graph_op_attr_weights_format,
+    };
+
+    /// Constructs an op object with an unique ID, an operation kind, and a name
+    /// string.
+    ///
+    /// @param id The unique ID of the op.
+    /// @param akind The op kind specifies which computation is represented by
+    ///     the op, such as Convolution or ReLU.
+    /// @param verbose_name The string added as the op name.
+    op(size_t id, kind akind, const std::string &verbose_name = "") {
+        dnnl_graph_op_t op = nullptr;
+        error::wrap_c_api(dnnl_graph_op_create(&op, id, convert_to_c(akind),
+                                  verbose_name.c_str()),
+                "could not create op with id and op kind");
+        reset(op);
+    }
+
+    /// Constructs an op object with an unique ID, an operation kind, and
+    /// input/output logical tensors.
+    ///
+    /// @param id The unique ID of this op.
+    /// @param akind The op kind specifies which computation is represented by
+    ///     this op, such as Convolution or ReLU.
+    /// @param inputs Input logical tensor to be bound to this op.
+    /// @param outputs Output logical tensor to be bound to this op.
+    /// @param verbose_name The string added as the op name.
+    op(size_t id, kind akind, const std::vector<logical_tensor> &inputs,
+            const std::vector<logical_tensor> &outputs,
+            const std::string &verbose_name = "")
+        : op(id, akind, verbose_name) {
+        for (const auto &input : inputs) {
+            error::wrap_c_api(dnnl_graph_op_add_input(get(), &(input.data)),
+                    "adding input to the op failed");
+        }
+        for (const auto &output : outputs) {
+            error::wrap_c_api(dnnl_graph_op_add_output(get(), &(output.data)),
+                    "adding output to the op failed");
+        }
+    }
+
+    /// Adds an input logical tensor to the op.
+    ///
+    /// @param t Input logical tensor.
+    void add_input(const logical_tensor &t) {
+        error::wrap_c_api(dnnl_graph_op_add_input(get(), &(t.data)),
+                "adding input to the op failed");
+    }
+
+    /// Adds a vector of input logical tensors to the op.
+    ///
+    /// @param ts The list of input logical tensors.
+    void add_inputs(const std::vector<logical_tensor> &ts) {
+        for (const auto &t : ts) {
+            error::wrap_c_api(dnnl_graph_op_add_input(get(), &(t.data)),
+                    "adding input to the op failed");
+        }
+    }
+
+    /// Adds an output logical tensor to the op.
+    ///
+    /// @param t Output logical tensor.
+    void add_output(const logical_tensor &t) {
+        error::wrap_c_api(dnnl_graph_op_add_output(get(), &(t.data)),
+                "adding output to the op failed");
+    }
+
+    /// Adds a vector of output logical tensors to the op.
+    ///
+    /// @param ts The list of output logical tensors.
+    void add_outputs(const std::vector<logical_tensor> &ts) {
+        for (const auto &t : ts) {
+            error::wrap_c_api(dnnl_graph_op_add_output(get(), &(t.data)),
+                    "adding output to the op failed");
+        }
+    }
+
+    /// Sets the attribute according to the name and type (int64_t).
+    ///
+    /// @tparam Type Attribute's type.
+    /// @param name Attribute's name.
+    /// @param value The attribute's value.
+    /// @returns The Op self.
+    template <typename Type, req<std::is_same<Type, int64_t>::value> = true>
+    op &set_attr(attr name, const Type &value) {
+        dnnl_graph_op_attr_t attr = convert_to_c(name);
+        error::wrap_c_api(dnnl_graph_op_set_attr_s64(get(), attr, &value, 1),
+                "could not set attribute to the op");
+        return *this;
+    }
+
+    /// Sets the attribute according to the name and type (float).
+    ///
+    /// @tparam Type Attribute's type.
+    /// @param name Attribute's name.
+    /// @param value The attribute's value.
+    /// @returns The Op self.
+    template <typename Type, req<std::is_same<Type, float>::value> = true>
+    op &set_attr(attr name, const Type &value) {
+        dnnl_graph_op_attr_t attr = convert_to_c(name);
+        error::wrap_c_api(dnnl_graph_op_set_attr_f32(get(), attr, &value, 1),
+                "could not set attribute to the op");
+        return *this;
+    }
+
+    /// Sets the attribute according to the name and type (bool).
+    ///
+    /// @tparam Type Attribute's type.
+    /// @param name Attribute's name.
+    /// @param value The attribute's value.
+    /// @returns The Op self.
+    template <typename Type, req<std::is_same<Type, bool>::value> = true>
+    op &set_attr(attr name, const Type &value) {
+        dnnl_graph_op_attr_t attr = convert_to_c(name);
+        const uint8_t val = value;
+        error::wrap_c_api(dnnl_graph_op_set_attr_bool(get(), attr, &val, 1),
+                "could not set attribute to the op");
+        return *this;
+    }
+
+    /// Sets the attribute according to the name and type (string).
+    ///
+    /// @tparam Type Attribute's type.
+    /// @param name Attribute's name.
+    /// @param value The attribute's value.
+    /// @returns The Op self.
+    template <typename Type, req<std::is_same<Type, std::string>::value> = true>
+    op &set_attr(attr name, const Type &value) {
+        dnnl_graph_op_attr_t attr = convert_to_c(name);
+        error::wrap_c_api(dnnl_graph_op_set_attr_str(
+                                  get(), attr, value.c_str(), value.size()),
+                "could not set attribute to the op");
+        return *this;
+    }
+
+    /// Sets the attribute according to the name and type
+    /// (std::vector<int64_t>).
+    ///
+    /// @tparam Type Attribute's type.
+    /// @param name Attribute's name.
+    /// @param value The attribute's value.
+    /// @returns The Op self.
+    template <typename Type,
+            req<std::is_same<Type, std::vector<int64_t>>::value> = true>
+    op &set_attr(attr name, const Type &value) {
+        dnnl_graph_op_attr_t attr = convert_to_c(name);
+        error::wrap_c_api(dnnl_graph_op_set_attr_s64(
+                                  get(), attr, value.data(), value.size()),
+                "could not set attribute to the op");
+        return *this;
+    }
+
+    /// Sets the attribute according to the name and type (std::vector<float>).
+    ///
+    /// @tparam Type Attribute's type.
+    /// @param name Attribute's name.
+    /// @param value The attribute's value.
+    /// @returns The Op self.
+    template <typename Type,
+            req<std::is_same<Type, std::vector<float>>::value> = true>
+    op &set_attr(attr name, const Type &value) {
+        dnnl_graph_op_attr_t attr = convert_to_c(name);
+        error::wrap_c_api(dnnl_graph_op_set_attr_f32(
+                                  get(), attr, value.data(), value.size()),
+                "could not set attribute to the op");
+        return *this;
+    }
+
+private:
+    dnnl_graph_op_kind_t convert_to_c(kind akind) {
+        return static_cast<dnnl_graph_op_kind_t>(akind);
+    }
+
+    dnnl_graph_op_attr_t convert_to_c(attr aattr) {
+        return static_cast<dnnl_graph_op_attr_t>(aattr);
+    }
+};
+
+/// @} dnnl_graph_api_op
+
+/// @addtogroup dnnl_graph_api_partition Partition
+///
+/// Partition represents a collection of operations and their input and output
+/// logical tensors identified by library as the basic unit for compilation and
+/// execution.
+///
+/// @{
+
+/// A partition object.
+class partition : public partition_handle {
+public:
+    /// Policy specifications for partitioning.
+    enum class policy {
+        /// Fusion policy returns partitions with typical post-op fusions, eg.
+        /// Convolution + ReLU or other element-wise operations or a chian of
+        /// post-ops.
+        fusion = dnnl_graph_partition_policy_fusion,
+        /// Debug policy doesn't not apply any fusions. It returns partitions
+        /// with single operations in each partition. The policy is useful when
+        /// users notice any bug or correctness issue in fusion policy.
+        debug = dnnl_graph_partition_policy_debug,
+    };
+
+    partition() = default;
+
+    /// Constructs a partition object
+    ///
+    /// @param p A raw pointer to the C API handle
+    partition(dnnl_graph_partition_t p) { reset(p, false); }
+
+    /// Creates a new partition with a given operator and engine kind. The API
+    /// is used to create a partition from an operation directly without
+    /// creating the graph and calling `get_partitions()`. The output partition
+    /// contains only one operation.
+    ///
+    /// @param aop An operation used to create the partition.
+    /// @param ekind Engine kind.
+    partition(const op &aop, engine::kind ekind) {
+        dnnl_graph_partition_t p = nullptr;
+        error::wrap_c_api(dnnl_graph_partition_create_with_op(&p, aop.get(),
+                                  static_cast<dnnl_engine_kind_t>(ekind)),
+                "could not create a partition with the op and engine kind");
+        reset(p);
+    }
+
+    /// Returns the number of operations contained in the partition.
+    ///
+    /// @returns Number of operations.
+    size_t get_ops_num() const {
+        size_t num {0};
+        error::wrap_c_api(dnnl_graph_partition_get_op_num(get(), &num),
+                "could not get number of ops from the partition");
+        return num;
+    }
+
+    /// Returns all operation IDs contained in the partition.
+    ///
+    /// @returns An unordered set of operation IDs.
+    std::vector<size_t> get_ops() const {
+        auto num = get_ops_num();
+        std::vector<size_t> ops(num);
+
+        error::wrap_c_api(dnnl_graph_partition_get_ops(get(), num, ops.data()),
+                "could not get op ids from the partition");
+        return ops;
+    }
+
+    /// Returns the unique ID of the partition. Partition ID is generated by the
+    /// library internally. The ID can be used for debugging purpose or verbose.
+    ///
+    /// @returns ID of the partition.
+    size_t get_id() const {
+        size_t id {};
+        error::wrap_c_api(dnnl_graph_partition_get_id(get(), &id),
+                "could not get id of the partition");
+        return id;
+    }
+
+    /// Compiles a partition with given input and output logical tensors. The
+    /// output logical tensors can contain unknown dimensions. For this case,
+    /// the compilation will deduce the output shapes according to input shapes.
+    /// The output logical tensors can also have layout type `any`. The
+    /// compilation will choose the optimal layout for output tensors. The
+    /// optimal layout will be represented as an opaque layout ID saved in the
+    /// output logical tensor.
+    ///
+    /// @param inputs A list of input logical tensors.
+    /// @param outputs A list of output logical tensors.
+    /// @param e The engine used to compile the partition.
+    /// @returns A compiled partition.
+    compiled_partition compile(const std::vector<logical_tensor> &inputs,
+            const std::vector<logical_tensor> &outputs, const engine &e) const {
+        if (!is_supported()) {
+            error::wrap_c_api(dnnl_invalid_arguments,
+                    "could not compile an unsupported partition");
+        }
+
+        return compile_(inputs, outputs, e);
+    }
+
+    /// Returns the supporting status of a partition. Some operations may not be
+    /// supported by the library under certain circumstances. During
+    /// partitioning stage, unsupported partitions will be returned to users
+    /// with each containing an unsupported operation. Users should check the
+    /// supporting status of a partition before transforming the computation
+    /// graph or compiling the partition.
+    ///
+    /// @returns @c true if this partition is supported or @c false if this
+    ///     partition isn't supported by the library
+    bool is_supported() const {
+        uint8_t supported {0};
+        error::wrap_c_api(dnnl_graph_partition_is_supported(get(), &supported),
+                "could not get supporting status of the partition");
+        return supported != 0;
+    }
+
+    /// Returns a list of input logical tensors from the partition.
+    ///
+    /// @returns A list of input logical tensors.
+    std::vector<logical_tensor> get_input_ports() const {
+        size_t num = 0;
+        error::wrap_c_api(dnnl_graph_partition_get_input_ports_num(get(), &num),
+                "could not get number of inputs of the partition");
+        if (num == 0) return {};
+
+        std::vector<dnnl_graph_logical_tensor_t> c_inputs(num);
+        error::wrap_c_api(dnnl_graph_partition_get_input_ports(
+                                  get(), num, c_inputs.data()),
+                "could not get input logical tensors of the partition");
+
+        std::vector<logical_tensor> inputs;
+        inputs.reserve(num);
+        for (auto &c_lt : c_inputs)
+            inputs.emplace_back(c_lt);
+        return inputs;
+    }
+
+    /// Returns a list of output logical tensors from the partition.
+    ///
+    /// @returns A list of output logical tensor.
+    std::vector<logical_tensor> get_output_ports() const {
+        size_t num = 0;
+        error::wrap_c_api(
+                dnnl_graph_partition_get_output_ports_num(get(), &num),
+                "cannot get number of outputs of the partition");
+        if (num == 0) return {};
+
+        std::vector<dnnl_graph_logical_tensor_t> c_outputs(num);
+        error::wrap_c_api(dnnl_graph_partition_get_output_ports(
+                                  get(), num, c_outputs.data()),
+                "could not get output logical tensors of the partition");
+
+        std::vector<logical_tensor> outputs;
+        outputs.reserve(num);
+        for (auto &c_lt : c_outputs)
+            outputs.emplace_back(c_lt);
+        return outputs;
+    }
+
+    /// Returns the engine kind of the partition
+    ///
+    /// @returns The engine kind
+    engine::kind get_engine_kind() const {
+        dnnl_engine_kind_t akind;
+        error::wrap_c_api(dnnl_graph_partition_get_engine_kind(get(), &akind),
+                "cannot get the engine kind from the partition");
+
+        return static_cast<engine::kind>(akind);
+    }
+
+private:
+    compiled_partition compile_(const std::vector<logical_tensor> &inputs,
+            const std::vector<logical_tensor> &outputs, const engine &e) const {
+        std::vector<const dnnl_graph_logical_tensor_t *> c_inputs;
+        std::vector<const dnnl_graph_logical_tensor_t *> c_outputs;
+
+        c_inputs.reserve(inputs.size());
+        for (const auto &in : inputs) {
+            c_inputs.push_back(&(in.data));
+        }
+
+        c_outputs.reserve(outputs.size());
+        for (const auto &out : outputs) {
+            c_outputs.push_back(&(out.data));
+        }
+
+        dnnl_graph_compiled_partition_t cpartitions = nullptr;
+        error::wrap_c_api(
+                dnnl_graph_compiled_partition_create(&cpartitions, get()),
+                "could not create compiled_partition");
+        error::wrap_c_api(dnnl_graph_partition_compile(get(), cpartitions,
+                                  c_inputs.size(), c_inputs.data(),
+                                  c_outputs.size(), c_outputs.data(), e.get()),
+                "partition compile failed");
+
+        return compiled_partition(cpartitions);
+    }
+};
+
+/// @} dnnl_graph_api_partition
+
+/// @addtogroup dnnl_graph_api_graph Graph
+///
+/// Graph represents a computational DAG with a set of operations.
+/// #dnnl::graph::graph::add_op() adds an operation and its input and output
+/// logical tensors into a graph. The library accumulates the operations and
+/// logical tensors and constructs and validates the graph as an internal state.
+/// A graph object is associated to a specific engine kind. The partitions
+/// returned from the graph will inherit the engine kind of the graph.
+///
+/// @{
+
+/// A graph object.
+class graph : public graph_handle {
+public:
+    /// Constructs a graph with an engine kind.
+    ///
+    /// @param engine_kind Engine kind.
+    graph(engine::kind engine_kind) {
+        dnnl_graph_graph_t g = nullptr;
+        error::wrap_c_api(
+                dnnl_graph_graph_create(&g, convert_to_c(engine_kind)),
+                "could not create graph with engine kind");
+        reset(g);
+    }
+
+    /// Creates a new empty graph with an engine kind and a floating-point math
+    /// mode. All partitions returned from the graph will inherit the engine
+    /// kind and floating-point math mode.
+    ///
+    /// @param engine_kind Engine kind.
+    /// @param mode Floating-point math mode.
+    graph(engine::kind engine_kind, fpmath_mode mode) {
+        dnnl_graph_graph_t g = nullptr;
+        error::wrap_c_api(
+                dnnl_graph_graph_create_with_fpmath_mode(
+                        &g, convert_to_c(engine_kind), convert_to_c(mode)),
+                "could not create graph with engine kind and math mode");
+        reset(g);
+    }
+
+    /// Adds an op into the graph to construct a computational DAG. The API will
+    /// return failure if the operator has already been added to the graph or
+    /// the operation cannot pass the schema check in the library (eg. input and
+    /// output numbers and data types, the attributes of the operation, etc.).
+    ///
+    /// @param op An operation to be added.
+    /// @param allow_exception A flag indicating whether the method is allowed
+    ///     to throw an exception if it fails to add the op to the graph.
+    /// @returns #status::success or a status describing the error otherwise.
+    status add_op(const op &op, bool allow_exception = true) {
+        dnnl_status_t ret = dnnl_graph_add_op(get(), op.get());
+
+        if (allow_exception) {
+            error::wrap_c_api(ret, "could not add op to the graph");
+        }
+
+        return static_cast<status>(ret);
+    }
+
+    /// Finalizes a graph. It means users have finished adding operations into
+    /// the graph and the graph is ready for partitioning. Adding a new
+    /// operation into a finalized graph will return failures. Similarly,
+    /// partitioning on a un-finalized graph will also return failures.
+    void finalize() {
+        error::wrap_c_api(dnnl_graph_graph_finalize(get()),
+                "could not finalize the graph");
+    }
+
+    /// Checks if a graph is finalized.
+    ///
+    /// @return True if the graph is finalized or false if the graph is not
+    /// finalized.
+    bool is_finalized() const {
+        uint8_t ret = 0;
+        error::wrap_c_api(dnnl_graph_graph_is_finalized(get(), &ret),
+                "could not get the finalization status of the graph");
+
+        return ret != 0;
+    }
+
+    /// Gets filtered partitions from a graph. Partitions will be claimed
+    /// internally according to the capability of the library, the engine kind
+    /// of the graph, and the policy.
+    ///
+    /// @param policy Partition policy, defaults to policy
+    ///     #dnnl::graph::partition::policy::fusion.
+    /// @return A vector storing the partitions.
+    std::vector<partition> get_partitions(
+            partition::policy policy = partition::policy::fusion) {
+        if (!is_finalized()) {
+            error::wrap_c_api(
+                    dnnl_invalid_graph, "the graph is not finalized yet");
+        }
+
+        error::wrap_c_api(
+                dnnl_graph_graph_filter(get(),
+                        static_cast<dnnl_graph_partition_policy_t>(policy)),
+                "could not filter the graph");
+
+        size_t num = 0;
+        error::wrap_c_api(dnnl_graph_graph_get_partition_num(get(), &num),
+                "could not get number of partitions from the graph");
+
+        // return early if there is no partitions in the graph.
+        if (num == 0) return {};
+
+        std::vector<partition> out_list;
+        out_list.reserve(num);
+
+        std::vector<dnnl_graph_partition_t> partitions(num);
+        error::wrap_c_api(
+                dnnl_graph_graph_get_partitions(get(), num, partitions.data()),
+                "could not get partitions from the graph");
+
+        for (auto p : partitions) {
+            out_list.emplace_back(p);
+        }
+
+        return out_list;
+    }
+
+private:
+    static dnnl_fpmath_mode_t convert_to_c(fpmath_mode mode) {
+        return static_cast<dnnl_fpmath_mode_t>(mode);
+    }
+
+    static dnnl_engine_kind_t convert_to_c(engine::kind akind) {
+        return static_cast<dnnl_engine_kind_t>(akind);
+    }
+};
+
+/// @} dnnl_graph_api_graph
+
+/// @addtogroup dnnl_graph_api_compiled_partition_cache Compiled Partition Cache
+///
+/// A set of functions that provide compiled partition cache control.
+///
+/// @{
+
+/// Returns the number of compiled partition that can be held in the compiled
+/// partition cache at the same time.
+inline int get_compiled_partition_cache_capacity() {
+    int result = 0;
+    error::wrap_c_api(dnnl_graph_get_compiled_partition_cache_capacity(&result),
+            "could not get compiled partition cache capacity");
+    return result;
+}
+
+/// @copydoc dnnl_graph_set_compiled_partition_cache_capacity(int capacity)
+inline void set_compiled_partition_cache_capacity(int capacity) {
+    error::wrap_c_api(
+            dnnl_graph_set_compiled_partition_cache_capacity(capacity),
+            "could not set compiled partition cache capacity");
+}
+
+/// @} dnnl_graph_api_compiled_partition_cache
+
+/// @addtogroup dnnl_graph_api_constant_tensor_cache Constant Tensor Cache
+///
+/// A set of functions that provide constant tensor cache control
+///
+/// @{
+
+/// Control the enabling or disabling of constant tensor cache. This API must be
+/// called once before compilation stage. By default, constant tensor cache is
+/// disabled in the library.
+///
+/// @param flag Set to positive value to enable the cache and set to 0 to
+/// disable the cache. Negative values are invalid.
+inline void set_constant_tensor_cache(int flag) {
+    error::wrap_c_api(dnnl_graph_set_constant_tensor_cache(flag),
+            "fail to set constant tensor cache");
+}
+
+/// Return the enabling status of constant tensor cache.
+inline int get_constant_tensor_cache() {
+    int result = 0;
+    error::wrap_c_api(dnnl_graph_get_constant_tensor_cache(&result),
+            "fail to get constant tensor cache");
+    return result;
+}
+
+/// @} dnnl_graph_constant_tensor_cache
+
+} // namespace graph
+} // namespace dnnl
+
+/// @cond DO_NOT_DOCUMENT_THIS
+
+/// oneAPI namespace
+// Contains the oneapi::dnnl namespace as an alias to the ::dnnl namespace.
+namespace oneapi {
+// Note: without this guard, doxygen warns of potentially recursive namespace
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+/// oneDNN alias namespace
+namespace dnnl = ::dnnl;
+#endif
+} // namespace oneapi
+
+/// @endcond
+
+/// @} dnnl_graph_api
+
+/// @} dnnl_api
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/include/oneapi/dnnl/dnnl_ocl.h

@@ -0,0 +1,249 @@
+/*******************************************************************************
+* Copyright 2020-2022 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.
+*******************************************************************************/
+
+#ifndef ONEAPI_DNNL_DNNL_OCL_H
+#define ONEAPI_DNNL_DNNL_OCL_H
+
+#include "oneapi/dnnl/dnnl.h"
+
+#include "oneapi/dnnl/dnnl_ocl_types.h"
+
+/// @cond DO_NOT_DOCUMENT_THIS
+// Set target version for OpenCL explicitly to suppress a compiler warning.
+#ifndef CL_TARGET_OPENCL_VERSION
+#define CL_TARGET_OPENCL_VERSION 120
+#endif
+
+#include <CL/cl.h>
+/// @endcond
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// @addtogroup dnnl_api
+/// @{
+
+/// @addtogroup dnnl_api_interop
+/// @{
+
+/// @addtogroup dnnl_api_ocl_interop
+/// @{
+
+/// Creates a memory object.
+///
+/// Unless @p handle is equal to DNNL_MEMORY_NONE or DNNL_MEMORY_ALLOCATE, the
+/// constructed memory object will have the underlying buffer set. In this
+/// case, the buffer will be initialized as if:
+/// - dnnl_memory_set_data_handle() has been called, if @p memory_kind is equal
+///   to dnnl_ocl_interop_usm, or
+/// - dnnl_ocl_interop_memory_set_mem_object() has been called, if @p memory_kind
+///   is equal to dnnl_ocl_interop_buffer.
+///
+/// @param memory Output memory object.
+/// @param memory_desc Memory descriptor.
+/// @param engine Engine to use.
+/// @param memory_kind Memory allocation kind to specify the type of handle.
+/// @param handle Handle of the memory buffer to use as an underlying storage.
+///     - A USM pointer to the user-allocated buffer. In this case the library
+///       doesn't own the buffer. Requires @p memory_kind to be equal to
+///       dnnl_ocl_interop_usm.
+///     - An OpenCL buffer. In this case the library doesn't own the buffer.
+///       Requires @p memory_kind be equal to be equal to dnnl_ocl_interop_buffer.
+///     - The DNNL_MEMORY_ALLOCATE special value. Instructs the library to
+///       allocate the buffer that corresponds to the memory allocation kind
+///       @p memory_kind for the memory object. In this case the library
+///       owns the buffer.
+///     - The DNNL_MEMORY_NONE specific value. Instructs the library to
+///       create memory object without an underlying buffer.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_ocl_interop_memory_create(dnnl_memory_t *memory,
+        const_dnnl_memory_desc_t memory_desc, dnnl_engine_t engine,
+        dnnl_ocl_interop_memory_kind_t memory_kind, void *handle);
+
+/// Returns the memory allocation kind associated with a memory object.
+///
+/// @param memory Memory to query.
+/// @param memory_kind Output underlying memory allocation kind of the memory
+///     object.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_ocl_interop_memory_get_memory_kind(
+        const_dnnl_memory_t memory,
+        dnnl_ocl_interop_memory_kind_t *memory_kind);
+
+/// Returns an OpenCL memory object associated with a memory object.
+///
+/// @param memory Memory object.
+/// @param mem_object Output OpenCL memory object.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_ocl_interop_memory_get_mem_object(
+        const_dnnl_memory_t memory, cl_mem *mem_object);
+
+/// Sets OpenCL memory object associated with a memory object.
+///
+/// For behavioral details, see dnnl_memory_set_data_handle().
+///
+/// @param memory Memory object.
+/// @param mem_object OpenCL memory object.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_ocl_interop_memory_set_mem_object(
+        dnnl_memory_t memory, cl_mem mem_object);
+
+/// Retrieves a cache blob ID for the OpenCL device.
+///
+/// @warning
+///     This API is intended to be used with
+///     #dnnl_ocl_interop_engine_get_cache_blob() and
+///     #dnnl_ocl_interop_engine_create_from_cache_blob(). The returned cache
+///     blob ID can only be used as an ID of the cache blob returned by
+///     #dnnl_ocl_interop_engine_get_cache_blob().
+///
+/// @note The cache blob ID can be empty (@p size will be 0 and
+///     @p cache_blob_id will be nullptr) if oneDNN doesn't have anything to
+///     put in the cache blob. (#dnnl_ocl_interop_engine_get_cache_blob will
+///     return an empty cache blob).
+///
+/// @param device An OpenCL device.
+/// @param size Size of the cache blob ID in bytes.
+/// @param cache_blob_id Cache blob id of size @p size. If
+///     the @p cache_blob_id is nullptr then the size of the cache blob ID is
+///     returned in @p size.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_ocl_interop_engine_get_cache_blob_id(
+        cl_device_id device, size_t *size, uint8_t *cache_blob_id);
+
+/// Retrieves a cache blob associated with the given engine.
+///
+/// @note The cache blob can be empty (@p size will be 0 and @p cache_blob
+///     will be nullptr) if oneDNN doesn't have anything to put in the cache
+///     blob. It's the user's responsibility to check whether it's empty
+///     prior to passing it to
+///     #dnnl_ocl_interop_engine_create_from_cache_blob().
+///
+/// @param engine Engine to query for the cache blob.
+/// @param size Size of the cache blob in bytes.
+/// @param cache_blob Cache blob of size @p size. If the @p cache_blob is
+///     nullptr then the size of the cache blob is returned in @p size.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_ocl_interop_engine_get_cache_blob(
+        dnnl_engine_t engine, size_t *size, uint8_t *cache_blob);
+
+/// Creates an engine from the given cache blob.
+///
+/// @param engine Output engine.
+/// @param device The OpenCL device that this engine will encapsulate.
+/// @param context The OpenCL context (containing the device) that this
+///     engine will use for all operations.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+/// @param size Size of the cache blob in bytes.
+/// @param cache_blob Cache blob of size @p size.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_ocl_interop_engine_create_from_cache_blob(
+        dnnl_engine_t *engine, cl_device_id device, cl_context context,
+        size_t size, const uint8_t *cache_blob);
+
+/// Creates an engine associated with an OpenCL device and an OpenCL context.
+///
+/// @param engine Output engine.
+/// @param device Underlying OpenCL device to use for the engine.
+/// @param context Underlying OpenCL context to use for the engine.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_ocl_interop_engine_create(
+        dnnl_engine_t *engine, cl_device_id device, cl_context context);
+
+/// Returns the OpenCL context associated with an engine.
+///
+/// @param engine Engine to query.
+/// @param context Output underlying OpenCL context of the engine.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_ocl_interop_engine_get_context(
+        dnnl_engine_t engine, cl_context *context);
+
+/// Returns the OpenCL device associated with an engine.
+///
+/// @param engine Engine to query.
+/// @param device Output underlying OpenCL device of the engine.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_ocl_interop_get_device(
+        dnnl_engine_t engine, cl_device_id *device);
+
+/// Creates an execution stream for a given engine associated with
+/// an OpenCL command queue.
+///
+/// @param stream Output execution stream.
+/// @param engine Engine to create the execution stream on.
+/// @param queue OpenCL command queue to use.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_ocl_interop_stream_create(
+        dnnl_stream_t *stream, dnnl_engine_t engine, cl_command_queue queue);
+
+/// Returns the OpenCL command queue associated with an execution stream.
+///
+/// @param stream Execution stream to query.
+/// @param queue Output OpenCL command queue.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_ocl_interop_stream_get_command_queue(
+        dnnl_stream_t stream, cl_command_queue *queue);
+
+/// Executes computations specified by the primitive in a specified stream and
+/// returns an OpenCL event.
+///
+/// @param primitive Primitive to execute.
+/// @param stream Stream to use.
+/// @param nargs Number of arguments.
+/// @param args Array of arguments. Each argument is an
+///     <index, #dnnl_memory_t> pair. The index is one of the `DNNL_ARG_*`
+///     values such as `DNNL_ARG_SRC`. Unless runtime shapes are used (see
+///     #DNNL_RUNTIME_DIM_VAL), the memory object must have the same memory
+///     descriptor as that returned by
+///     #dnnl_primitive_desc_query_md(#dnnl_query_exec_arg_md, index).
+/// @param deps A pointer to a vector of size @p ndeps that contains
+///     dependencies.
+/// @param ndeps Number of dependencies.
+/// @param return_event Output event. It's the user's responsibility to
+///     manage lifetime of the event. Can be NULL. When @p stream is in-order
+///     NULL will be returned.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_ocl_interop_primitive_execute(
+        const_dnnl_primitive_t primitive, dnnl_stream_t stream, int nargs,
+        const dnnl_exec_arg_t *args, const cl_event *deps, int ndeps,
+        cl_event *return_event);
+
+/// @} dnnl_api_ocl_interop
+
+/// @} dnnl_api_interop
+
+/// @} dnnl_api
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/include/oneapi/dnnl/dnnl_ocl_types.h

@@ -0,0 +1,51 @@
+/*******************************************************************************
+* Copyright 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.
+*******************************************************************************/
+
+#ifndef ONEAPI_DNNL_DNNL_OCL_TYPES_H
+#define ONEAPI_DNNL_DNNL_OCL_TYPES_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// @addtogroup dnnl_api
+/// @{
+
+/// @addtogroup dnnl_api_interop
+/// @{
+
+/// @addtogroup dnnl_api_ocl_interop
+/// @{
+
+/// Memory allocation kind.
+typedef enum {
+    /// USM (device, shared, host, or unknown) memory allocation kind.
+    dnnl_ocl_interop_usm,
+    /// Buffer memory allocation kind - default.
+    dnnl_ocl_interop_buffer,
+} dnnl_ocl_interop_memory_kind_t;
+
+/// @} dnnl_api_ocl_interop
+
+/// @} dnnl_api_interop
+
+/// @} dnnl_api
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/include/oneapi/dnnl/dnnl_sycl.h

@@ -0,0 +1,169 @@
+/*******************************************************************************
+* Copyright 2020-2022 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.
+*******************************************************************************/
+
+#ifndef ONEAPI_DNNL_DNNL_SYCL_H
+#define ONEAPI_DNNL_DNNL_SYCL_H
+
+#include "oneapi/dnnl/dnnl.h"
+
+#include "oneapi/dnnl/dnnl_sycl_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// @addtogroup dnnl_api
+/// @{
+
+/// @addtogroup dnnl_api_interop
+/// @{
+
+/// @addtogroup dnnl_api_sycl_interop
+/// @{
+
+/// Creates an engine associated with a SYCL device and a SYCL context.
+///
+/// @param engine Output engine.
+/// @param device Pointer to the SYCL device to use for the engine.
+/// @param context Pointer to the SYCL context to use for the engine.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_sycl_interop_engine_create(
+        dnnl_engine_t *engine, const void *device, const void *context);
+
+/// Returns the SYCL context associated with an engine.
+///
+/// @param engine Engine to query.
+/// @param context Pointer to the underlying SYCL context of the engine.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_sycl_interop_engine_get_context(
+        dnnl_engine_t engine, void **context);
+
+/// Returns the SYCL device associated with an engine.
+///
+/// @param engine Engine to query.
+/// @param device Pointer to the underlying SYCL device of the engine.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_sycl_interop_engine_get_device(
+        dnnl_engine_t engine, void **device);
+
+/// Creates a memory object.
+///
+/// Unless @p handle is equal to DNNL_MEMORY_NONE or DNNL_MEMORY_ALLOCATE, the
+/// constructed memory object will have the underlying buffer set. In this
+/// case, the buffer will be initialized as if:
+/// - dnnl_memory_set_data_handle() had been called, if @p memory_kind is equal
+///   to dnnl_sycl_interop_usm, or
+/// - dnnl_sycl_interop_memory_set_buffer() has been called, if @p memory_kind
+///   is equal to dnnl_sycl_interop_buffer.
+///
+/// @param memory Output memory object.
+/// @param memory_desc Memory descriptor.
+/// @param engine Engine to use.
+/// @param memory_kind Memory allocation kind to specify the type of handle.
+/// @param handle Handle of the memory buffer to use as an underlying storage.
+///     - A USM pointer to the user-allocated buffer. In this case the library
+///       doesn't own the buffer. Requires @p memory_kind to be equal to
+///       dnnl_sycl_interop_usm.
+///     - A pointer to SYCL buffer. In this case the library doesn't own the
+///       buffer. Requires @p memory_kind be equal to be equal to
+///       dnnl_sycl_interop_buffer.
+///     - The DNNL_MEMORY_ALLOCATE special value. Instructs the library to
+///       allocate the buffer that corresponds to the memory allocation kind
+///       @p memory_kind for the memory object. In this case the library
+///       owns the buffer.
+///     - The DNNL_MEMORY_NONE specific value. Instructs the library to
+///       create memory object without an underlying buffer.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_sycl_interop_memory_create(dnnl_memory_t *memory,
+        const_dnnl_memory_desc_t memory_desc, dnnl_engine_t engine,
+        dnnl_sycl_interop_memory_kind_t memory_kind, void *handle);
+
+/// Returns the memory allocation kind associated with a memory object.
+///
+/// @param memory Memory to query.
+/// @param memory_kind Output underlying memory allocation kind of the memory
+///     object.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_sycl_interop_memory_get_memory_kind(
+        const_dnnl_memory_t memory,
+        dnnl_sycl_interop_memory_kind_t *memory_kind);
+
+/// Sets a SYCL buffer for a memory object.
+///
+/// @param memory Memory object.
+/// @param buffer SYCL buffer to be set in the memory object.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_sycl_interop_memory_set_buffer(
+        dnnl_memory_t memory, void *buffer);
+
+/// Creates an execution stream for a given engine associated with a SYCL
+/// queue.
+///
+/// @param stream Output execution stream.
+/// @param engine Engine to create the execution stream on.
+/// @param queue SYCL queue to use.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_sycl_interop_stream_create(
+        dnnl_stream_t *stream, dnnl_engine_t engine, void *queue);
+
+/// Returns the SYCL queue associated with an execution stream.
+///
+/// @param stream Execution stream to query.
+/// @param queue Output SYCL command queue.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_sycl_interop_stream_get_queue(
+        dnnl_stream_t stream, void **queue);
+
+/// Executes computations specified by the primitive in a specified stream and
+/// returns a SYCL event.
+///
+/// @param primitive Primitive to execute.
+/// @param stream Stream to use.
+/// @param nargs Number of arguments.
+/// @param args Array of arguments. Each argument is an
+///     <index, #dnnl_memory_t> pair. The index is one of the `DNNL_ARG_*`
+///     values such as `DNNL_ARG_SRC`. Unless runtime shapes are used (see
+///     #DNNL_RUNTIME_DIM_VAL), the memory object must have the same memory
+///     descriptor as that returned by
+///     #dnnl_primitive_desc_query_md(#dnnl_query_exec_arg_md, index).
+/// @param deps A pointer to std::vector<sycl::event> that contains
+///     dependencies.
+/// @param return_event Output event.
+/// @returns #dnnl_success on success and a status describing the error
+///     otherwise.
+dnnl_status_t DNNL_API dnnl_sycl_interop_primitive_execute(
+        const_dnnl_primitive_t primitive, dnnl_stream_t stream, int nargs,
+        const dnnl_exec_arg_t *args, const void *deps, void *return_event);
+
+/// @} dnnl_api_sycl_interop
+
+/// @} dnnl_api_interop
+
+/// @} dnnl_api
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/include/oneapi/dnnl/dnnl_sycl_types.h

@@ -0,0 +1,51 @@
+/*******************************************************************************
+* 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.
+*******************************************************************************/
+
+#ifndef ONEAPI_DNNL_DNNL_SYCL_TYPES_H
+#define ONEAPI_DNNL_DNNL_SYCL_TYPES_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// @addtogroup dnnl_api
+/// @{
+
+/// @addtogroup dnnl_api_interop
+/// @{
+
+/// @addtogroup dnnl_api_sycl_interop
+/// @{
+
+/// Memory allocation kind.
+typedef enum {
+    /// USM (device, shared, host, or unknown) memory allocation kind - default.
+    dnnl_sycl_interop_usm,
+    /// Buffer memory allocation kind.
+    dnnl_sycl_interop_buffer,
+} dnnl_sycl_interop_memory_kind_t;
+
+/// @} dnnl_api_sycl_interop
+
+/// @} dnnl_api_interop
+
+/// @} dnnl_api
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/include/oneapi/dnnl/dnnl_version.h.in

@@ -0,0 +1,36 @@
+/*******************************************************************************
+* Copyright 2019-2020 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.
+*******************************************************************************/
+
+#ifndef ONEAPI_DNNL_DNNL_VERSION_H
+#define ONEAPI_DNNL_DNNL_VERSION_H
+
+// clang-format off
+
+/// Major version
+#define DNNL_VERSION_MAJOR @DNNL_VERSION_MAJOR@
+
+/// Minor version
+#define DNNL_VERSION_MINOR @DNNL_VERSION_MINOR@
+
+/// Patch version
+#define DNNL_VERSION_PATCH @DNNL_VERSION_PATCH@
+
+/// Git commit hash
+#define DNNL_VERSION_HASH  "@DNNL_VERSION_HASH@"
+
+// clang-format on
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/common/batch_normalization_pd.hpp

@@ -0,0 +1,366 @@
+/*******************************************************************************
+* Copyright 2016-2023 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.
+*******************************************************************************/
+
+#ifndef COMMON_BATCH_NORMALIZATION_PD_HPP
+#define COMMON_BATCH_NORMALIZATION_PD_HPP
+
+#include "oneapi/dnnl/dnnl.h"
+
+#include "c_types_map.hpp"
+#include "primitive_desc.hpp"
+#include "utils.hpp"
+
+namespace dnnl {
+namespace impl {
+
+struct batch_normalization_fwd_pd_t;
+
+struct batch_normalization_pd_t : public primitive_desc_t {
+    static constexpr auto base_pkind = primitive_kind::batch_normalization;
+
+    const batch_normalization_desc_t *desc() const { return &desc_; }
+    const op_desc_t *op_desc() const override {
+        return reinterpret_cast<const op_desc_t *>(this->desc());
+    }
+
+    status_t query(query_t what, int idx, void *result) const override {
+        switch (what) {
+            case query::prop_kind:
+                *(prop_kind_t *)result = desc()->prop_kind;
+                break;
+            case query::epsilon_f32:
+                *(float *)result = desc()->batch_norm_epsilon;
+                break;
+            case query::flags: *(uint32_t *)result = desc()->flags; break;
+            default: return primitive_desc_t::query(what, idx, result);
+        }
+        return status::success;
+    }
+
+    /* common batch_normalization aux functions */
+
+    dim_t MB() const { return src_md()->dims[0]; }
+    dim_t C() const { return src_md()->dims[1]; }
+    dim_t D() const { return ndims() >= 5 ? src_md()->dims[ndims() - 3] : 1; }
+    dim_t H() const { return ndims() >= 4 ? src_md()->dims[ndims() - 2] : 1; }
+    dim_t W() const { return ndims() >= 3 ? src_md()->dims[ndims() - 1] : 1; }
+
+    int ndims() const { return src_md()->ndims; }
+
+    bool stats_is_src() const {
+        return desc_.flags & normalization_flags::use_global_stats;
+    }
+    bool use_scale() const {
+        return desc_.flags & normalization_flags::use_scale;
+    }
+    bool use_shift() const {
+        return desc_.flags & normalization_flags::use_shift;
+    }
+    bool use_global_stats() const {
+        return desc_.flags & normalization_flags::use_global_stats;
+    }
+    bool fuse_norm_relu() const {
+        return desc_.flags & normalization_flags::fuse_norm_relu;
+    }
+    bool fuse_norm_add_relu() const {
+        return desc_.flags & normalization_flags::fuse_norm_add_relu;
+    }
+    bool with_relu_post_op(bool require_nslope_zero = true) const {
+        const auto &p = this->attr()->post_ops_;
+        const bool nslope_zero_ok
+                = IMPLICATION(is_training(), require_nslope_zero);
+        return p.len() == 1 && p.entry_[0].is_relu(true, require_nslope_zero)
+                && nslope_zero_ok;
+    }
+
+    float alpha() const {
+        const auto &p = attr()->post_ops_;
+        const bool entry_size_ok = p.entry_.size() > 0;
+        assert(entry_size_ok || fuse_norm_relu() || fuse_norm_add_relu());
+        if (entry_size_ok) return p.entry_[0].eltwise.alpha;
+        return 0.f;
+    }
+
+    bool is_fwd() const {
+        return utils::one_of(desc_.prop_kind, prop_kind::forward_training,
+                prop_kind::forward_inference);
+    }
+
+    bool is_training() const {
+        return desc_.prop_kind == prop_kind::forward_training;
+    }
+
+    bool has_zero_dim_memory() const {
+        return memory_desc_wrapper(src_md()).has_zero_dim();
+    }
+
+protected:
+    batch_normalization_desc_t desc_;
+    const batch_normalization_fwd_pd_t *hint_fwd_pd_;
+
+    memory_desc_t src_md_;
+    memory_desc_t stat_md_;
+    memory_desc_t scaleshift_md_;
+
+    memory_desc_t ws_md_;
+
+    batch_normalization_pd_t(const batch_normalization_desc_t *adesc,
+            const primitive_attr_t *attr,
+            const batch_normalization_fwd_pd_t *hint_fwd_pd)
+        : primitive_desc_t(attr, base_pkind)
+        , desc_(*adesc)
+        , hint_fwd_pd_(hint_fwd_pd)
+        , src_md_(desc_.src_desc)
+        , stat_md_(desc_.stat_desc)
+        , scaleshift_md_(desc_.scaleshift_desc)
+        , ws_md_() {}
+
+    virtual status_t init_default_ws(size_t bits_per_element) {
+        const auto src_mdw = memory_desc_wrapper(src_md_);
+
+        const dim_t nelems = src_mdw.nelems(true);
+        const dim_t bits_per_byte = 8;
+        const dims_t ws_sz = {
+                (dim_t)utils::div_up(nelems * bits_per_element, bits_per_byte)};
+        return memory_desc_init_by_tag(
+                ws_md_, 1, ws_sz, data_type::u8, format_tag::x);
+    }
+};
+
+struct batch_normalization_fwd_pd_t : public batch_normalization_pd_t {
+    typedef batch_normalization_fwd_pd_t base_class;
+    typedef batch_normalization_fwd_pd_t hint_class;
+
+    arg_usage_t arg_usage(int arg) const override {
+        if (arg == DNNL_ARG_SRC) return arg_usage_t::input;
+        if (arg == DNNL_ARG_SRC_1 && fuse_norm_add_relu())
+            return arg_usage_t::input;
+        if (arg == DNNL_ARG_DST) return arg_usage_t::output;
+
+        if (utils::one_of(arg, DNNL_ARG_MEAN, DNNL_ARG_VARIANCE)) {
+            if (stats_is_src()) return arg_usage_t::input;
+            if (!stats_is_src() && is_training()) return arg_usage_t::output;
+            return arg_usage_t::unused;
+        }
+
+        if (arg == DNNL_ARG_SCALE && use_scale()) return arg_usage_t::input;
+        if (arg == DNNL_ARG_SHIFT && use_shift()) return arg_usage_t::input;
+
+        if (arg == DNNL_ARG_WORKSPACE && !types::is_zero_md(workspace_md()))
+            return arg_usage_t::output;
+
+        return primitive_desc_t::arg_usage(arg);
+    }
+
+    const memory_desc_t *arg_md(
+            int arg, bool user_input = false) const override {
+        switch (arg) {
+            case DNNL_ARG_SRC_1: return dst_md(3);
+            case DNNL_ARG_SRC: return src_md(0);
+            case DNNL_ARG_DST: return dst_md(0, user_input);
+            case DNNL_ARG_MEAN: return stats_is_src() ? src_md(1) : dst_md(1);
+            case DNNL_ARG_VARIANCE:
+                return stats_is_src() ? src_md(2) : dst_md(2);
+            case DNNL_ARG_SCALE:
+            case DNNL_ARG_SHIFT: return weights_md(0);
+            default: return batch_normalization_pd_t::arg_md(arg);
+        }
+    }
+
+    const memory_desc_t *src_md(
+            int index = 0, bool user_input = false) const override {
+        if (index == 0) return user_input ? &desc()->src_desc : &src_md_;
+        if (stats_is_src() && (index == 1 || index == 2)) return &stat_md_;
+        return &glob_zero_md;
+    }
+
+    const memory_desc_t *dst_md(
+            int index = 0, bool user_input = false) const override {
+        if (index == 0) return user_input ? &desc()->dst_desc : &dst_md_;
+        if (!stats_is_src() && is_training() && (index == 1 || index == 2))
+            return &stat_md_;
+        if (fuse_norm_add_relu() && index == 3) return &dst_md_;
+        return &glob_zero_md;
+    }
+
+    const memory_desc_t *weights_md(
+            int index = 0, bool user_input = false) const override {
+        return index == 0 ? &scaleshift_md_ : &glob_zero_md;
+    }
+
+    const memory_desc_t *workspace_md(int index = 0) const override {
+        return index == 0 ? &ws_md_ : &glob_zero_md;
+    }
+
+    const memory_desc_t *stat_md() const {
+        return stats_is_src() ? src_md(1) : dst_md(1);
+    }
+
+    int n_inputs() const override {
+        return 1 + 2 * stats_is_src() + use_scale() + use_shift()
+                + fuse_norm_add_relu();
+    }
+    int n_outputs() const override {
+        return 1 + !types::is_zero_md(workspace_md())
+                + (2 * (!stats_is_src())) * is_training();
+    }
+
+protected:
+    memory_desc_t dst_md_;
+
+    batch_normalization_fwd_pd_t(const batch_normalization_desc_t *adesc,
+            const primitive_attr_t *attr,
+            const batch_normalization_fwd_pd_t *hint_fwd_pd)
+        : batch_normalization_pd_t(adesc, attr, hint_fwd_pd)
+        , dst_md_(desc_.dst_desc) {}
+
+    bool set_default_formats_common() {
+        return IMPLICATION(dst_md_.format_kind == format_kind::any,
+                memory_desc_init_by_md_and_dt(
+                        dst_md_, src_md_, dst_md_.data_type)
+                        == status::success);
+    }
+    bool check_scale_shift_data_type() const {
+        return IMPLICATION(use_scale() || use_shift(),
+                weights_md()->data_type == data_type::f32);
+    }
+};
+
+struct batch_normalization_bwd_pd_t : public batch_normalization_pd_t {
+    typedef batch_normalization_bwd_pd_t base_class;
+    typedef batch_normalization_fwd_pd_t hint_class;
+
+    arg_usage_t arg_usage(int arg) const override {
+        if (utils::one_of(arg, DNNL_ARG_SRC, DNNL_ARG_MEAN, DNNL_ARG_VARIANCE,
+                    DNNL_ARG_DIFF_DST))
+            return arg_usage_t::input;
+
+        if (arg == DNNL_ARG_SCALE && use_scale()) return arg_usage_t::input;
+        if (arg == DNNL_ARG_SHIFT && use_shift()) return arg_usage_t::input;
+
+        if (arg == DNNL_ARG_WORKSPACE && !types::is_zero_md(workspace_md()))
+            return arg_usage_t::input;
+
+        if (arg == DNNL_ARG_DIFF_SRC) return arg_usage_t::output;
+        if (arg == DNNL_ARG_DIFF_SRC_1 && fuse_norm_add_relu())
+            return arg_usage_t::output;
+
+        if (arg == DNNL_ARG_DIFF_SCALE && use_scale())
+            return arg_usage_t::output;
+        if (arg == DNNL_ARG_DIFF_SHIFT && use_shift())
+            return arg_usage_t::output;
+        return primitive_desc_t::arg_usage(arg);
+    }
+
+    const memory_desc_t *arg_md(
+            int arg, bool user_input = false) const override {
+        switch (arg) {
+            case DNNL_ARG_SRC: return src_md(0);
+            case DNNL_ARG_MEAN: return src_md(1);
+            case DNNL_ARG_VARIANCE: return src_md(2);
+            case DNNL_ARG_SCALE:
+            case DNNL_ARG_SHIFT: return weights_md(0);
+            case DNNL_ARG_DIFF_SRC_1: return diff_dst_md(1);
+            case DNNL_ARG_DIFF_SRC: return diff_src_md(0);
+            case DNNL_ARG_DIFF_DST: return diff_dst_md(0, user_input);
+            case DNNL_ARG_DIFF_SCALE:
+            case DNNL_ARG_DIFF_SHIFT: return diff_weights_md(0);
+            default: return batch_normalization_pd_t::arg_md(arg);
+        }
+    }
+
+    const memory_desc_t *src_md(
+            int index = 0, bool user_input = false) const override {
+        if (index == 0) return user_input ? &desc()->src_desc : &src_md_;
+        if (index == 1 || index == 2) return &stat_md_;
+        return &glob_zero_md;
+    }
+    const memory_desc_t *diff_dst_md(
+            int index = 0, bool user_input = false) const override {
+        if (index == 0)
+            return user_input ? &desc()->diff_dst_desc : &diff_dst_md_;
+        if (fuse_norm_add_relu() && index == 1)
+            return user_input ? &desc()->diff_dst_desc : &diff_dst_md_;
+        return &glob_zero_md;
+    }
+    const memory_desc_t *diff_src_md(
+            int index = 0, bool user_input = false) const override {
+        if (index == 0)
+            return user_input ? &desc()->diff_src_desc : &diff_src_md_;
+        return &glob_zero_md;
+    }
+
+    const memory_desc_t *weights_md(
+            int index = 0, bool user_input = false) const override {
+        return index == 0 ? &scaleshift_md_ : &glob_zero_md;
+    }
+    const memory_desc_t *diff_weights_md(
+            int index = 0, bool user_input = false) const override {
+        return index == 0 ? &diff_scaleshift_md_ : &glob_zero_md;
+    }
+
+    const memory_desc_t *workspace_md(int index = 0) const override {
+        return index == 0 ? &ws_md_ : &glob_zero_md;
+    }
+
+    const memory_desc_t *stat_md() const { return src_md(1); }
+
+    int n_inputs() const override {
+        return 4 + (!types::is_zero_md(workspace_md())) + use_scale();
+    }
+    int n_outputs() const override {
+        return 1 + fuse_norm_add_relu()
+                + (!types::is_zero_md(diff_weights_md()))
+                * (use_scale() + use_shift());
+    }
+
+protected:
+    memory_desc_t diff_src_md_;
+    memory_desc_t diff_dst_md_;
+    memory_desc_t diff_scaleshift_md_;
+
+    batch_normalization_bwd_pd_t(const batch_normalization_desc_t *adesc,
+            const primitive_attr_t *attr,
+            const batch_normalization_fwd_pd_t *hint_fwd_pd)
+        : batch_normalization_pd_t(adesc, attr, hint_fwd_pd)
+        , diff_src_md_(desc_.diff_src_desc)
+        , diff_dst_md_(desc_.diff_dst_desc)
+        , diff_scaleshift_md_(desc_.diff_scaleshift_desc) {}
+
+    bool set_default_formats_common() {
+        return IMPLICATION(diff_dst_md_.format_kind == format_kind::any,
+                       memory_desc_init_by_md_and_dt(
+                               diff_dst_md_, src_md_, diff_dst_md_.data_type)
+                               == status::success)
+                && IMPLICATION(diff_src_md_.format_kind == format_kind::any,
+                        memory_desc_init_by_md_and_dt(
+                                diff_src_md_, src_md_, diff_src_md_.data_type)
+                                == status::success);
+    }
+
+    bool check_scale_shift_data_type() const {
+        return IMPLICATION(use_scale() || use_shift(),
+                utils::everyone_is(data_type::f32, weights_md()->data_type,
+                        diff_weights_md()->data_type));
+    }
+};
+
+} // namespace impl
+} // namespace dnnl
+
+#endif
+
+// vim: et ts=4 sw=4 cindent cino+=l0,\:4,N-s

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/common/bfloat16.hpp

@@ -0,0 +1,96 @@
+/*******************************************************************************
+* Copyright 2019-2023 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.
+*******************************************************************************/
+
+#ifndef COMMON_BFLOAT16_HPP
+#define COMMON_BFLOAT16_HPP
+
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <limits>
+#include <type_traits>
+
+#include "common/bit_cast.hpp"
+
+#include "oneapi/dnnl/dnnl.h"
+
+namespace dnnl {
+namespace impl {
+
+#if DNNL_CPU_RUNTIME != DNNL_RUNTIME_NONE
+struct bfloat16_t;
+bool try_cvt_float_to_bfloat16(bfloat16_t *out, const float *inp);
+#endif
+
+struct bfloat16_t {
+    uint16_t raw_bits_;
+    bfloat16_t() = default;
+    constexpr bfloat16_t(uint16_t r, bool) : raw_bits_(r) {}
+    bfloat16_t(float f) { (*this) = f; }
+
+    template <typename IntegerType,
+            typename SFINAE = typename std::enable_if<
+                    std::is_integral<IntegerType>::value>::type>
+    bfloat16_t(const IntegerType i)
+        : raw_bits_ {convert_bits_of_normal_or_zero(
+                utils::bit_cast<uint32_t>(static_cast<float>(i)))} {}
+
+    bfloat16_t DNNL_API &operator=(float f);
+
+    template <typename IntegerType,
+            typename SFINAE = typename std::enable_if<
+                    std::is_integral<IntegerType>::value>::type>
+    bfloat16_t &operator=(const IntegerType i) {
+        // Call the converting constructor that is optimized for integer types,
+        // followed by the fast defaulted move-assignment operator.
+        return (*this) = bfloat16_t {i};
+    }
+
+    DNNL_API operator float() const;
+
+    bfloat16_t &operator+=(const float a) {
+        (*this) = float {*this} + a;
+        return *this;
+    }
+
+private:
+    // Converts the 32 bits of a normal float or zero to the bits of a bfloat16.
+    static constexpr uint16_t convert_bits_of_normal_or_zero(
+            const uint32_t bits) {
+        return static_cast<uint16_t>(
+                uint32_t {bits
+                        + uint32_t {0x7FFFU + (uint32_t {bits >> 16} & 1U)}}
+                >> 16);
+    }
+};
+
+static_assert(sizeof(bfloat16_t) == 2, "bfloat16_t must be 2 bytes");
+
+void cvt_float_to_bfloat16(bfloat16_t *out, const float *inp, size_t nelems);
+void cvt_bfloat16_to_float(float *out, const bfloat16_t *inp, size_t nelems);
+
+// performs element-by-element sum of inp and add float arrays and stores
+// result to bfloat16 out array with downconversion
+// out[:] = (bfloat16_t)(inp0[:] + inp1[:])
+void add_floats_and_cvt_to_bfloat16(
+        bfloat16_t *out, const float *inp0, const float *inp1, size_t nelems);
+
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/common/binary_pd.hpp

@@ -0,0 +1,174 @@
+/*******************************************************************************
+* Copyright 2019-2023 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.
+*******************************************************************************/
+
+#ifndef COMMON_BINARY_PD_HPP
+#define COMMON_BINARY_PD_HPP
+
+#include <assert.h>
+
+#include "oneapi/dnnl/dnnl.h"
+
+#include "c_types_map.hpp"
+#include "primitive_desc.hpp"
+#include "utils.hpp"
+
+namespace dnnl {
+namespace impl {
+
+struct binary_pd_t : public primitive_desc_t {
+    static constexpr auto base_pkind = primitive_kind::binary;
+
+    typedef binary_pd_t base_class;
+    typedef binary_pd_t hint_class;
+
+    const binary_desc_t *desc() const { return &desc_; }
+    const op_desc_t *op_desc() const override {
+        return reinterpret_cast<const op_desc_t *>(this->desc());
+    }
+
+    status_t query(query_t what, int idx, void *result) const override {
+        switch (what) {
+            case query::alg_kind:
+                *(alg_kind_t *)result = desc()->alg_kind;
+                break;
+            default: return primitive_desc_t::query(what, idx, result);
+        }
+        return status::success;
+    }
+
+    arg_usage_t arg_usage(int arg) const override {
+        if (arg == DNNL_ARG_SRC_0 || arg == DNNL_ARG_SRC_1)
+            return arg_usage_t::input;
+
+        if (arg == DNNL_ARG_DST) return arg_usage_t::output;
+
+        return primitive_desc_t::arg_usage(arg);
+    }
+
+    const memory_desc_t *arg_md(
+            int arg, bool user_input = false) const override {
+        switch (arg) {
+            case DNNL_ARG_SRC_0: return src_md(0);
+            case DNNL_ARG_SRC_1: return src_md(1);
+            case DNNL_ARG_DST: return dst_md(0, user_input);
+            default: return primitive_desc_t::arg_md(arg);
+        }
+    }
+
+    const memory_desc_t *src_md(
+            int index = 0, bool user_input = false) const override {
+        if (index == 0) return user_input ? &desc()->src_desc[0] : &src0_md_;
+        if (index == 1) return user_input ? &desc()->src_desc[1] : &src1_md_;
+        return &glob_zero_md;
+    }
+    const memory_desc_t *dst_md(
+            int index = 0, bool user_input = false) const override {
+        if (index == 0) return user_input ? &desc()->dst_desc : &dst_md_;
+        return &glob_zero_md;
+    }
+
+    int n_inputs() const override { return 2 + n_binary_po_inputs(); }
+    int n_outputs() const override { return 1; }
+
+    const dims_t &broadcast_dims() const { return broadcast_dims_; }
+
+    bool has_zero_dim_memory() const {
+        return memory_desc_wrapper(src_md(0)).has_zero_dim();
+    }
+
+    int ndims() const { return memory_desc_wrapper(src_md(0)).ndims(); }
+
+    bool is_tensor_op() const {
+        const memory_desc_wrapper src0_d(src_md(0));
+        const memory_desc_wrapper src1_d(src_md(1));
+        return src0_d.consistent_with(src1_d);
+    }
+
+protected:
+    binary_desc_t desc_;
+
+    memory_desc_t src0_md_;
+    memory_desc_t src1_md_;
+    memory_desc_t dst_md_;
+
+    dims_t broadcast_dims_;
+
+    binary_pd_t(const binary_desc_t *adesc, const primitive_attr_t *attr,
+            const binary_pd_t *hint_fwd_pd)
+        : primitive_desc_t(attr, base_pkind)
+        , desc_(*adesc)
+        , src0_md_(desc_.src_desc[0])
+        , src1_md_(desc_.src_desc[1])
+        , dst_md_(desc_.dst_desc) {
+        init_broadcast_dims();
+    }
+
+    status_t set_default_params() {
+        if (src1_md_.format_kind == format_kind::any) {
+            const memory_desc_wrapper src_d(src_md(0));
+            if (src_d.is_blocking_desc()) {
+                CHECK(memory_desc_init_by_blocking_desc(
+                        src1_md_, src_d.blocking_desc()));
+            }
+        }
+
+        if (dst_md_.format_kind == format_kind::any) {
+            const memory_desc_wrapper src_d(src_md(0));
+            if (src_d.is_blocking_desc()) {
+                CHECK(memory_desc_init_by_blocking_desc(
+                        dst_md_, src_d.blocking_desc()));
+            }
+        }
+
+        return status::success;
+    }
+
+    bool attr_post_ops_ok() const {
+        using namespace primitive_kind;
+        const auto &p = attr()->post_ops_;
+        switch (p.len()) {
+            case 0: return true;
+            case 1: return p.contain(sum, 0) || p.contain(eltwise, 0);
+            case 2: return p.contain(sum, 0) && p.contain(eltwise, 1);
+            default: return false;
+        }
+    }
+
+    bool attr_scales_ok(const std::vector<int> &supported_args
+            = {DNNL_ARG_SRC_0, DNNL_ARG_SRC_1, DNNL_ARG_DST}) const {
+        bool ok = attr()->scales_.has_default_values(supported_args);
+        for (int arg : supported_args) {
+            const auto &mask = attr()->scales_.get(arg).mask_;
+            ok = ok && (mask == 0);
+        }
+        return ok;
+    }
+
+private:
+    void init_broadcast_dims() {
+        const dims_t &dims_A = src_md(0)->dims;
+        const dims_t &dims_B = src_md(1)->dims;
+
+        for (int d = 0; d < ndims(); ++d)
+            broadcast_dims_[d]
+                    = (dims_A[d] == dims_B[d] && dims_A[d] != 1) ? 0 : 1;
+    }
+};
+
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/common/bit_cast.hpp

@@ -0,0 +1,57 @@
+/*******************************************************************************
+* Copyright 2020-2022 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.
+*******************************************************************************/
+
+#ifndef COMMON_BIT_CAST_HPP
+#define COMMON_BIT_CAST_HPP
+
+#include <cstdint>
+#include <cstring>
+#include <type_traits>
+
+namespace dnnl {
+namespace impl {
+namespace utils {
+
+// Returns a value of type T by reinterpretting the representation of the input
+// value (part of C++20).
+//
+// Provides a safe implementation of type punning.
+//
+// Constraints:
+// - U and T must have the same size
+// - U and T must be trivially copyable
+template <typename T, typename U>
+inline T bit_cast(const U &u) {
+    static_assert(sizeof(T) == sizeof(U), "Bit-casting must preserve size.");
+    static_assert(std::is_trivial<T>::value, "T must be trivially copyable.");
+    static_assert(std::is_trivial<U>::value, "U must be trivially copyable.");
+
+    T t;
+    // Since bit_cast is used in SYCL kernels it cannot use std::memcpy as it
+    // can be implemented as @llvm.objectsize.* + __memcpy_chk for Release
+    // builds which cannot be translated to SPIR-V.
+    uint8_t *t_ptr = reinterpret_cast<uint8_t *>(&t);
+    const uint8_t *u_ptr = reinterpret_cast<const uint8_t *>(&u);
+    for (size_t i = 0; i < sizeof(U); i++)
+        t_ptr[i] = u_ptr[i];
+    return t;
+}
+
+} // namespace utils
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/common/c_types_map.hpp

@@ -0,0 +1,1966 @@
+/*******************************************************************************
+* Copyright 2016-2023 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.
+*******************************************************************************/
+
+#ifndef COMMON_C_TYPES_MAP_HPP
+#define COMMON_C_TYPES_MAP_HPP
+
+#include "oneapi/dnnl/dnnl_types.h"
+
+// These aliases should be in the global namespace as they are intended
+// to give names that better reflects the meaning of the entities
+using primitive_iface_t = dnnl_primitive;
+using primitive_desc_iface_t = dnnl_primitive_desc;
+
+namespace dnnl {
+namespace impl {
+
+// TODO: autogenerate this
+
+using dim_t = dnnl_dim_t;
+using dims_t = dnnl_dims_t;
+using stride_t = dnnl_dim_t;
+using strides_t = dnnl_dims_t;
+
+#ifdef DNNL_STATUS_NODISCARD
+// nodiscard is not allowed in type aliases
+using status_t __attribute__((warn_unused_result)) = dnnl_status_t;
+#else
+using status_t = dnnl_status_t;
+#endif
+namespace status {
+const status_t success = dnnl_success;
+const status_t out_of_memory = dnnl_out_of_memory;
+const status_t invalid_arguments = dnnl_invalid_arguments;
+const status_t unimplemented = dnnl_unimplemented;
+const status_t last_impl_reached = dnnl_last_impl_reached;
+const status_t runtime_error = dnnl_runtime_error;
+const status_t not_required = dnnl_not_required;
+} // namespace status
+
+using prop_kind_t = dnnl_prop_kind_t;
+namespace prop_kind {
+const prop_kind_t undef = dnnl_prop_kind_undef;
+const prop_kind_t forward_training = dnnl_forward_training;
+const prop_kind_t forward_inference = dnnl_forward_inference;
+const prop_kind_t forward = dnnl_forward;
+const prop_kind_t backward = dnnl_backward;
+const prop_kind_t backward_data = dnnl_backward_data;
+const prop_kind_t backward_weights = dnnl_backward_weights;
+const prop_kind_t backward_bias = dnnl_backward_bias;
+} // namespace prop_kind
+
+using alg_kind_t = dnnl_alg_kind_t;
+namespace alg_kind {
+const alg_kind_t undef = dnnl_alg_kind_undef;
+const alg_kind_t convolution_auto = dnnl_convolution_auto;
+const alg_kind_t convolution_direct = dnnl_convolution_direct;
+const alg_kind_t convolution_winograd = dnnl_convolution_winograd;
+const alg_kind_t deconvolution_direct = dnnl_deconvolution_direct;
+const alg_kind_t deconvolution_winograd = dnnl_deconvolution_winograd;
+const alg_kind_t eltwise_relu = dnnl_eltwise_relu;
+const alg_kind_t eltwise_tanh = dnnl_eltwise_tanh;
+const alg_kind_t eltwise_elu = dnnl_eltwise_elu;
+const alg_kind_t eltwise_square = dnnl_eltwise_square;
+const alg_kind_t eltwise_abs = dnnl_eltwise_abs;
+const alg_kind_t eltwise_sqrt = dnnl_eltwise_sqrt;
+const alg_kind_t eltwise_swish = dnnl_eltwise_swish;
+const alg_kind_t eltwise_linear = dnnl_eltwise_linear;
+const alg_kind_t eltwise_soft_relu = dnnl_eltwise_soft_relu;
+const alg_kind_t eltwise_logistic = dnnl_eltwise_logistic;
+const alg_kind_t eltwise_mish = dnnl_eltwise_mish;
+const alg_kind_t eltwise_exp = dnnl_eltwise_exp;
+const alg_kind_t eltwise_log = dnnl_eltwise_log;
+const alg_kind_t eltwise_clip = dnnl_eltwise_clip;
+const alg_kind_t eltwise_clip_v2 = dnnl_eltwise_clip_v2;
+const alg_kind_t eltwise_pow = dnnl_eltwise_pow;
+const alg_kind_t eltwise_gelu_tanh = dnnl_eltwise_gelu_tanh;
+const alg_kind_t eltwise_gelu_erf = dnnl_eltwise_gelu_erf;
+const alg_kind_t eltwise_hardswish = dnnl_eltwise_hardswish;
+const alg_kind_t eltwise_hardsigmoid = dnnl_eltwise_hardsigmoid;
+const alg_kind_t eltwise_relu_use_dst_for_bwd
+        = dnnl_eltwise_relu_use_dst_for_bwd;
+const alg_kind_t eltwise_tanh_use_dst_for_bwd
+        = dnnl_eltwise_tanh_use_dst_for_bwd;
+const alg_kind_t eltwise_elu_use_dst_for_bwd = dnnl_eltwise_elu_use_dst_for_bwd;
+const alg_kind_t eltwise_sqrt_use_dst_for_bwd
+        = dnnl_eltwise_sqrt_use_dst_for_bwd;
+const alg_kind_t eltwise_logistic_use_dst_for_bwd
+        = dnnl_eltwise_logistic_use_dst_for_bwd;
+const alg_kind_t eltwise_exp_use_dst_for_bwd = dnnl_eltwise_exp_use_dst_for_bwd;
+const alg_kind_t eltwise_clip_v2_use_dst_for_bwd
+        = dnnl_eltwise_clip_v2_use_dst_for_bwd;
+const alg_kind_t eltwise_round = dnnl_eltwise_round;
+const alg_kind_t pooling_max = dnnl_pooling_max;
+const alg_kind_t pooling_avg_include_padding = dnnl_pooling_avg_include_padding;
+const alg_kind_t pooling_avg_exclude_padding = dnnl_pooling_avg_exclude_padding;
+const alg_kind_t lrn_across_channels = dnnl_lrn_across_channels;
+const alg_kind_t lrn_within_channel = dnnl_lrn_within_channel;
+const alg_kind_t vanilla_rnn = dnnl_vanilla_rnn;
+const alg_kind_t vanilla_lstm = dnnl_vanilla_lstm;
+const alg_kind_t vanilla_gru = dnnl_vanilla_gru;
+const alg_kind_t lbr_gru = dnnl_lbr_gru;
+const alg_kind_t vanilla_augru = dnnl_vanilla_augru;
+const alg_kind_t lbr_augru = dnnl_lbr_augru;
+const alg_kind_t binary_add = dnnl_binary_add;
+const alg_kind_t binary_mul = dnnl_binary_mul;
+const alg_kind_t binary_max = dnnl_binary_max;
+const alg_kind_t binary_min = dnnl_binary_min;
+const alg_kind_t binary_div = dnnl_binary_div;
+const alg_kind_t binary_sub = dnnl_binary_sub;
+const alg_kind_t binary_ge = dnnl_binary_ge;
+const alg_kind_t binary_gt = dnnl_binary_gt;
+const alg_kind_t binary_le = dnnl_binary_le;
+const alg_kind_t binary_lt = dnnl_binary_lt;
+const alg_kind_t binary_eq = dnnl_binary_eq;
+const alg_kind_t binary_ne = dnnl_binary_ne;
+const alg_kind_t resampling_nearest = dnnl_resampling_nearest;
+const alg_kind_t resampling_linear = dnnl_resampling_linear;
+const alg_kind_t reduction_max = dnnl_reduction_max;
+const alg_kind_t reduction_min = dnnl_reduction_min;
+const alg_kind_t reduction_sum = dnnl_reduction_sum;
+const alg_kind_t reduction_mul = dnnl_reduction_mul;
+const alg_kind_t reduction_mean = dnnl_reduction_mean;
+const alg_kind_t reduction_norm_lp_max = dnnl_reduction_norm_lp_max;
+const alg_kind_t reduction_norm_lp_sum = dnnl_reduction_norm_lp_sum;
+const alg_kind_t reduction_norm_lp_power_p_max
+        = dnnl_reduction_norm_lp_power_p_max;
+const alg_kind_t reduction_norm_lp_power_p_sum
+        = dnnl_reduction_norm_lp_power_p_sum;
+const alg_kind_t softmax_accurate = dnnl_softmax_accurate;
+const alg_kind_t softmax_log = dnnl_softmax_log;
+} // namespace alg_kind
+
+using data_type_t = dnnl_data_type_t;
+namespace data_type {
+const data_type_t undef = dnnl_data_type_undef;
+const data_type_t f16 = dnnl_f16;
+const data_type_t bf16 = dnnl_bf16;
+const data_type_t f32 = dnnl_f32;
+const data_type_t f64 = dnnl_f64;
+const data_type_t s32 = dnnl_s32;
+const data_type_t s8 = dnnl_s8;
+const data_type_t u8 = dnnl_u8;
+const data_type_t boolean = dnnl_boolean;
+const data_type_t data_type_max = dnnl_data_type_max;
+
+// Not exposed through API as all current uses are internal only
+const data_type_t tf32 = static_cast<data_type_t>(1 << 8);
+
+} // namespace data_type
+
+using fpmath_mode_t = dnnl_fpmath_mode_t;
+namespace fpmath_mode {
+const fpmath_mode_t strict = dnnl_fpmath_mode_strict;
+const fpmath_mode_t bf16 = dnnl_fpmath_mode_bf16;
+const fpmath_mode_t f16 = dnnl_fpmath_mode_f16;
+const fpmath_mode_t tf32 = dnnl_fpmath_mode_tf32;
+const fpmath_mode_t any = dnnl_fpmath_mode_any;
+} // namespace fpmath_mode
+
+using scratchpad_mode_t = dnnl_scratchpad_mode_t;
+namespace scratchpad_mode {
+const scratchpad_mode_t library = dnnl_scratchpad_mode_library;
+const scratchpad_mode_t user = dnnl_scratchpad_mode_user;
+} // namespace scratchpad_mode
+
+#ifdef DNNL_EXPERIMENTAL_SPARSE
+using sparse_encoding_t = dnnl_sparse_encoding_t;
+namespace sparse_encoding {
+const sparse_encoding_t undef = dnnl_sparse_encoding_undef;
+const sparse_encoding_t csr = dnnl_csr;
+} // namespace sparse_encoding
+#else
+// Declare dummy values to avoid guarding internal implementation.
+using sparse_encoding_t = int;
+namespace sparse_encoding {
+const sparse_encoding_t undef = 0;
+const sparse_encoding_t csr = 1;
+} // namespace sparse_encoding
+#endif
+
+using format_kind_t = dnnl_format_kind_t;
+namespace format_kind {
+const format_kind_t undef = dnnl_format_kind_undef;
+const format_kind_t any = dnnl_format_kind_any;
+const format_kind_t blocked = dnnl_blocked;
+const format_kind_t opaque = dnnl_format_kind_opaque;
+#ifdef DNNL_EXPERIMENTAL_SPARSE
+const format_kind_t sparse = dnnl_format_kind_sparse;
+#else
+const format_kind_t sparse = dnnl_format_kind_undef;
+#endif
+
+// Internal only format kinds.
+const format_kind_t internal_only_start = (format_kind_t)(1 << 8);
+const format_kind_t wino = internal_only_start;
+const format_kind_t rnn_packed = (format_kind_t)(internal_only_start + 1);
+} // namespace format_kind
+
+#ifdef DNNL_EXPERIMENTAL_PROFILING
+using profiling_data_kind_t = dnnl_profiling_data_kind_t;
+namespace profiling_data_kind {
+const profiling_data_kind_t undef = dnnl_profiling_data_kind_undef;
+const profiling_data_kind_t time = dnnl_profiling_data_kind_time;
+#else
+using profiling_data_kind_t = int;
+namespace profiling_data_kind {
+const profiling_data_kind_t undef = 0;
+const profiling_data_kind_t time = 1;
+#endif
+// Internal only data kinds.
+const profiling_data_kind_t internal_only_start
+        = (profiling_data_kind_t)(1 << 8);
+const profiling_data_kind_t cycles
+        = (profiling_data_kind_t)(internal_only_start + 1);
+} // namespace profiling_data_kind
+
+using format_tag_t = dnnl_format_tag_t;
+namespace format_tag {
+const format_tag_t undef = dnnl_format_tag_undef;
+const format_tag_t any = dnnl_format_tag_any;
+const format_tag_t a = dnnl_a;
+const format_tag_t ab = dnnl_ab;
+const format_tag_t abc = dnnl_abc;
+const format_tag_t abcd = dnnl_abcd;
+const format_tag_t abcde = dnnl_abcde;
+const format_tag_t abcdef = dnnl_abcdef;
+const format_tag_t abcdefg = dnnl_abcdefg;
+const format_tag_t abcdefgh = dnnl_abcdefgh;
+const format_tag_t abcdefghi = dnnl_abcdefghi;
+const format_tag_t abcdefghij = dnnl_abcdefghij;
+const format_tag_t abcdefghijk = dnnl_abcdefghijk;
+const format_tag_t abcdefghijkl = dnnl_abcdefghijkl;
+const format_tag_t abcdefghijlk = dnnl_abcdefghijlk;
+const format_tag_t abcdefghikj = dnnl_abcdefghikj;
+const format_tag_t abcdefghji = dnnl_abcdefghji;
+const format_tag_t abcdefgih = dnnl_abcdefgih;
+const format_tag_t abcdefhg = dnnl_abcdefhg;
+const format_tag_t abcdegf = dnnl_abcdegf;
+const format_tag_t abcdfe = dnnl_abcdfe;
+const format_tag_t abced = dnnl_abced;
+const format_tag_t abdc = dnnl_abdc;
+const format_tag_t acbd = dnnl_acbd;
+const format_tag_t abdec = dnnl_abdec;
+const format_tag_t abdfce = dnnl_abdfce;
+const format_tag_t acb = dnnl_acb;
+const format_tag_t acbde = dnnl_acbde;
+const format_tag_t acbdef = dnnl_acbdef;
+const format_tag_t abdefc = dnnl_abdefc;
+const format_tag_t acdb = dnnl_acdb;
+const format_tag_t acdeb = dnnl_acdeb;
+const format_tag_t adbc = dnnl_adbc;
+const format_tag_t ba = dnnl_ba;
+const format_tag_t bac = dnnl_bac;
+const format_tag_t bacd = dnnl_bacd;
+const format_tag_t bca = dnnl_bca;
+const format_tag_t bcda = dnnl_bcda;
+const format_tag_t bcdea = dnnl_bcdea;
+const format_tag_t bacde = dnnl_bacde;
+const format_tag_t cab = dnnl_cab;
+const format_tag_t cba = dnnl_cba;
+const format_tag_t cdab = dnnl_cdab;
+const format_tag_t cdba = dnnl_cdba;
+const format_tag_t dcab = dnnl_dcab;
+const format_tag_t cdeab = dnnl_cdeab;
+const format_tag_t cdeba = dnnl_cdeba;
+const format_tag_t decab = dnnl_decab;
+const format_tag_t defcab = dnnl_defcab;
+const format_tag_t AB16b16a = dnnl_AB16b16a;
+const format_tag_t AB16b32a = dnnl_AB16b32a;
+const format_tag_t AB16b48a = dnnl_AB16b48a;
+const format_tag_t AB16b64a = dnnl_AB16b64a;
+const format_tag_t AB8b16a2b = dnnl_AB8b16a2b;
+const format_tag_t AB8b32a2b = dnnl_AB8b32a2b;
+const format_tag_t AB8b64a2b = dnnl_AB8b64a2b;
+const format_tag_t AB4b8a4b = dnnl_AB4b8a4b;
+const format_tag_t AB4b16a4b = dnnl_AB4b16a4b;
+const format_tag_t AB4b24a4b = dnnl_AB4b24a4b;
+const format_tag_t AB4b32a4b = dnnl_AB4b32a4b;
+const format_tag_t AB4b64a4b = dnnl_AB4b64a4b;
+const format_tag_t AB32a16b = dnnl_AB32a16b;
+const format_tag_t AB32a32b = dnnl_AB32a32b;
+const format_tag_t AB48a16b = dnnl_AB48a16b;
+const format_tag_t AB48a32b = dnnl_AB48a32b;
+const format_tag_t BA4b8a8b2a = dnnl_BA4b8a8b2a;
+const format_tag_t BA4b8a8b4a = dnnl_BA4b8a8b4a;
+const format_tag_t BA4b8a16b2a = dnnl_BA4b8a16b2a;
+const format_tag_t BA4b8a16b4a = dnnl_BA4b8a16b4a;
+const format_tag_t aBC32b16c = dnnl_aBC32b16c;
+const format_tag_t aBC32b32c = dnnl_aBC32b32c;
+const format_tag_t aBC48b16c = dnnl_aBC48b16c;
+const format_tag_t aBC48b32c = dnnl_aBC48b32c;
+const format_tag_t aCB4c8b8c2b = dnnl_aCB4c8b8c2b;
+const format_tag_t aCB4c8b8c4b = dnnl_aCB4c8b8c4b;
+const format_tag_t aCB4c8b16c2b = dnnl_aCB4c8b16c2b;
+const format_tag_t aCB4c8b16c4b = dnnl_aCB4c8b16c4b;
+const format_tag_t AB16b16a4b = dnnl_AB16b16a4b;
+const format_tag_t AB16b32a4b = dnnl_AB16b32a4b;
+const format_tag_t AB16b48a4b = dnnl_AB16b48a4b;
+const format_tag_t AB16b64a4b = dnnl_AB16b64a4b;
+const format_tag_t AB16b16a2b = dnnl_AB16b16a2b;
+const format_tag_t AB16b32a2b = dnnl_AB16b32a2b;
+const format_tag_t AB16b48a2b = dnnl_AB16b48a2b;
+const format_tag_t AB16b64a2b = dnnl_AB16b64a2b;
+const format_tag_t BA16a16b = dnnl_BA16a16b;
+const format_tag_t BA16a32b = dnnl_BA16a32b;
+const format_tag_t BA16a48b = dnnl_BA16a48b;
+const format_tag_t BA16a64b = dnnl_BA16a64b;
+const format_tag_t BA16a16b2a = dnnl_BA16a16b2a;
+const format_tag_t BA16a32b2a = dnnl_BA16a32b2a;
+const format_tag_t BA16a48b2a = dnnl_BA16a48b2a;
+const format_tag_t BA16a64b2a = dnnl_BA16a64b2a;
+const format_tag_t BA16a16b4a = dnnl_BA16a16b4a;
+const format_tag_t BA16a32b4a = dnnl_BA16a32b4a;
+const format_tag_t BA16a48b4a = dnnl_BA16a48b4a;
+const format_tag_t BA16a64b4a = dnnl_BA16a64b4a;
+const format_tag_t aCB16b16c = dnnl_aCB16b16c;
+const format_tag_t aCB16b32c = dnnl_aCB16b32c;
+const format_tag_t aCB16b48c = dnnl_aCB16b48c;
+const format_tag_t aCB16b64c = dnnl_aCB16b64c;
+const format_tag_t aCB16b16c2b = dnnl_aCB16b16c2b;
+const format_tag_t aCB16b32c2b = dnnl_aCB16b32c2b;
+const format_tag_t aCB16b48c2b = dnnl_aCB16b48c2b;
+const format_tag_t aCB16b64c2b = dnnl_aCB16b64c2b;
+const format_tag_t aCB16b16c4b = dnnl_aCB16b16c4b;
+const format_tag_t aCB16b32c4b = dnnl_aCB16b32c4b;
+const format_tag_t aCB16b48c4b = dnnl_aCB16b48c4b;
+const format_tag_t aCB16b64c4b = dnnl_aCB16b64c4b;
+
+const format_tag_t Abc16a = dnnl_Abc16a;
+const format_tag_t ABc16a16b = dnnl_ABc16a16b;
+const format_tag_t ABc4a2b = dnnl_ABc4a2b;
+const format_tag_t ABc4a4b = dnnl_ABc4a4b;
+const format_tag_t aBc16b = dnnl_aBc16b;
+const format_tag_t aBc32b = dnnl_aBc32b;
+const format_tag_t ABc16b16a = dnnl_ABc16b16a;
+const format_tag_t ABc16b32a = dnnl_ABc16b32a;
+const format_tag_t ABc16b48a = dnnl_ABc16b48a;
+const format_tag_t ABc16b64a = dnnl_ABc16b64a;
+const format_tag_t Abc4a = dnnl_Abc4a;
+const format_tag_t aBc4b = dnnl_aBc4b;
+const format_tag_t ABc4b8a4b = dnnl_ABc4b8a4b;
+const format_tag_t ABc4b16a4b = dnnl_ABc4b16a4b;
+const format_tag_t ABc4b24a4b = dnnl_ABc4b24a4b;
+const format_tag_t ABc4b32a4b = dnnl_ABc4b32a4b;
+const format_tag_t ABc4b64a4b = dnnl_ABc4b64a4b;
+const format_tag_t ABc2b8a4b = dnnl_ABc2b8a4b;
+const format_tag_t ABc16b16a4b = dnnl_ABc16b16a4b;
+const format_tag_t ABc16b32a4b = dnnl_ABc16b32a4b;
+const format_tag_t ABc16b48a4b = dnnl_ABc16b48a4b;
+const format_tag_t ABc16b64a4b = dnnl_ABc16b64a4b;
+const format_tag_t ABc16b16a2b = dnnl_ABc16b16a2b;
+const format_tag_t ABc16b32a2b = dnnl_ABc16b32a2b;
+const format_tag_t ABc16b48a2b = dnnl_ABc16b48a2b;
+const format_tag_t ABc16b64a2b = dnnl_ABc16b64a2b;
+const format_tag_t ABc16a16b2a = dnnl_ABc16a16b2a;
+const format_tag_t ABc4b4a = dnnl_ABc4b4a;
+const format_tag_t ABc8a16b2a = dnnl_ABc8a16b2a;
+const format_tag_t BAc8a16b2a = dnnl_BAc8a16b2a;
+const format_tag_t ABc8a8b = dnnl_ABc8a8b;
+const format_tag_t ABc8a2b = dnnl_ABc8a2b;
+const format_tag_t ABc8a4b = dnnl_ABc8a4b;
+const format_tag_t aBc8b = dnnl_aBc8b;
+const format_tag_t ABc8b16a2b = dnnl_ABc8b16a2b;
+const format_tag_t ABc8b32a2b = dnnl_ABc8b32a2b;
+const format_tag_t ABc8b64a2b = dnnl_ABc8b64a2b;
+const format_tag_t ABc8b8a = dnnl_ABc8b8a;
+const format_tag_t Abcd16a = dnnl_Abcd16a;
+const format_tag_t Abcd8a = dnnl_Abcd8a;
+const format_tag_t Abcd32a = dnnl_Abcd32a;
+const format_tag_t ABcd16a16b = dnnl_ABcd16a16b;
+const format_tag_t aBcd16b = dnnl_aBcd16b;
+const format_tag_t aBcd32b = dnnl_aBcd32b;
+const format_tag_t ABcd16b16a = dnnl_ABcd16b16a;
+const format_tag_t ABcd16b32a = dnnl_ABcd16b32a;
+const format_tag_t ABcd16b48a = dnnl_ABcd16b48a;
+const format_tag_t ABcd16b64a = dnnl_ABcd16b64a;
+const format_tag_t aBCd16b16c = dnnl_aBCd16b16c;
+const format_tag_t aBCd16c16b = dnnl_aBCd16c16b;
+const format_tag_t Abcd4a = dnnl_Abcd4a;
+const format_tag_t aBcd4b = dnnl_aBcd4b;
+const format_tag_t ABcd4b8a4b = dnnl_ABcd4b8a4b;
+const format_tag_t ABcd4b16a4b = dnnl_ABcd4b16a4b;
+const format_tag_t ABcd4b24a4b = dnnl_ABcd4b24a4b;
+const format_tag_t ABcd4b32a4b = dnnl_ABcd4b32a4b;
+const format_tag_t ABcd4b64a4b = dnnl_ABcd4b64a4b;
+const format_tag_t ABcd16b16a4b = dnnl_ABcd16b16a4b;
+const format_tag_t ABcd16b32a4b = dnnl_ABcd16b32a4b;
+const format_tag_t ABcd16b48a4b = dnnl_ABcd16b48a4b;
+const format_tag_t ABcd16b64a4b = dnnl_ABcd16b64a4b;
+const format_tag_t ABcd16b16a2b = dnnl_ABcd16b16a2b;
+const format_tag_t ABcd16b32a2b = dnnl_ABcd16b32a2b;
+const format_tag_t ABcd16b48a2b = dnnl_ABcd16b48a2b;
+const format_tag_t ABcd16b64a2b = dnnl_ABcd16b64a2b;
+const format_tag_t ABcd16a16b2a = dnnl_ABcd16a16b2a;
+const format_tag_t ABcde16a16b2a = dnnl_ABcde16a16b2a;
+const format_tag_t ABcd4b4a = dnnl_ABcd4b4a;
+const format_tag_t ABcd4a2b = dnnl_ABcd4a2b;
+const format_tag_t ABcd4a4b = dnnl_ABcd4a4b;
+const format_tag_t aBCd4c16b4c = dnnl_aBCd4c16b4c;
+const format_tag_t aBCd2c8b4c = dnnl_aBCd2c8b4c;
+const format_tag_t aBCd16c16b4c = dnnl_aBCd16c16b4c;
+const format_tag_t aBCd16c16b2c = dnnl_aBCd16c16b2c;
+const format_tag_t aBCd16b16c2b = dnnl_aBCd16b16c2b;
+const format_tag_t aBCd4c4b = dnnl_aBCd4c4b;
+const format_tag_t aBCd4b4c = dnnl_aBCd4b4c;
+const format_tag_t ABcd8a16b2a = dnnl_ABcd8a16b2a;
+const format_tag_t BAcd8a16b2a = dnnl_BAcd8a16b2a;
+const format_tag_t ABcd8a8b = dnnl_ABcd8a8b;
+const format_tag_t ABcd8a4b = dnnl_ABcd8a4b;
+const format_tag_t ABcd8a2b = dnnl_ABcd8a2b;
+const format_tag_t aBcd8b = dnnl_aBcd8b;
+const format_tag_t ABcd8b16a2b = dnnl_ABcd8b16a2b;
+const format_tag_t ABcd8b32a2b = dnnl_ABcd8b32a2b;
+const format_tag_t ABcd8b64a2b = dnnl_ABcd8b64a2b;
+const format_tag_t ABcd2b8a4b = dnnl_ABcd2b8a4b;
+const format_tag_t aBCd8b16c2b = dnnl_aBCd8b16c2b;
+const format_tag_t aCBd8b16c2b = dnnl_aCBd8b16c2b;
+const format_tag_t aBCd2c8b16c2b = dnnl_aBCd2c8b16c2b;
+const format_tag_t ABcd8b8a = dnnl_ABcd8b8a;
+const format_tag_t aBCd8b8c = dnnl_aBCd8b8c;
+const format_tag_t aBCd8b2c = dnnl_aBCd8b2c;
+const format_tag_t aBCd8b4c = dnnl_aBCd8b4c;
+const format_tag_t aBCd8c16b2c = dnnl_aBCd8c16b2c;
+const format_tag_t aBCd8c8b = dnnl_aBCd8c8b;
+const format_tag_t Abcde16a = dnnl_Abcde16a;
+const format_tag_t Abcde32a = dnnl_Abcde32a;
+const format_tag_t ABcde16a16b = dnnl_ABcde16a16b;
+const format_tag_t aBcde16b = dnnl_aBcde16b;
+const format_tag_t aBcde32b = dnnl_aBcde32b;
+const format_tag_t ABcde16b16a = dnnl_ABcde16b16a;
+const format_tag_t ABcde16b32a = dnnl_ABcde16b32a;
+const format_tag_t ABcde16b48a = dnnl_ABcde16b48a;
+const format_tag_t ABcde16b64a = dnnl_ABcde16b64a;
+const format_tag_t aBCde16b16c = dnnl_aBCde16b16c;
+const format_tag_t aBCde16c16b = dnnl_aBCde16c16b;
+const format_tag_t aBCde2c8b4c = dnnl_aBCde2c8b4c;
+const format_tag_t Abcde4a = dnnl_Abcde4a;
+const format_tag_t aBcde4b = dnnl_aBcde4b;
+const format_tag_t ABcde4b4a = dnnl_ABcde4b4a;
+const format_tag_t ABcde4a2b = dnnl_ABcde4a2b;
+const format_tag_t ABcde4a4b = dnnl_ABcde4a4b;
+const format_tag_t aBCde4b4c = dnnl_aBCde4b4c;
+const format_tag_t aBCde4c16b4c = dnnl_aBCde4c16b4c;
+const format_tag_t aBCde16c16b4c = dnnl_aBCde16c16b4c;
+const format_tag_t aBCde16c16b2c = dnnl_aBCde16c16b2c;
+const format_tag_t aBCde16b16c2b = dnnl_aBCde16b16c2b;
+const format_tag_t aBCde4c4b = dnnl_aBCde4c4b;
+const format_tag_t Abcde8a = dnnl_Abcde8a;
+const format_tag_t ABcde8a8b = dnnl_ABcde8a8b;
+const format_tag_t ABcde8a2b = dnnl_ABcde8a2b;
+const format_tag_t ABcde8a4b = dnnl_ABcde8a4b;
+const format_tag_t aBcde8b = dnnl_aBcde8b;
+const format_tag_t ABcde8b16a2b = dnnl_ABcde8b16a2b;
+const format_tag_t ABcde8b32a2b = dnnl_ABcde8b32a2b;
+const format_tag_t ABcde8b64a2b = dnnl_ABcde8b64a2b;
+const format_tag_t ABcde8a16b2a = dnnl_ABcde8a16b2a;
+const format_tag_t BAcde8a16b2a = dnnl_BAcde8a16b2a;
+const format_tag_t ABcde4b8a4b = dnnl_ABcde4b8a4b;
+const format_tag_t ABcde4b16a4b = dnnl_ABcde4b16a4b;
+const format_tag_t ABcde4b24a4b = dnnl_ABcde4b24a4b;
+const format_tag_t ABcde4b32a4b = dnnl_ABcde4b32a4b;
+const format_tag_t ABcde4b64a4b = dnnl_ABcde4b64a4b;
+const format_tag_t ABcde16b16a4b = dnnl_ABcde16b16a4b;
+const format_tag_t ABcde16b32a4b = dnnl_ABcde16b32a4b;
+const format_tag_t ABcde16b48a4b = dnnl_ABcde16b48a4b;
+const format_tag_t ABcde16b64a4b = dnnl_ABcde16b64a4b;
+const format_tag_t ABcde2b8a4b = dnnl_ABcde2b8a4b;
+const format_tag_t aBCde8b16c2b = dnnl_aBCde8b16c2b;
+const format_tag_t aCBde8b16c2b = dnnl_aCBde8b16c2b;
+const format_tag_t ABcde8b8a = dnnl_ABcde8b8a;
+const format_tag_t aBCde8b8c = dnnl_aBCde8b8c;
+const format_tag_t aBCde8b2c = dnnl_aBCde8b2c;
+const format_tag_t aBCde8b4c = dnnl_aBCde8b4c;
+const format_tag_t ABc4a8b8a4b = dnnl_ABc4a8b8a4b;
+const format_tag_t ABcd4a8b8a4b = dnnl_ABcd4a8b8a4b;
+const format_tag_t ABcde4a8b8a4b = dnnl_ABcde4a8b8a4b;
+const format_tag_t ABcd2a8b8a2b = dnnl_ABcd2a8b8a2b;
+const format_tag_t ABcde4a8b8a2b = dnnl_ABcde4a8b8a2b;
+const format_tag_t ABcd4a8b8a2b = dnnl_ABcd4a8b8a2b;
+const format_tag_t ABc4a8b8a2b = dnnl_ABc4a8b8a2b;
+const format_tag_t aBCdef4b8c8b2c = dnnl_aBCdef4b8c8b2c;
+const format_tag_t aBCde4b8c8b2c = dnnl_aBCde4b8c8b2c;
+const format_tag_t aBCd4b8c8b2c = dnnl_aBCd4b8c8b2c;
+const format_tag_t BAcde4b8a8b2a = dnnl_BAcde4b8a8b2a;
+const format_tag_t BAcd4b8a8b2a = dnnl_BAcd4b8a8b2a;
+const format_tag_t BAc4b8a8b2a = dnnl_BAc4b8a8b2a;
+const format_tag_t aCBdef4c8b8c2b = dnnl_aCBdef4c8b8c2b;
+const format_tag_t aCBde4c8b8c2b = dnnl_aCBde4c8b8c2b;
+const format_tag_t aCBd4c8b8c2b = dnnl_aCBd4c8b8c2b;
+const format_tag_t aBCd4b8c8b4c = dnnl_aBCd4b8c8b4c;
+const format_tag_t aBCde4b8c8b4c = dnnl_aBCde4b8c8b4c;
+const format_tag_t aBCdef4b8c8b4c = dnnl_aBCdef4b8c8b4c;
+const format_tag_t BAc4b8a8b4a = dnnl_BAc4b8a8b4a;
+const format_tag_t BAcd4b8a8b4a = dnnl_BAcd4b8a8b4a;
+const format_tag_t BAcde4b8a8b4a = dnnl_BAcde4b8a8b4a;
+const format_tag_t aCBd4c8b8c4b = dnnl_aCBd4c8b8c4b;
+const format_tag_t aCBde4c8b8c4b = dnnl_aCBde4c8b8c4b;
+const format_tag_t aCBdef4c8b8c4b = dnnl_aCBdef4c8b8c4b;
+const format_tag_t aBCde2b8c8b2c = dnnl_aBCde2b8c8b2c;
+const format_tag_t aBCde8c16b2c = dnnl_aBCde8c16b2c;
+const format_tag_t aBCde8c8b = dnnl_aBCde8c8b;
+const format_tag_t aBcdef16b = dnnl_aBcdef16b;
+const format_tag_t aBCdef16b16c = dnnl_aBCdef16b16c;
+const format_tag_t aBCdef16b16c2b = dnnl_aBCdef16b16c2b;
+const format_tag_t aBCdef16c16b = dnnl_aBCdef16c16b;
+const format_tag_t aBCdef4c16b4c = dnnl_aBCdef4c16b4c;
+const format_tag_t aBCdef2c8b4c = dnnl_aBCdef2c8b4c;
+const format_tag_t aBcdef4b = dnnl_aBcdef4b;
+const format_tag_t aBCdef4c4b = dnnl_aBCdef4c4b;
+const format_tag_t aBCdef4b4c = dnnl_aBCdef4b4c;
+const format_tag_t aBCdef8b8c = dnnl_aBCdef8b8c;
+const format_tag_t aBCdef8b2c = dnnl_aBCdef8b2c;
+const format_tag_t aBCdef8b4c = dnnl_aBCdef8b4c;
+const format_tag_t aBCdef8c16b2c = dnnl_aBCdef8c16b2c;
+const format_tag_t aBCdef8b16c2b = dnnl_aBCdef8b16c2b;
+const format_tag_t aCBdef8b16c2b = dnnl_aCBdef8b16c2b;
+const format_tag_t aBCdef8c8b = dnnl_aBCdef8c8b;
+const format_tag_t aBdc16b = dnnl_aBdc16b;
+const format_tag_t aBdC16b2c = dnnl_aBdC16b2c;
+const format_tag_t aBdC16b4c = dnnl_aBdC16b4c;
+const format_tag_t aBdc4b = dnnl_aBdc4b;
+const format_tag_t aBdc8b = dnnl_aBdc8b;
+const format_tag_t aBdC8b2c = dnnl_aBdC8b2c;
+const format_tag_t aBdC8b4c = dnnl_aBdC8b4c;
+const format_tag_t aBdec16b = dnnl_aBdec16b;
+const format_tag_t aBdeC16b2c = dnnl_aBdeC16b2c;
+const format_tag_t aBdeC16b4c = dnnl_aBdeC16b4c;
+const format_tag_t aBdec4b = dnnl_aBdec4b;
+const format_tag_t aBdec8b = dnnl_aBdec8b;
+const format_tag_t aBdeC8b2c = dnnl_aBdeC8b2c;
+const format_tag_t aBdeC8b4c = dnnl_aBdeC8b4c;
+const format_tag_t aBdefc16b = dnnl_aBdefc16b;
+const format_tag_t aBdefC16b2c = dnnl_aBdefC16b2c;
+const format_tag_t aBdefC16b4c = dnnl_aBdefC16b4c;
+const format_tag_t aCBdef16c16b = dnnl_aCBdef16c16b;
+const format_tag_t aCBdef16b16c = dnnl_aCBdef16b16c;
+const format_tag_t aBdefc4b = dnnl_aBdefc4b;
+const format_tag_t aBdefc8b = dnnl_aBdefc8b;
+const format_tag_t aBdefC8b2c = dnnl_aBdefC8b2c;
+const format_tag_t aBdefC8b4c = dnnl_aBdefC8b4c;
+const format_tag_t aBdfec16b = dnnl_aBdfec16b;
+const format_tag_t aBedc16b = dnnl_aBedc16b;
+const format_tag_t Acb16a = dnnl_Acb16a;
+const format_tag_t AcB16a2b = dnnl_AcB16a2b;
+const format_tag_t AcB16a4b = dnnl_AcB16a4b;
+const format_tag_t Acb4a = dnnl_Acb4a;
+const format_tag_t Acb8a = dnnl_Acb8a;
+const format_tag_t AcB8a2b = dnnl_AcB8a2b;
+const format_tag_t AcB8a4b = dnnl_AcB8a4b;
+const format_tag_t aCBd16b16c = dnnl_aCBd16b16c;
+const format_tag_t aCBd16c16b = dnnl_aCBd16c16b;
+const format_tag_t aCBde16b16c = dnnl_aCBde16b16c;
+const format_tag_t aCBde16c16b = dnnl_aCBde16c16b;
+const format_tag_t Acdb16a = dnnl_Acdb16a;
+const format_tag_t AcdB16a2b = dnnl_AcdB16a2b;
+const format_tag_t AcdB16a4b = dnnl_AcdB16a4b;
+const format_tag_t Acdb4a = dnnl_Acdb4a;
+const format_tag_t Acdb8a = dnnl_Acdb8a;
+const format_tag_t AcdB8a2b = dnnl_AcdB8a2b;
+const format_tag_t AcdB8a4b = dnnl_AcdB8a4b;
+const format_tag_t Acdeb16a = dnnl_Acdeb16a;
+const format_tag_t AcdeB16a2b = dnnl_AcdeB16a2b;
+const format_tag_t AcdeB16a4b = dnnl_AcdeB16a4b;
+const format_tag_t Acdeb4a = dnnl_Acdeb4a;
+const format_tag_t Acdeb8a = dnnl_Acdeb8a;
+const format_tag_t AcdeB8a2b = dnnl_AcdeB8a2b;
+const format_tag_t AcdeB8a4b = dnnl_AcdeB8a4b;
+const format_tag_t Acedb16a = dnnl_Acedb16a;
+const format_tag_t Adcb16a = dnnl_Adcb16a;
+const format_tag_t BAc16a16b = dnnl_BAc16a16b;
+const format_tag_t BAcd16a16b = dnnl_BAcd16a16b;
+const format_tag_t ABc32a16b = dnnl_ABc32a16b;
+const format_tag_t ABcd32a16b = dnnl_ABcd32a16b;
+const format_tag_t ABcde32a16b = dnnl_ABcde32a16b;
+const format_tag_t ABc40a16b = dnnl_ABc40a16b;
+const format_tag_t ABcd40a16b = dnnl_ABcd40a16b;
+const format_tag_t ABcde40a16b = dnnl_ABcde40a16b;
+const format_tag_t ABc32a32b = dnnl_ABc32a32b;
+const format_tag_t BAcde16a16b = dnnl_BAcde16a16b;
+const format_tag_t ABcd32a32b = dnnl_ABcd32a32b;
+const format_tag_t ABcde32a32b = dnnl_ABcde32a32b;
+const format_tag_t ABc40a32b = dnnl_ABc40a32b;
+const format_tag_t ABcd40a32b = dnnl_ABcd40a32b;
+const format_tag_t ABcde40a32b = dnnl_ABcde40a32b;
+const format_tag_t BAcde16b16a = dnnl_BAcde16b16a;
+const format_tag_t aBdec32b = dnnl_aBdec32b;
+const format_tag_t Abcdef16a = dnnl_Abcdef16a;
+const format_tag_t Abcdef32a = dnnl_Abcdef32a;
+const format_tag_t Acdb32a = dnnl_Acdb32a;
+const format_tag_t BAc16b16a = dnnl_BAc16b16a;
+const format_tag_t BAcd16b16a = dnnl_BAcd16b16a;
+const format_tag_t aBCd2b4c2b = dnnl_aBCd2b4c2b;
+const format_tag_t aBCde2b4c2b = dnnl_aBCde2b4c2b;
+const format_tag_t aBCdef2b4c2b = dnnl_aBCdef2b4c2b;
+const format_tag_t aBCd2c4b2c = dnnl_aBCd2c4b2c;
+const format_tag_t aBCde2c4b2c = dnnl_aBCde2c4b2c;
+const format_tag_t aBCdef2c4b2c = dnnl_aBCdef2c4b2c;
+const format_tag_t aBCd4b8c2b = dnnl_aBCd4b8c2b;
+const format_tag_t aBCde4b8c2b = dnnl_aBCde4b8c2b;
+const format_tag_t aBCdef4b8c2b = dnnl_aBCdef4b8c2b;
+const format_tag_t aBCd4c8b2c = dnnl_aBCd4c8b2c;
+const format_tag_t aBCde4c8b2c = dnnl_aBCde4c8b2c;
+const format_tag_t aBCdef4c8b2c = dnnl_aBCdef4c8b2c;
+const format_tag_t AB32a32b8a4b = dnnl_AB32a32b8a4b;
+const format_tag_t AB8a4b = dnnl_AB8a4b;
+const format_tag_t AB32a32b8a2b = dnnl_AB32a32b8a2b;
+const format_tag_t AB8a2b = dnnl_AB8a2b;
+const format_tag_t abDc16d = dnnl_abDc16d;
+const format_tag_t abDc32d = dnnl_abDc32d;
+const format_tag_t abDC32d4c = dnnl_abDC32d4c;
+const format_tag_t abCd4c = dnnl_abCd4c;
+const format_tag_t abCde4c = dnnl_abCde4c;
+const format_tag_t abCdef4c = dnnl_abCdef4c;
+const format_tag_t abCd32c = dnnl_abCd32c;
+const format_tag_t abCde32c = dnnl_abCde32c;
+const format_tag_t abCdef32c = dnnl_abCdef32c;
+const format_tag_t abdEc16e = dnnl_abdEc16e;
+const format_tag_t abdEc32e = dnnl_abdEc32e;
+const format_tag_t abdEC32e2c = dnnl_abdEC32e2c;
+const format_tag_t abdEC32e4c = dnnl_abdEC32e4c;
+const format_tag_t abdEC64e2c = dnnl_abdEC64e2c;
+const format_tag_t abdEC64e4c = dnnl_abdEC64e4c;
+const format_tag_t abdCe16c = dnnl_abdCe16c;
+const format_tag_t abdCe32c = dnnl_abdCe32c;
+const format_tag_t abdCE32c2e = dnnl_abdCE32c2e;
+const format_tag_t aBCdef16c16b4c = dnnl_aBCdef16c16b4c;
+const format_tag_t ABcde16b16a2b = dnnl_ABcde16b16a2b;
+const format_tag_t ABcde16b32a2b = dnnl_ABcde16b32a2b;
+const format_tag_t ABcde16b48a2b = dnnl_ABcde16b48a2b;
+const format_tag_t ABcde16b64a2b = dnnl_ABcde16b64a2b;
+const format_tag_t aBCdef16c16b2c = dnnl_aBCdef16c16b2c;
+const format_tag_t cBa2b = dnnl_cBa2b;
+const format_tag_t cBa4b = dnnl_cBa4b;
+const format_tag_t adcb = dnnl_adcb;
+const format_tag_t adCb2c = dnnl_adCb2c;
+const format_tag_t adCb4c = dnnl_adCb4c;
+const format_tag_t cdBa2b = dnnl_cdBa2b;
+const format_tag_t cdBa4b = dnnl_cdBa4b;
+const format_tag_t adecb = dnnl_adecb;
+const format_tag_t adeCb2c = dnnl_adeCb2c;
+const format_tag_t adeCb4c = dnnl_adeCb4c;
+const format_tag_t cdeBa2b = dnnl_cdeBa2b;
+const format_tag_t cdeBa4b = dnnl_cdeBa4b;
+const format_tag_t adefcb = dnnl_adefcb;
+const format_tag_t adefCb2c = dnnl_adefCb2c;
+const format_tag_t adefCb4c = dnnl_adefCb4c;
+const format_tag_t Acb32a = dnnl_Acb32a;
+const format_tag_t AcB32a2b = dnnl_AcB32a2b;
+const format_tag_t AcB32a4b = dnnl_AcB32a4b;
+const format_tag_t Acb48a = dnnl_Acb48a;
+const format_tag_t AcB48a2b = dnnl_AcB48a2b;
+const format_tag_t AcB48a4b = dnnl_AcB48a4b;
+const format_tag_t Acb64a = dnnl_Acb64a;
+const format_tag_t AcB64a2b = dnnl_AcB64a2b;
+const format_tag_t AcB64a4b = dnnl_AcB64a4b;
+const format_tag_t aBdc32b = dnnl_aBdc32b;
+const format_tag_t aBdC32b2c = dnnl_aBdC32b2c;
+const format_tag_t aBdC32b4c = dnnl_aBdC32b4c;
+const format_tag_t aBdc48b = dnnl_aBdc48b;
+const format_tag_t aBdC48b2c = dnnl_aBdC48b2c;
+const format_tag_t aBdC48b4c = dnnl_aBdC48b4c;
+const format_tag_t aBdc64b = dnnl_aBdc64b;
+const format_tag_t aBdC64b2c = dnnl_aBdC64b2c;
+const format_tag_t aBdC64b4c = dnnl_aBdC64b4c;
+const format_tag_t AcdB32a2b = dnnl_AcdB32a2b;
+const format_tag_t AcdB32a4b = dnnl_AcdB32a4b;
+const format_tag_t Acdb48a = dnnl_Acdb48a;
+const format_tag_t AcdB48a2b = dnnl_AcdB48a2b;
+const format_tag_t AcdB48a4b = dnnl_AcdB48a4b;
+const format_tag_t Acdb64a = dnnl_Acdb64a;
+const format_tag_t AcdB64a2b = dnnl_AcdB64a2b;
+const format_tag_t AcdB64a4b = dnnl_AcdB64a4b;
+const format_tag_t aBdeC32b2c = dnnl_aBdeC32b2c;
+const format_tag_t aBdeC32b4c = dnnl_aBdeC32b4c;
+const format_tag_t aBdec48b = dnnl_aBdec48b;
+const format_tag_t aBdeC48b2c = dnnl_aBdeC48b2c;
+const format_tag_t aBdeC48b4c = dnnl_aBdeC48b4c;
+const format_tag_t aBdec64b = dnnl_aBdec64b;
+const format_tag_t aBdeC64b2c = dnnl_aBdeC64b2c;
+const format_tag_t aBdeC64b4c = dnnl_aBdeC64b4c;
+const format_tag_t Acdeb32a = dnnl_Acdeb32a;
+const format_tag_t AcdeB32a2b = dnnl_AcdeB32a2b;
+const format_tag_t AcdeB32a4b = dnnl_AcdeB32a4b;
+const format_tag_t Acdeb48a = dnnl_Acdeb48a;
+const format_tag_t AcdeB48a2b = dnnl_AcdeB48a2b;
+const format_tag_t AcdeB48a4b = dnnl_AcdeB48a4b;
+const format_tag_t Acdeb64a = dnnl_Acdeb64a;
+const format_tag_t AcdeB64a2b = dnnl_AcdeB64a2b;
+const format_tag_t AcdeB64a4b = dnnl_AcdeB64a4b;
+const format_tag_t aBdefc32b = dnnl_aBdefc32b;
+const format_tag_t aBdefC32b2c = dnnl_aBdefC32b2c;
+const format_tag_t aBdefC32b4c = dnnl_aBdefC32b4c;
+const format_tag_t aBdefc48b = dnnl_aBdefc48b;
+const format_tag_t aBdefC48b2c = dnnl_aBdefC48b2c;
+const format_tag_t aBdefC48b4c = dnnl_aBdefC48b4c;
+const format_tag_t aBdefc64b = dnnl_aBdefc64b;
+const format_tag_t aBdefC64b2c = dnnl_aBdefC64b2c;
+const format_tag_t aBdefC64b4c = dnnl_aBdefC64b4c;
+const format_tag_t aBdeC16c16b2c = dnnl_aBdeC16c16b2c;
+const format_tag_t aBdeC16c16b4c = dnnl_aBdeC16c16b4c;
+const format_tag_t aBdefC16c16b2c = dnnl_aBdefC16c16b2c;
+const format_tag_t aBdefC16c16b4c = dnnl_aBdefC16c16b4c;
+const format_tag_t AcB16b16a2b = dnnl_AcB16b16a2b;
+const format_tag_t AcB16b16a4b = dnnl_AcB16b16a4b;
+const format_tag_t aBdC16c16b2c = dnnl_aBdC16c16b2c;
+const format_tag_t aBdC16c16b4c = dnnl_aBdC16c16b4c;
+const format_tag_t AcdB16b16a2b = dnnl_AcdB16b16a2b;
+const format_tag_t AcdB16b16a4b = dnnl_AcdB16b16a4b;
+const format_tag_t AcdeB16b16a2b = dnnl_AcdeB16b16a2b;
+const format_tag_t AcdeB16b16a4b = dnnl_AcdeB16b16a4b;
+const format_tag_t AcB16b32a2b = dnnl_AcB16b32a2b;
+const format_tag_t AcB16b32a4b = dnnl_AcB16b32a4b;
+const format_tag_t AcB16b48a2b = dnnl_AcB16b48a2b;
+const format_tag_t AcB16b48a4b = dnnl_AcB16b48a4b;
+const format_tag_t AcB16b64a2b = dnnl_AcB16b64a2b;
+const format_tag_t AcB16b64a4b = dnnl_AcB16b64a4b;
+const format_tag_t aBdC16c32b2c = dnnl_aBdC16c32b2c;
+const format_tag_t aBdC16c32b4c = dnnl_aBdC16c32b4c;
+const format_tag_t aBdC16c48b2c = dnnl_aBdC16c48b2c;
+const format_tag_t aBdC16c48b4c = dnnl_aBdC16c48b4c;
+const format_tag_t aBdC16c64b2c = dnnl_aBdC16c64b2c;
+const format_tag_t aBdC16c64b4c = dnnl_aBdC16c64b4c;
+const format_tag_t AcdB16b32a2b = dnnl_AcdB16b32a2b;
+const format_tag_t AcdB16b32a4b = dnnl_AcdB16b32a4b;
+const format_tag_t AcdB16b48a2b = dnnl_AcdB16b48a2b;
+const format_tag_t AcdB16b48a4b = dnnl_AcdB16b48a4b;
+const format_tag_t AcdB16b64a2b = dnnl_AcdB16b64a2b;
+const format_tag_t AcdB16b64a4b = dnnl_AcdB16b64a4b;
+const format_tag_t aBdeC16c32b2c = dnnl_aBdeC16c32b2c;
+const format_tag_t aBdeC16c32b4c = dnnl_aBdeC16c32b4c;
+const format_tag_t aBdeC16c48b2c = dnnl_aBdeC16c48b2c;
+const format_tag_t aBdeC16c48b4c = dnnl_aBdeC16c48b4c;
+const format_tag_t aBdeC16c64b2c = dnnl_aBdeC16c64b2c;
+const format_tag_t aBdeC16c64b4c = dnnl_aBdeC16c64b4c;
+const format_tag_t AcdeB16b32a2b = dnnl_AcdeB16b32a2b;
+const format_tag_t AcdeB16b32a4b = dnnl_AcdeB16b32a4b;
+const format_tag_t AcdeB16b48a2b = dnnl_AcdeB16b48a2b;
+const format_tag_t AcdeB16b48a4b = dnnl_AcdeB16b48a4b;
+const format_tag_t AcdeB16b64a2b = dnnl_AcdeB16b64a2b;
+const format_tag_t AcdeB16b64a4b = dnnl_AcdeB16b64a4b;
+const format_tag_t aBdefC16c32b2c = dnnl_aBdefC16c32b2c;
+const format_tag_t aBdefC16c32b4c = dnnl_aBdefC16c32b4c;
+const format_tag_t aBdefC16c48b2c = dnnl_aBdefC16c48b2c;
+const format_tag_t aBdefC16c48b4c = dnnl_aBdefC16c48b4c;
+const format_tag_t aBdefC16c64b2c = dnnl_aBdefC16c64b2c;
+const format_tag_t aBdefC16c64b4c = dnnl_aBdefC16c64b4c;
+const format_tag_t decbA16a = dnnl_decbA16a;
+const format_tag_t decbA8a = dnnl_decbA8a;
+const format_tag_t defcbA16a = dnnl_defcbA16a;
+const format_tag_t defcbA8a = dnnl_defcbA8a;
+const format_tag_t aCB16c2b = dnnl_aCB16c2b;
+const format_tag_t aCB16c4b = dnnl_aCB16c4b;
+const format_tag_t BA16b2a = dnnl_BA16b2a;
+const format_tag_t BA16b4a = dnnl_BA16b4a;
+const format_tag_t aBC16b16c = dnnl_aBC16b16c;
+const format_tag_t aBC16b32c = dnnl_aBC16b32c;
+const format_tag_t AB16a16b = dnnl_AB16a16b;
+const format_tag_t AB16a32b = dnnl_AB16a32b;
+const format_tag_t ABcd16a32b = dnnl_ABcd16a32b;
+const format_tag_t aCdefB16b32c2b = dnnl_aCdefB16b32c2b;
+const format_tag_t aCdefB16b32c4b = dnnl_aCdefB16b32c4b;
+const format_tag_t aCdefB16b48c2b = dnnl_aCdefB16b48c2b;
+const format_tag_t aCdefB16b48c4b = dnnl_aCdefB16b48c4b;
+const format_tag_t aCdefB16b64c2b = dnnl_aCdefB16b64c2b;
+const format_tag_t aCdefB16b64c4b = dnnl_aCdefB16b64c4b;
+const format_tag_t BcdeA16a32b2a = dnnl_BcdeA16a32b2a;
+const format_tag_t BcdeA16a32b4a = dnnl_BcdeA16a32b4a;
+const format_tag_t BcdeA16a48b2a = dnnl_BcdeA16a48b2a;
+const format_tag_t BcdeA16a48b4a = dnnl_BcdeA16a48b4a;
+const format_tag_t BcdeA16a64b2a = dnnl_BcdeA16a64b2a;
+const format_tag_t BcdeA16a64b4a = dnnl_BcdeA16a64b4a;
+const format_tag_t aCdefb32c = dnnl_aCdefb32c;
+const format_tag_t aCdefB32c2b = dnnl_aCdefB32c2b;
+const format_tag_t aCdefB32c4b = dnnl_aCdefB32c4b;
+const format_tag_t aCdefb48c = dnnl_aCdefb48c;
+const format_tag_t aCdefB48c2b = dnnl_aCdefB48c2b;
+const format_tag_t aCdefB48c4b = dnnl_aCdefB48c4b;
+const format_tag_t aCdefb64c = dnnl_aCdefb64c;
+const format_tag_t aCdefB64c2b = dnnl_aCdefB64c2b;
+const format_tag_t aCdefB64c4b = dnnl_aCdefB64c4b;
+const format_tag_t Bcdea32b = dnnl_Bcdea32b;
+const format_tag_t BcdeA32b2a = dnnl_BcdeA32b2a;
+const format_tag_t BcdeA32b4a = dnnl_BcdeA32b4a;
+const format_tag_t Bcdea48b = dnnl_Bcdea48b;
+const format_tag_t BcdeA48b2a = dnnl_BcdeA48b2a;
+const format_tag_t BcdeA48b4a = dnnl_BcdeA48b4a;
+const format_tag_t Bcdea64b = dnnl_Bcdea64b;
+const format_tag_t BcdeA64b2a = dnnl_BcdeA64b2a;
+const format_tag_t BcdeA64b4a = dnnl_BcdeA64b4a;
+const format_tag_t Bca32b = dnnl_Bca32b;
+const format_tag_t BcA32b2a = dnnl_BcA32b2a;
+const format_tag_t BcA32b4a = dnnl_BcA32b4a;
+const format_tag_t Bca48b = dnnl_Bca48b;
+const format_tag_t BcA48b2a = dnnl_BcA48b2a;
+const format_tag_t BcA48b4a = dnnl_BcA48b4a;
+const format_tag_t Bca64b = dnnl_Bca64b;
+const format_tag_t BcA64b2a = dnnl_BcA64b2a;
+const format_tag_t BcA64b4a = dnnl_BcA64b4a;
+const format_tag_t aCdb32c = dnnl_aCdb32c;
+const format_tag_t aCdB32c2b = dnnl_aCdB32c2b;
+const format_tag_t aCdB32c4b = dnnl_aCdB32c4b;
+const format_tag_t aCdb48c = dnnl_aCdb48c;
+const format_tag_t aCdB48c2b = dnnl_aCdB48c2b;
+const format_tag_t aCdB48c4b = dnnl_aCdB48c4b;
+const format_tag_t aCdb64c = dnnl_aCdb64c;
+const format_tag_t aCdB64c2b = dnnl_aCdB64c2b;
+const format_tag_t aCdB64c4b = dnnl_aCdB64c4b;
+const format_tag_t BcA16a16b2a = dnnl_BcA16a16b2a;
+const format_tag_t BcA16a16b4a = dnnl_BcA16a16b4a;
+const format_tag_t BcdA16a16b2a = dnnl_BcdA16a16b2a;
+const format_tag_t BcdA16a16b4a = dnnl_BcdA16a16b4a;
+const format_tag_t BcdeA16a16b2a = dnnl_BcdeA16a16b2a;
+const format_tag_t BcdeA16a16b4a = dnnl_BcdeA16a16b4a;
+const format_tag_t aCdB16b16c2b = dnnl_aCdB16b16c2b;
+const format_tag_t aCdB16b16c4b = dnnl_aCdB16b16c4b;
+const format_tag_t aCdeB16b16c2b = dnnl_aCdeB16b16c2b;
+const format_tag_t aCdeB16b16c4b = dnnl_aCdeB16b16c4b;
+const format_tag_t aCdefB16b16c2b = dnnl_aCdefB16b16c2b;
+const format_tag_t aCdefB16b16c4b = dnnl_aCdefB16b16c4b;
+const format_tag_t BcA16a32b2a = dnnl_BcA16a32b2a;
+const format_tag_t BcA16a32b4a = dnnl_BcA16a32b4a;
+const format_tag_t BcA16a48b2a = dnnl_BcA16a48b2a;
+const format_tag_t BcA16a48b4a = dnnl_BcA16a48b4a;
+const format_tag_t BcA16a64b2a = dnnl_BcA16a64b2a;
+const format_tag_t BcA16a64b4a = dnnl_BcA16a64b4a;
+const format_tag_t aCdB16b32c2b = dnnl_aCdB16b32c2b;
+const format_tag_t aCdB16b32c4b = dnnl_aCdB16b32c4b;
+const format_tag_t aCdB16b48c2b = dnnl_aCdB16b48c2b;
+const format_tag_t aCdB16b48c4b = dnnl_aCdB16b48c4b;
+const format_tag_t aCdB16b64c2b = dnnl_aCdB16b64c2b;
+const format_tag_t aCdB16b64c4b = dnnl_aCdB16b64c4b;
+const format_tag_t BcdA16a32b2a = dnnl_BcdA16a32b2a;
+const format_tag_t BcdA16a32b4a = dnnl_BcdA16a32b4a;
+const format_tag_t BcdA16a48b2a = dnnl_BcdA16a48b2a;
+const format_tag_t BcdA16a48b4a = dnnl_BcdA16a48b4a;
+const format_tag_t BcdA16a64b2a = dnnl_BcdA16a64b2a;
+const format_tag_t BcdA16a64b4a = dnnl_BcdA16a64b4a;
+const format_tag_t aCdeB16b32c2b = dnnl_aCdeB16b32c2b;
+const format_tag_t aCdeB16b32c4b = dnnl_aCdeB16b32c4b;
+const format_tag_t aCdeB16b48c2b = dnnl_aCdeB16b48c2b;
+const format_tag_t aCdeB16b48c4b = dnnl_aCdeB16b48c4b;
+const format_tag_t aCdeB16b64c2b = dnnl_aCdeB16b64c2b;
+const format_tag_t aCdeB16b64c4b = dnnl_aCdeB16b64c4b;
+const format_tag_t Bca8b = dnnl_Bca8b;
+const format_tag_t BcA8b2a = dnnl_BcA8b2a;
+const format_tag_t BcA8b4a = dnnl_BcA8b4a;
+const format_tag_t Bcda8b = dnnl_Bcda8b;
+const format_tag_t BcdA8b2a = dnnl_BcdA8b2a;
+const format_tag_t BcdA8b4a = dnnl_BcdA8b4a;
+const format_tag_t Bcdea8b = dnnl_Bcdea8b;
+const format_tag_t BcdeA8b2a = dnnl_BcdeA8b2a;
+const format_tag_t BcdeA8b4a = dnnl_BcdeA8b4a;
+const format_tag_t aCdb8c = dnnl_aCdb8c;
+const format_tag_t aCdB8c2b = dnnl_aCdB8c2b;
+const format_tag_t aCdB8c4b = dnnl_aCdB8c4b;
+const format_tag_t aCdeb8c = dnnl_aCdeb8c;
+const format_tag_t aCdeB8c2b = dnnl_aCdeB8c2b;
+const format_tag_t aCdeB8c4b = dnnl_aCdeB8c4b;
+const format_tag_t aCdefb8c = dnnl_aCdefb8c;
+const format_tag_t aCdefB8c2b = dnnl_aCdefB8c2b;
+const format_tag_t aCdefB8c4b = dnnl_aCdefB8c4b;
+const format_tag_t Bca16b = dnnl_Bca16b;
+const format_tag_t BcA16b2a = dnnl_BcA16b2a;
+const format_tag_t BcA16b4a = dnnl_BcA16b4a;
+const format_tag_t Bcda16b = dnnl_Bcda16b;
+const format_tag_t BcdA16b2a = dnnl_BcdA16b2a;
+const format_tag_t BcdA16b4a = dnnl_BcdA16b4a;
+const format_tag_t Bcdea16b = dnnl_Bcdea16b;
+const format_tag_t BcdeA16b2a = dnnl_BcdeA16b2a;
+const format_tag_t BcdeA16b4a = dnnl_BcdeA16b4a;
+const format_tag_t aCdb16c = dnnl_aCdb16c;
+const format_tag_t aCdB16c2b = dnnl_aCdB16c2b;
+const format_tag_t aCdB16c4b = dnnl_aCdB16c4b;
+const format_tag_t aCdeb16c = dnnl_aCdeb16c;
+const format_tag_t aCdeB16c2b = dnnl_aCdeB16c2b;
+const format_tag_t aCdeB16c4b = dnnl_aCdeB16c4b;
+const format_tag_t aCdefb16c = dnnl_aCdefb16c;
+const format_tag_t aCdefB16c2b = dnnl_aCdefB16c2b;
+const format_tag_t aCdefB16c4b = dnnl_aCdefB16c4b;
+const format_tag_t Bca24b = dnnl_Bca24b;
+const format_tag_t BcA24b2a = dnnl_BcA24b2a;
+const format_tag_t BcA24b4a = dnnl_BcA24b4a;
+const format_tag_t Bcda24b = dnnl_Bcda24b;
+const format_tag_t BcdA24b2a = dnnl_BcdA24b2a;
+const format_tag_t BcdA24b4a = dnnl_BcdA24b4a;
+const format_tag_t Bcdea24b = dnnl_Bcdea24b;
+const format_tag_t BcdeA24b2a = dnnl_BcdeA24b2a;
+const format_tag_t BcdeA24b4a = dnnl_BcdeA24b4a;
+const format_tag_t aCdb24c = dnnl_aCdb24c;
+const format_tag_t aCdB24c2b = dnnl_aCdB24c2b;
+const format_tag_t aCdB24c4b = dnnl_aCdB24c4b;
+const format_tag_t aCdeb24c = dnnl_aCdeb24c;
+const format_tag_t aCdeB24c2b = dnnl_aCdeB24c2b;
+const format_tag_t aCdeB24c4b = dnnl_aCdeB24c4b;
+const format_tag_t aCdefb24c = dnnl_aCdefb24c;
+const format_tag_t aCdefB24c2b = dnnl_aCdefB24c2b;
+const format_tag_t aCdefB24c4b = dnnl_aCdefB24c4b;
+const format_tag_t Bcda32b = dnnl_Bcda32b;
+const format_tag_t BcdA32b2a = dnnl_BcdA32b2a;
+const format_tag_t BcdA32b4a = dnnl_BcdA32b4a;
+const format_tag_t Bcda48b = dnnl_Bcda48b;
+const format_tag_t BcdA48b2a = dnnl_BcdA48b2a;
+const format_tag_t BcdA48b4a = dnnl_BcdA48b4a;
+const format_tag_t Bcda64b = dnnl_Bcda64b;
+const format_tag_t BcdA64b2a = dnnl_BcdA64b2a;
+const format_tag_t BcdA64b4a = dnnl_BcdA64b4a;
+const format_tag_t aCdeb32c = dnnl_aCdeb32c;
+const format_tag_t aCdeB32c2b = dnnl_aCdeB32c2b;
+const format_tag_t aCdeB32c4b = dnnl_aCdeB32c4b;
+const format_tag_t aCdeb48c = dnnl_aCdeb48c;
+const format_tag_t aCdeB48c2b = dnnl_aCdeB48c2b;
+const format_tag_t aCdeB48c4b = dnnl_aCdeB48c4b;
+const format_tag_t aCdeb64c = dnnl_aCdeb64c;
+const format_tag_t aCdeB64c2b = dnnl_aCdeB64c2b;
+const format_tag_t aCdeB64c4b = dnnl_aCdeB64c4b;
+const format_tag_t Acb24a = dnnl_Acb24a;
+const format_tag_t Acdb24a = dnnl_Acdb24a;
+const format_tag_t Acdeb24a = dnnl_Acdeb24a;
+const format_tag_t aBdc24b = dnnl_aBdc24b;
+const format_tag_t aBdec24b = dnnl_aBdec24b;
+const format_tag_t aBdefc24b = dnnl_aBdefc24b;
+const format_tag_t AcB24a2b = dnnl_AcB24a2b;
+const format_tag_t AcdB24a2b = dnnl_AcdB24a2b;
+const format_tag_t AcdeB24a2b = dnnl_AcdeB24a2b;
+const format_tag_t aBdC24b2c = dnnl_aBdC24b2c;
+const format_tag_t aBdeC24b2c = dnnl_aBdeC24b2c;
+const format_tag_t aBdefC24b2c = dnnl_aBdefC24b2c;
+const format_tag_t AB8b32a = dnnl_AB8b32a;
+const format_tag_t ABc8b32a = dnnl_ABc8b32a;
+const format_tag_t ABcd8b32a = dnnl_ABcd8b32a;
+const format_tag_t ABcde8b32a = dnnl_ABcde8b32a;
+const format_tag_t AB8b24a = dnnl_AB8b24a;
+const format_tag_t ABc8b24a = dnnl_ABc8b24a;
+const format_tag_t ABcd8b24a = dnnl_ABcd8b24a;
+const format_tag_t ABcde8b24a = dnnl_ABcde8b24a;
+const format_tag_t AB8b16a = dnnl_AB8b16a;
+const format_tag_t ABc8b16a = dnnl_ABc8b16a;
+const format_tag_t ABcd8b16a = dnnl_ABcd8b16a;
+const format_tag_t ABcde8b16a = dnnl_ABcde8b16a;
+const format_tag_t AB8b8a = dnnl_AB8b8a;
+const format_tag_t AcB24a4b = dnnl_AcB24a4b;
+const format_tag_t AcdB24a4b = dnnl_AcdB24a4b;
+const format_tag_t AcdeB24a4b = dnnl_AcdeB24a4b;
+const format_tag_t aBdC24b4c = dnnl_aBdC24b4c;
+const format_tag_t aBdeC24b4c = dnnl_aBdeC24b4c;
+const format_tag_t aBdefC24b4c = dnnl_aBdefC24b4c;
+const format_tag_t AB8b8a2b = dnnl_AB8b8a2b;
+const format_tag_t ABc8b8a2b = dnnl_ABc8b8a2b;
+const format_tag_t ABcd8b8a2b = dnnl_ABcd8b8a2b;
+const format_tag_t ABcde8b8a2b = dnnl_ABcde8b8a2b;
+const format_tag_t AB8b24a2b = dnnl_AB8b24a2b;
+const format_tag_t ABc8b24a2b = dnnl_ABc8b24a2b;
+const format_tag_t ABcd8b24a2b = dnnl_ABcd8b24a2b;
+const format_tag_t ABcde8b24a2b = dnnl_ABcde8b24a2b;
+
+const format_tag_t last = dnnl_format_tag_last;
+
+const format_tag_t x = dnnl_x;
+const format_tag_t nc = dnnl_nc;
+const format_tag_t cn = dnnl_cn;
+const format_tag_t ncw = dnnl_ncw;
+const format_tag_t nwc = dnnl_nwc;
+const format_tag_t nchw = dnnl_nchw;
+const format_tag_t nhwc = dnnl_nhwc;
+const format_tag_t chwn = dnnl_chwn;
+const format_tag_t ncdhw = dnnl_ncdhw;
+const format_tag_t ndhwc = dnnl_ndhwc;
+const format_tag_t oi = dnnl_oi;
+const format_tag_t io = dnnl_io;
+const format_tag_t oiw = dnnl_oiw;
+const format_tag_t wio = dnnl_wio;
+const format_tag_t woi = dnnl_woi;
+const format_tag_t owi = dnnl_owi;
+const format_tag_t iwo = dnnl_iwo;
+const format_tag_t oihw = dnnl_oihw;
+const format_tag_t hwio = dnnl_hwio;
+const format_tag_t hwoi = dnnl_hwoi;
+const format_tag_t ohwi = dnnl_ohwi;
+const format_tag_t ihwo = dnnl_ihwo;
+const format_tag_t iohw = dnnl_iohw;
+const format_tag_t oidhw = dnnl_oidhw;
+const format_tag_t dhwio = dnnl_dhwio;
+const format_tag_t dhwoi = dnnl_dhwoi;
+const format_tag_t odhwi = dnnl_odhwi;
+const format_tag_t idhwo = dnnl_idhwo;
+
+const format_tag_t iodhw = dnnl_iodhw;
+const format_tag_t goiw = dnnl_goiw;
+const format_tag_t goihw = dnnl_goihw;
+const format_tag_t wigo = dnnl_wigo;
+const format_tag_t hwigo = dnnl_hwigo;
+const format_tag_t dhwigo = dnnl_dhwigo;
+const format_tag_t giohw = dnnl_giohw;
+const format_tag_t goidhw = dnnl_goidhw;
+const format_tag_t giodhw = dnnl_giodhw;
+const format_tag_t gowi = dnnl_gowi;
+const format_tag_t gohwi = dnnl_gohwi;
+const format_tag_t godhwi = dnnl_godhwi;
+const format_tag_t tnc = dnnl_tnc;
+const format_tag_t ntc = dnnl_ntc;
+const format_tag_t ldnc = dnnl_ldnc;
+const format_tag_t ldigo = dnnl_ldigo;
+const format_tag_t ldgoi = dnnl_ldgoi;
+const format_tag_t ldio = dnnl_ldio;
+const format_tag_t ldoi = dnnl_ldoi;
+const format_tag_t ldgo = dnnl_ldgo;
+const format_tag_t nCdhw32c = dnnl_nCdhw32c;
+const format_tag_t nCdhw16c = dnnl_nCdhw16c;
+const format_tag_t nCdhw4c = dnnl_nCdhw4c;
+const format_tag_t nCdhw8c = dnnl_nCdhw8c;
+const format_tag_t nChw32c = dnnl_nChw32c;
+const format_tag_t nChw16c = dnnl_nChw16c;
+const format_tag_t nChw4c = dnnl_nChw4c;
+const format_tag_t nChw8c = dnnl_nChw8c;
+const format_tag_t nCw32c = dnnl_nCw32c;
+const format_tag_t nCw16c = dnnl_nCw16c;
+const format_tag_t nCw4c = dnnl_nCw4c;
+const format_tag_t nCw8c = dnnl_nCw8c;
+const format_tag_t NCw16n16c = dnnl_NCw16n16c;
+const format_tag_t NChw16n16c = dnnl_NChw16n16c;
+const format_tag_t NCdhw16n16c = dnnl_NCdhw16n16c;
+const format_tag_t NCw32n16c = dnnl_NCw32n16c;
+const format_tag_t NChw32n16c = dnnl_NChw32n16c;
+const format_tag_t NCdhw32n16c = dnnl_NCdhw32n16c;
+const format_tag_t NCw40n16c = dnnl_NCw40n16c;
+const format_tag_t NChw40n16c = dnnl_NChw40n16c;
+const format_tag_t NCdhw40n16c = dnnl_NCdhw40n16c;
+const format_tag_t NCw32n32c = dnnl_NCw32n32c;
+const format_tag_t NChw32n32c = dnnl_NChw32n32c;
+const format_tag_t NCdhw32n32c = dnnl_NCdhw32n32c;
+const format_tag_t NCw40n32c = dnnl_NCw40n32c;
+const format_tag_t NChw40n32c = dnnl_NChw40n32c;
+const format_tag_t NCdhw40n32c = dnnl_NCdhw40n32c;
+const format_tag_t OI16i16o = dnnl_OI16i16o;
+const format_tag_t OI16i32o = dnnl_OI16i32o;
+const format_tag_t OI16i48o = dnnl_OI16i48o;
+const format_tag_t OI16i64o = dnnl_OI16i64o;
+const format_tag_t OI8i16o2i = dnnl_OI8i16o2i;
+const format_tag_t OI8i32o2i = dnnl_OI8i32o2i;
+const format_tag_t OI8i64o2i = dnnl_OI8i64o2i;
+const format_tag_t OI4i8o4i = dnnl_OI4i8o4i;
+const format_tag_t OI4i16o4i = dnnl_OI4i16o4i;
+const format_tag_t OI4i24o4i = dnnl_OI4i24o4i;
+const format_tag_t OI4i32o4i = dnnl_OI4i32o4i;
+const format_tag_t OI4i64o4i = dnnl_OI4i64o4i;
+const format_tag_t OI16i16o4i = dnnl_OI16i16o4i;
+const format_tag_t OI16i32o4i = dnnl_OI16i32o4i;
+const format_tag_t OI16i48o4i = dnnl_OI16i48o4i;
+const format_tag_t OI16i64o4i = dnnl_OI16i64o4i;
+const format_tag_t OI16i16o2i = dnnl_OI16i16o2i;
+const format_tag_t OI16i32o2i = dnnl_OI16i32o2i;
+const format_tag_t OI16i48o2i = dnnl_OI16i48o2i;
+const format_tag_t OI16i64o2i = dnnl_OI16i64o2i;
+const format_tag_t IOdhw16i16o = dnnl_IOdhw16i16o;
+const format_tag_t IOhw16i16o = dnnl_IOhw16i16o;
+const format_tag_t Ohwi32o = dnnl_Ohwi32o;
+const format_tag_t gIOhw16i16o = dnnl_gIOhw16i16o;
+const format_tag_t gOhwi32o = dnnl_gOhwi32o;
+const format_tag_t Goidhw16g = dnnl_Goidhw16g;
+const format_tag_t IOw16o16i = dnnl_IOw16o16i;
+const format_tag_t IOw16i16o = dnnl_IOw16i16o;
+const format_tag_t gIOw16i16o = dnnl_gIOw16i16o;
+const format_tag_t OIw16i16o = dnnl_OIw16i16o;
+const format_tag_t OIw16i32o = dnnl_OIw16i32o;
+const format_tag_t OIw16i48o = dnnl_OIw16i48o;
+const format_tag_t OIw16i64o = dnnl_OIw16i64o;
+const format_tag_t OIw16o16i = dnnl_OIw16o16i;
+const format_tag_t Oiw16o = dnnl_Oiw16o;
+const format_tag_t OIw4i8o4i = dnnl_OIw4i8o4i;
+const format_tag_t OIw4i16o4i = dnnl_OIw4i16o4i;
+const format_tag_t OIw4i24o4i = dnnl_OIw4i24o4i;
+const format_tag_t OIw4i32o4i = dnnl_OIw4i32o4i;
+const format_tag_t OIw4i64o4i = dnnl_OIw4i64o4i;
+const format_tag_t OIw2i8o4i = dnnl_OIw2i8o4i;
+const format_tag_t OIw16i16o4i = dnnl_OIw16i16o4i;
+const format_tag_t OIw16i32o4i = dnnl_OIw16i32o4i;
+const format_tag_t OIw16i48o4i = dnnl_OIw16i48o4i;
+const format_tag_t OIw16i64o4i = dnnl_OIw16i64o4i;
+const format_tag_t OIw16i16o2i = dnnl_OIw16i16o2i;
+const format_tag_t OIw16i32o2i = dnnl_OIw16i32o2i;
+const format_tag_t OIw16i48o2i = dnnl_OIw16i48o2i;
+const format_tag_t OIw16i64o2i = dnnl_OIw16i64o2i;
+const format_tag_t OIw16o16i2o = dnnl_OIw16o16i2o;
+const format_tag_t OIw4i4o = dnnl_OIw4i4o;
+const format_tag_t OIw4o4i = dnnl_OIw4o4i;
+const format_tag_t Oiw4o = dnnl_Oiw4o;
+const format_tag_t OIw8i16o2i = dnnl_OIw8i16o2i;
+const format_tag_t OIw8i32o2i = dnnl_OIw8i32o2i;
+const format_tag_t OIw8i64o2i = dnnl_OIw8i64o2i;
+const format_tag_t OIw8i8o = dnnl_OIw8i8o;
+const format_tag_t OIw8o16i2o = dnnl_OIw8o16i2o;
+const format_tag_t IOw8o16i2o = dnnl_IOw8o16i2o;
+const format_tag_t OIw8o8i = dnnl_OIw8o8i;
+const format_tag_t OIw8o4i = dnnl_OIw8o4i;
+const format_tag_t Owi16o = dnnl_Owi16o;
+const format_tag_t OwI16o2i = dnnl_OwI16o2i;
+const format_tag_t OwI16o4i = dnnl_OwI16o4i;
+const format_tag_t Owi4o = dnnl_Owi4o;
+const format_tag_t Owi8o = dnnl_Owi8o;
+const format_tag_t OwI8o2i = dnnl_OwI8o2i;
+const format_tag_t OwI8o4i = dnnl_OwI8o4i;
+const format_tag_t IOdhw16o16i = dnnl_IOdhw16o16i;
+const format_tag_t IOhw16o16i = dnnl_IOhw16o16i;
+const format_tag_t Ohwi16o = dnnl_Ohwi16o;
+const format_tag_t OhwI16o2i = dnnl_OhwI16o2i;
+const format_tag_t OhwI16o4i = dnnl_OhwI16o4i;
+const format_tag_t Ohwi4o = dnnl_Ohwi4o;
+const format_tag_t Ohwi8o = dnnl_Ohwi8o;
+const format_tag_t OhwI8o2i = dnnl_OhwI8o2i;
+const format_tag_t OhwI8o4i = dnnl_OhwI8o4i;
+const format_tag_t OIhw16i16o = dnnl_OIhw16i16o;
+const format_tag_t OIhw16i32o = dnnl_OIhw16i32o;
+const format_tag_t OIhw16i48o = dnnl_OIhw16i48o;
+const format_tag_t OIhw16i64o = dnnl_OIhw16i64o;
+const format_tag_t OIhw16o16i = dnnl_OIhw16o16i;
+const format_tag_t Oihw16o = dnnl_Oihw16o;
+const format_tag_t OIhw4i8o4i = dnnl_OIhw4i8o4i;
+const format_tag_t OIhw4i16o4i = dnnl_OIhw4i16o4i;
+const format_tag_t OIhw4i24o4i = dnnl_OIhw4i24o4i;
+const format_tag_t OIhw4i32o4i = dnnl_OIhw4i32o4i;
+const format_tag_t OIhw4i64o4i = dnnl_OIhw4i64o4i;
+const format_tag_t OIhw16i16o4i = dnnl_OIhw16i16o4i;
+const format_tag_t OIhw16i32o4i = dnnl_OIhw16i32o4i;
+const format_tag_t OIhw16i48o4i = dnnl_OIhw16i48o4i;
+const format_tag_t OIhw16i64o4i = dnnl_OIhw16i64o4i;
+const format_tag_t OIhw16i16o2i = dnnl_OIhw16i16o2i;
+const format_tag_t OIhw16i32o2i = dnnl_OIhw16i32o2i;
+const format_tag_t OIhw16i48o2i = dnnl_OIhw16i48o2i;
+const format_tag_t OIhw16i64o2i = dnnl_OIhw16i64o2i;
+const format_tag_t OIhw16o16i2o = dnnl_OIhw16o16i2o;
+const format_tag_t OIhw4i4o = dnnl_OIhw4i4o;
+const format_tag_t OIhw4o4i = dnnl_OIhw4o4i;
+const format_tag_t Oihw4o = dnnl_Oihw4o;
+const format_tag_t OIhw8i16o2i = dnnl_OIhw8i16o2i;
+const format_tag_t OIhw8i32o2i = dnnl_OIhw8i32o2i;
+const format_tag_t OIhw8i64o2i = dnnl_OIhw8i64o2i;
+const format_tag_t OIhw2i8o4i = dnnl_OIhw2i8o4i;
+const format_tag_t OIhw8i8o = dnnl_OIhw8i8o;
+const format_tag_t OIhw8o16i2o = dnnl_OIhw8o16i2o;
+const format_tag_t IOhw8o16i2o = dnnl_IOhw8o16i2o;
+const format_tag_t OIhw8o8i = dnnl_OIhw8o8i;
+const format_tag_t OIhw8o4i = dnnl_OIhw8o4i;
+const format_tag_t Owhi16o = dnnl_Owhi16o;
+const format_tag_t Odwhi16o = dnnl_Odwhi16o;
+const format_tag_t Odhwi16o = dnnl_Odhwi16o;
+const format_tag_t OdhwI16o2i = dnnl_OdhwI16o2i;
+const format_tag_t OdhwI16o4i = dnnl_OdhwI16o4i;
+const format_tag_t Odhwi4o = dnnl_Odhwi4o;
+const format_tag_t Odhwi8o = dnnl_Odhwi8o;
+const format_tag_t OdhwI8o2i = dnnl_OdhwI8o2i;
+const format_tag_t OdhwI8o4i = dnnl_OdhwI8o4i;
+const format_tag_t OIdhw16i16o = dnnl_OIdhw16i16o;
+const format_tag_t OIdhw16i32o = dnnl_OIdhw16i32o;
+const format_tag_t OIdhw16i48o = dnnl_OIdhw16i48o;
+const format_tag_t OIdhw16i64o = dnnl_OIdhw16i64o;
+const format_tag_t OIdhw16o16i = dnnl_OIdhw16o16i;
+const format_tag_t OIdhw16o16i2o = dnnl_OIdhw16o16i2o;
+const format_tag_t Oidhw16o = dnnl_Oidhw16o;
+const format_tag_t OIdhw4i4o = dnnl_OIdhw4i4o;
+const format_tag_t OIdhw4o4i = dnnl_OIdhw4o4i;
+const format_tag_t Oidhw4o = dnnl_Oidhw4o;
+const format_tag_t OIdhw8i16o2i = dnnl_OIdhw8i16o2i;
+const format_tag_t OIdhw8i32o2i = dnnl_OIdhw8i32o2i;
+const format_tag_t OIdhw8i64o2i = dnnl_OIdhw8i64o2i;
+const format_tag_t OIdhw4i8o4i = dnnl_OIdhw4i8o4i;
+const format_tag_t OIdhw4i16o4i = dnnl_OIdhw4i16o4i;
+const format_tag_t OIdhw4i24o4i = dnnl_OIdhw4i24o4i;
+const format_tag_t OIdhw4i32o4i = dnnl_OIdhw4i32o4i;
+const format_tag_t OIdhw4i64o4i = dnnl_OIdhw4i64o4i;
+const format_tag_t OIdhw16i16o4i = dnnl_OIdhw16i16o4i;
+const format_tag_t OIdhw16i32o4i = dnnl_OIdhw16i32o4i;
+const format_tag_t OIdhw16i48o4i = dnnl_OIdhw16i48o4i;
+const format_tag_t OIdhw16i64o4i = dnnl_OIdhw16i64o4i;
+const format_tag_t OIdhw16i16o2i = dnnl_OIdhw16i16o2i;
+const format_tag_t OIdhw16i32o2i = dnnl_OIdhw16i32o2i;
+const format_tag_t OIdhw16i48o2i = dnnl_OIdhw16i48o2i;
+const format_tag_t OIdhw16i64o2i = dnnl_OIdhw16i64o2i;
+const format_tag_t OIdhw2i8o4i = dnnl_OIdhw2i8o4i;
+const format_tag_t OIdhw8o16i2o = dnnl_OIdhw8o16i2o;
+const format_tag_t IOdhw8o16i2o = dnnl_IOdhw8o16i2o;
+const format_tag_t OIdhw8i8o = dnnl_OIdhw8i8o;
+const format_tag_t OIdhw8o8i = dnnl_OIdhw8o8i;
+const format_tag_t OIdhw8o4i = dnnl_OIdhw8o4i;
+const format_tag_t gIOw16o16i = dnnl_gIOw16o16i;
+const format_tag_t Goiw16g = dnnl_Goiw16g;
+const format_tag_t Goiw8g = dnnl_Goiw8g;
+const format_tag_t Goiw4g = dnnl_Goiw4g;
+const format_tag_t gOIw16i16o = dnnl_gOIw16i16o;
+const format_tag_t gOIw16o16i = dnnl_gOIw16o16i;
+const format_tag_t gOiw16o = dnnl_gOiw16o;
+const format_tag_t gOIw4i16o4i = dnnl_gOIw4i16o4i;
+const format_tag_t gOIw2i8o4i = dnnl_gOIw2i8o4i;
+const format_tag_t gOIw16i16o4i = dnnl_gOIw16i16o4i;
+const format_tag_t gOIw16i16o2i = dnnl_gOIw16i16o2i;
+const format_tag_t gOIw16o16i2o = dnnl_gOIw16o16i2o;
+const format_tag_t gOIw4i4o = dnnl_gOIw4i4o;
+const format_tag_t gOIw4o4i = dnnl_gOIw4o4i;
+const format_tag_t gOiw4o = dnnl_gOiw4o;
+const format_tag_t gOIw8i16o2i = dnnl_gOIw8i16o2i;
+const format_tag_t gOIw8i8o = dnnl_gOIw8i8o;
+const format_tag_t gOIw8o16i2o = dnnl_gOIw8o16i2o;
+const format_tag_t gIOw8o16i2o = dnnl_gIOw8o16i2o;
+const format_tag_t gOIw8o8i = dnnl_gOIw8o8i;
+const format_tag_t gOIw8o4i = dnnl_gOIw8o4i;
+const format_tag_t gOwi16o = dnnl_gOwi16o;
+const format_tag_t gOwI16o2i = dnnl_gOwI16o2i;
+const format_tag_t gOwI16o4i = dnnl_gOwI16o4i;
+const format_tag_t gOwi4o = dnnl_gOwi4o;
+const format_tag_t gOwi8o = dnnl_gOwi8o;
+const format_tag_t gOwI8o2i = dnnl_gOwI8o2i;
+const format_tag_t gOwI8o4i = dnnl_gOwI8o4i;
+const format_tag_t gIOdhw16o16i = dnnl_gIOdhw16o16i;
+const format_tag_t gIOhw16o16i = dnnl_gIOhw16o16i;
+const format_tag_t gOhwi16o = dnnl_gOhwi16o;
+const format_tag_t gOhwI16o2i = dnnl_gOhwI16o2i;
+const format_tag_t gOhwI16o4i = dnnl_gOhwI16o4i;
+const format_tag_t gOhwi4o = dnnl_gOhwi4o;
+const format_tag_t gOhwi8o = dnnl_gOhwi8o;
+const format_tag_t gOhwI8o2i = dnnl_gOhwI8o2i;
+const format_tag_t gOhwI8o4i = dnnl_gOhwI8o4i;
+const format_tag_t Goihw16g = dnnl_Goihw16g;
+const format_tag_t gOIhw16i16o = dnnl_gOIhw16i16o;
+const format_tag_t gOIhw16o16i = dnnl_gOIhw16o16i;
+const format_tag_t gOihw16o = dnnl_gOihw16o;
+const format_tag_t gOIhw2i8o4i = dnnl_gOIhw2i8o4i;
+const format_tag_t gOIhw4i16o4i = dnnl_gOIhw4i16o4i;
+const format_tag_t gOIhw16i16o4i = dnnl_gOIhw16i16o4i;
+const format_tag_t gOIhw16i16o2i = dnnl_gOIhw16i16o2i;
+const format_tag_t gOIhw16o16i2o = dnnl_gOIhw16o16i2o;
+const format_tag_t gOIhw4i4o = dnnl_gOIhw4i4o;
+const format_tag_t gOIhw4o4i = dnnl_gOIhw4o4i;
+const format_tag_t gOihw4o = dnnl_gOihw4o;
+const format_tag_t Goihw8g = dnnl_Goihw8g;
+const format_tag_t Goihw4g = dnnl_Goihw4g;
+const format_tag_t gOIhw8i16o2i = dnnl_gOIhw8i16o2i;
+const format_tag_t gOIhw8i8o = dnnl_gOIhw8i8o;
+const format_tag_t gOIhw8o16i2o = dnnl_gOIhw8o16i2o;
+const format_tag_t OIw4o8i8o4i = dnnl_OIw4o8i8o4i;
+const format_tag_t gIOhw8o16i2o = dnnl_gIOhw8o16i2o;
+const format_tag_t OIhw4o8i8o4i = dnnl_OIhw4o8i8o4i;
+const format_tag_t OIdhw4o8i8o4i = dnnl_OIdhw4o8i8o4i;
+const format_tag_t IOw4i8o8i4o = dnnl_IOw4i8o8i4o;
+const format_tag_t IOhw4i8o8i4o = dnnl_IOhw4i8o8i4o;
+const format_tag_t IOdhw4i8o8i4o = dnnl_IOdhw4i8o8i4o;
+const format_tag_t gIOw4i8o8i4o = dnnl_gIOw4i8o8i4o;
+const format_tag_t gIOhw4i8o8i4o = dnnl_gIOhw4i8o8i4o;
+const format_tag_t gIOdhw4i8o8i4o = dnnl_gIOdhw4i8o8i4o;
+const format_tag_t OIhw2o8i8o2i = dnnl_OIhw2o8i8o2i;
+const format_tag_t gOIw4o8i8o4i = dnnl_gOIw4o8i8o4i;
+const format_tag_t gOIhw4o8i8o4i = dnnl_gOIhw4o8i8o4i;
+const format_tag_t gOIdhw4o8i8o4i = dnnl_gOIdhw4o8i8o4i;
+const format_tag_t gOIhw2o8i8o2i = dnnl_gOIhw2o8i8o2i;
+const format_tag_t gOIhw8o8i = dnnl_gOIhw8o8i;
+const format_tag_t gOIhw8o4i = dnnl_gOIhw8o4i;
+const format_tag_t gOwhi16o = dnnl_gOwhi16o;
+const format_tag_t gOdwhi16o = dnnl_gOdwhi16o;
+const format_tag_t gIOdhw16i16o = dnnl_gIOdhw16i16o;
+const format_tag_t gOdhwi16o = dnnl_gOdhwi16o;
+const format_tag_t gOdhwI16o2i = dnnl_gOdhwI16o2i;
+const format_tag_t gOdhwI16o4i = dnnl_gOdhwI16o4i;
+const format_tag_t gOdhwi4o = dnnl_gOdhwi4o;
+const format_tag_t gOdhwi8o = dnnl_gOdhwi8o;
+const format_tag_t gOdhwI8o2i = dnnl_gOdhwI8o2i;
+const format_tag_t gOdhwI8o4i = dnnl_gOdhwI8o4i;
+const format_tag_t gOIdhw16i16o = dnnl_gOIdhw16i16o;
+const format_tag_t gOIdhw16o16i = dnnl_gOIdhw16o16i;
+const format_tag_t gOIdhw16o16i2o = dnnl_gOIdhw16o16i2o;
+const format_tag_t gOidhw16o = dnnl_gOidhw16o;
+const format_tag_t gOIdhw4i4o = dnnl_gOIdhw4i4o;
+const format_tag_t gOIdhw4o4i = dnnl_gOIdhw4o4i;
+const format_tag_t gOidhw4o = dnnl_gOidhw4o;
+const format_tag_t gOIdhw8i16o2i = dnnl_gOIdhw8i16o2i;
+const format_tag_t gOIdhw4i16o4i = dnnl_gOIdhw4i16o4i;
+const format_tag_t gOIdhw16i16o4i = dnnl_gOIdhw16i16o4i;
+const format_tag_t gOIdhw2i8o4i = dnnl_gOIdhw2i8o4i;
+const format_tag_t gOIdhw16i16o2i = dnnl_gOIdhw16i16o2i;
+const format_tag_t gOIdhw8o16i2o = dnnl_gOIdhw8o16i2o;
+const format_tag_t gIOdhw8o16i2o = dnnl_gIOdhw8o16i2o;
+const format_tag_t gOIdhw8i8o = dnnl_gOIdhw8i8o;
+const format_tag_t gOIdhw8o8i = dnnl_gOIdhw8o8i;
+const format_tag_t gOIdhw8o4i = dnnl_gOIdhw8o4i;
+const format_tag_t Goiw32g = dnnl_Goiw32g;
+const format_tag_t Goihw32g = dnnl_Goihw32g;
+const format_tag_t Goidhw32g = dnnl_Goidhw32g;
+const format_tag_t OIdhw4o8i8o2i = dnnl_OIdhw4o8i8o2i;
+const format_tag_t OIhw4o8i8o2i = dnnl_OIhw4o8i8o2i;
+const format_tag_t OIw4o8i8o2i = dnnl_OIw4o8i8o2i;
+const format_tag_t gOIdhw4o8i8o2i = dnnl_gOIdhw4o8i8o2i;
+const format_tag_t gOIhw4o8i8o2i = dnnl_gOIhw4o8i8o2i;
+const format_tag_t gOIw4o8i8o2i = dnnl_gOIw4o8i8o2i;
+const format_tag_t IOdhw4i8o8i2o = dnnl_IOdhw4i8o8i2o;
+const format_tag_t IOhw4i8o8i2o = dnnl_IOhw4i8o8i2o;
+const format_tag_t IOw4i8o8i2o = dnnl_IOw4i8o8i2o;
+const format_tag_t gIOdhw4i8o8i2o = dnnl_gIOdhw4i8o8i2o;
+const format_tag_t gIOhw4i8o8i2o = dnnl_gIOhw4i8o8i2o;
+const format_tag_t gIOw4i8o8i2o = dnnl_gIOw4i8o8i2o;
+const format_tag_t gOIw2i4o2i = dnnl_gOIw2i4o2i;
+const format_tag_t gOIhw2i4o2i = dnnl_gOIhw2i4o2i;
+const format_tag_t gOIdhw2i4o2i = dnnl_gOIdhw2i4o2i;
+const format_tag_t gOIw2o4i2o = dnnl_gOIw2o4i2o;
+const format_tag_t gOIhw2o4i2o = dnnl_gOIhw2o4i2o;
+const format_tag_t gOIdhw2o4i2o = dnnl_gOIdhw2o4i2o;
+const format_tag_t gOIw4i8o2i = dnnl_gOIw4i8o2i;
+const format_tag_t gOIhw4i8o2i = dnnl_gOIhw4i8o2i;
+const format_tag_t gOIdhw4i8o2i = dnnl_gOIdhw4i8o2i;
+const format_tag_t gOIw4o8i2o = dnnl_gOIw4o8i2o;
+const format_tag_t gOIhw4o8i2o = dnnl_gOIhw4o8i2o;
+const format_tag_t gOIdhw4o8i2o = dnnl_gOIdhw4o8i2o;
+const format_tag_t ldOi16o = dnnl_ldOi16o;
+const format_tag_t ldOi32o = dnnl_ldOi32o;
+const format_tag_t ldOI32o4i = dnnl_ldOI32o4i;
+const format_tag_t ldIo32i = dnnl_ldIo32i;
+const format_tag_t ldgOi16o = dnnl_ldgOi16o;
+const format_tag_t ldgOi32o = dnnl_ldgOi32o;
+const format_tag_t ldgOI32o2i = dnnl_ldgOI32o2i;
+const format_tag_t ldgOI32o4i = dnnl_ldgOI32o4i;
+const format_tag_t ldgOI64o2i = dnnl_ldgOI64o2i;
+const format_tag_t ldgOI64o4i = dnnl_ldgOI64o4i;
+const format_tag_t ldgIo16i = dnnl_ldgIo16i;
+const format_tag_t ldgIo32i = dnnl_ldgIo32i;
+const format_tag_t ldgIO32i2o = dnnl_ldgIO32i2o;
+
+const format_tag_t wIo2i = dnnl_wIo2i;
+const format_tag_t wIo4i = dnnl_wIo4i;
+const format_tag_t gwio = dnnl_gwio;
+const format_tag_t gwIo2i = dnnl_gwIo2i;
+const format_tag_t gwIo4i = dnnl_gwIo4i;
+const format_tag_t hwIo2i = dnnl_hwIo2i;
+const format_tag_t hwIo4i = dnnl_hwIo4i;
+const format_tag_t ghwio = dnnl_ghwio;
+const format_tag_t ghwIo2i = dnnl_ghwIo2i;
+const format_tag_t ghwIo4i = dnnl_ghwIo4i;
+const format_tag_t dhwIo2i = dnnl_dhwIo2i;
+const format_tag_t dhwIo4i = dnnl_dhwIo4i;
+const format_tag_t gdhwio = dnnl_gdhwio;
+const format_tag_t gdhwIo2i = dnnl_gdhwIo2i;
+const format_tag_t gdhwIo4i = dnnl_gdhwIo4i;
+const format_tag_t Owi32o = dnnl_Owi32o;
+const format_tag_t OwI32o2i = dnnl_OwI32o2i;
+const format_tag_t OwI32o4i = dnnl_OwI32o4i;
+const format_tag_t Owi48o = dnnl_Owi48o;
+const format_tag_t OwI48o2i = dnnl_OwI48o2i;
+const format_tag_t OwI48o4i = dnnl_OwI48o4i;
+const format_tag_t Owi64o = dnnl_Owi64o;
+const format_tag_t OwI64o2i = dnnl_OwI64o2i;
+const format_tag_t OwI64o4i = dnnl_OwI64o4i;
+const format_tag_t OhwI32o2i = dnnl_OhwI32o2i;
+const format_tag_t OhwI32o4i = dnnl_OhwI32o4i;
+const format_tag_t Ohwi48o = dnnl_Ohwi48o;
+const format_tag_t OhwI48o2i = dnnl_OhwI48o2i;
+const format_tag_t OhwI48o4i = dnnl_OhwI48o4i;
+const format_tag_t Ohwi64o = dnnl_Ohwi64o;
+const format_tag_t OhwI64o2i = dnnl_OhwI64o2i;
+const format_tag_t OhwI64o4i = dnnl_OhwI64o4i;
+const format_tag_t Odhwi32o = dnnl_Odhwi32o;
+const format_tag_t OdhwI32o2i = dnnl_OdhwI32o2i;
+const format_tag_t OdhwI32o4i = dnnl_OdhwI32o4i;
+const format_tag_t Odhwi48o = dnnl_Odhwi48o;
+const format_tag_t OdhwI48o2i = dnnl_OdhwI48o2i;
+const format_tag_t OdhwI48o4i = dnnl_OdhwI48o4i;
+const format_tag_t Odhwi64o = dnnl_Odhwi64o;
+const format_tag_t OdhwI64o2i = dnnl_OdhwI64o2i;
+const format_tag_t OdhwI64o4i = dnnl_OdhwI64o4i;
+const format_tag_t gOwi32o = dnnl_gOwi32o;
+const format_tag_t gOwI32o2i = dnnl_gOwI32o2i;
+const format_tag_t gOwI32o4i = dnnl_gOwI32o4i;
+const format_tag_t gOwi48o = dnnl_gOwi48o;
+const format_tag_t gOwI48o2i = dnnl_gOwI48o2i;
+const format_tag_t gOwI48o4i = dnnl_gOwI48o4i;
+const format_tag_t gOwi64o = dnnl_gOwi64o;
+const format_tag_t gOwI64o2i = dnnl_gOwI64o2i;
+const format_tag_t gOwI64o4i = dnnl_gOwI64o4i;
+const format_tag_t gOhwI32o2i = dnnl_gOhwI32o2i;
+const format_tag_t gOhwI32o4i = dnnl_gOhwI32o4i;
+const format_tag_t gOhwi48o = dnnl_gOhwi48o;
+const format_tag_t gOhwI48o2i = dnnl_gOhwI48o2i;
+const format_tag_t gOhwI48o4i = dnnl_gOhwI48o4i;
+const format_tag_t gOhwi64o = dnnl_gOhwi64o;
+const format_tag_t gOhwI64o2i = dnnl_gOhwI64o2i;
+const format_tag_t gOhwI64o4i = dnnl_gOhwI64o4i;
+const format_tag_t gOdhwi32o = dnnl_gOdhwi32o;
+const format_tag_t gOdhwI32o2i = dnnl_gOdhwI32o2i;
+const format_tag_t gOdhwI32o4i = dnnl_gOdhwI32o4i;
+const format_tag_t gOdhwi48o = dnnl_gOdhwi48o;
+const format_tag_t gOdhwI48o2i = dnnl_gOdhwI48o2i;
+const format_tag_t gOdhwI48o4i = dnnl_gOdhwI48o4i;
+const format_tag_t gOdhwi64o = dnnl_gOdhwi64o;
+const format_tag_t gOdhwI64o2i = dnnl_gOdhwI64o2i;
+const format_tag_t gOdhwI64o4i = dnnl_gOdhwI64o4i;
+const format_tag_t ABc2b8a16b4a = dnnl_ABc2b8a16b4a;
+const format_tag_t ABcd2b8a16b4a = dnnl_ABcd2b8a16b4a;
+const format_tag_t ABcde2b8a16b4a = dnnl_ABcde2b8a16b4a;
+const format_tag_t ABc2a8b16a4b = dnnl_ABc2a8b16a4b;
+const format_tag_t ABcd2a8b16a4b = dnnl_ABcd2a8b16a4b;
+const format_tag_t ABcde2a8b16a4b = dnnl_ABcde2a8b16a4b;
+const format_tag_t ABc2a8b16a2b = dnnl_ABc2a8b16a2b;
+const format_tag_t ABcd2a8b16a2b = dnnl_ABcd2a8b16a2b;
+const format_tag_t ABcde2a8b16a2b = dnnl_ABcde2a8b16a2b;
+const format_tag_t aBCd2b8c16b2c = dnnl_aBCd2b8c16b2c;
+const format_tag_t aBCde2b8c16b2c = dnnl_aBCde2b8c16b2c;
+const format_tag_t aBCdef2b8c16b2c = dnnl_aBCdef2b8c16b2c;
+const format_tag_t aBCd2b8c16b4c = dnnl_aBCd2b8c16b4c;
+const format_tag_t aBCde2b8c16b4c = dnnl_aBCde2b8c16b4c;
+const format_tag_t BAc2b8a16b2a = dnnl_BAc2b8a16b2a;
+const format_tag_t aBCde2c8b16c2b = dnnl_aBCde2c8b16c2b;
+const format_tag_t aBCdef2c8b16c2b = dnnl_aBCdef2c8b16c2b;
+const format_tag_t BAcd2b8a16b2a = dnnl_BAcd2b8a16b2a;
+const format_tag_t BAcde2b8a16b2a = dnnl_BAcde2b8a16b2a;
+const format_tag_t aCBd2c8b16c2b = dnnl_aCBd2c8b16c2b;
+const format_tag_t aCBde2c8b16c2b = dnnl_aCBde2c8b16c2b;
+const format_tag_t aCBdef2c8b16c2b = dnnl_aCBdef2c8b16c2b;
+const format_tag_t BAc2b8a16b4a = dnnl_BAc2b8a16b4a;
+const format_tag_t BAcd2b8a16b4a = dnnl_BAcd2b8a16b4a;
+const format_tag_t BAcde2b8a16b4a = dnnl_BAcde2b8a16b4a;
+const format_tag_t ABc2b32a8b = dnnl_ABc2b32a8b;
+const format_tag_t ABcd2b32a8b = dnnl_ABcd2b32a8b;
+const format_tag_t ABcde2b32a8b = dnnl_ABcde2b32a8b;
+const format_tag_t aBC2b8c16b2c = dnnl_aBC2b8c16b2c;
+const format_tag_t ABc16a4b = dnnl_ABc16a4b;
+const format_tag_t ABcd16a4b = dnnl_ABcd16a4b;
+const format_tag_t ABcde16a4b = dnnl_ABcde16a4b;
+const format_tag_t NCw2c32n8c = dnnl_NCw2c32n8c;
+const format_tag_t NChw2c32n8c = dnnl_NChw2c32n8c;
+const format_tag_t NCdhw2c32n8c = dnnl_NCdhw2c32n8c;
+const format_tag_t OIw2i8o16i4o = dnnl_OIw2i8o16i4o;
+const format_tag_t OIhw2i8o16i4o = dnnl_OIhw2i8o16i4o;
+const format_tag_t OIdhw2i8o16i4o = dnnl_OIdhw2i8o16i4o;
+const format_tag_t OIw2o8i16o4i = dnnl_OIw2o8i16o4i;
+const format_tag_t OIhw2o8i16o4i = dnnl_OIhw2o8i16o4i;
+const format_tag_t OIdhw2o8i16o4i = dnnl_OIdhw2o8i16o4i;
+const format_tag_t OIw2o8i16o2i = dnnl_OIw2o8i16o2i;
+const format_tag_t OIhw2o8i16o2i = dnnl_OIhw2o8i16o2i;
+const format_tag_t OIdhw2o8i16o2i = dnnl_OIdhw2o8i16o2i;
+const format_tag_t IOw2i8o16i4o = dnnl_IOw2i8o16i4o;
+const format_tag_t IOhw2i8o16i4o = dnnl_IOhw2i8o16i4o;
+const format_tag_t IOdhw2i8o16i4o = dnnl_IOdhw2i8o16i4o;
+const format_tag_t IOw2i8o16i2o = dnnl_IOw2i8o16i2o;
+const format_tag_t IOhw2i8o16i2o = dnnl_IOhw2i8o16i2o;
+const format_tag_t IOdhw2i8o16i2o = dnnl_IOdhw2i8o16i2o;
+const format_tag_t gOIw2o8i16o2i = dnnl_gOIw2o8i16o2i;
+const format_tag_t gOIhw2o8i16o2i = dnnl_gOIhw2o8i16o2i;
+const format_tag_t gOIdhw2o8i16o2i = dnnl_gOIdhw2o8i16o2i;
+const format_tag_t gOIw2o8i16o4i = dnnl_gOIw2o8i16o4i;
+const format_tag_t gOIhw2o8i16o4i = dnnl_gOIhw2o8i16o4i;
+const format_tag_t gIOw2i8o16i2o = dnnl_gIOw2i8o16i2o;
+const format_tag_t gIOhw2i8o16i2o = dnnl_gIOhw2i8o16i2o;
+const format_tag_t gIOdhw2i8o16i2o = dnnl_gIOdhw2i8o16i2o;
+const format_tag_t OwI16i16o2i = dnnl_OwI16i16o2i;
+const format_tag_t OwI16i16o4i = dnnl_OwI16i16o4i;
+const format_tag_t OhwI16i16o2i = dnnl_OhwI16i16o2i;
+const format_tag_t OhwI16i16o4i = dnnl_OhwI16i16o4i;
+const format_tag_t OdhwI16i16o2i = dnnl_OdhwI16i16o2i;
+const format_tag_t OdhwI16i16o4i = dnnl_OdhwI16i16o4i;
+const format_tag_t gOwI16i16o2i = dnnl_gOwI16i16o2i;
+const format_tag_t gOwI16i16o4i = dnnl_gOwI16i16o4i;
+const format_tag_t gOhwI16i16o2i = dnnl_gOhwI16i16o2i;
+const format_tag_t gOhwI16i16o4i = dnnl_gOhwI16i16o4i;
+const format_tag_t gOdhwI16i16o2i = dnnl_gOdhwI16i16o2i;
+const format_tag_t gOdhwI16i16o4i = dnnl_gOdhwI16i16o4i;
+const format_tag_t OwI16i32o2i = dnnl_OwI16i32o2i;
+const format_tag_t OwI16i32o4i = dnnl_OwI16i32o4i;
+const format_tag_t OwI16i48o2i = dnnl_OwI16i48o2i;
+const format_tag_t OwI16i48o4i = dnnl_OwI16i48o4i;
+const format_tag_t OwI16i64o2i = dnnl_OwI16i64o2i;
+const format_tag_t OwI16i64o4i = dnnl_OwI16i64o4i;
+const format_tag_t OhwI16i32o2i = dnnl_OhwI16i32o2i;
+const format_tag_t OhwI16i32o4i = dnnl_OhwI16i32o4i;
+const format_tag_t OhwI16i48o2i = dnnl_OhwI16i48o2i;
+const format_tag_t OhwI16i48o4i = dnnl_OhwI16i48o4i;
+const format_tag_t OhwI16i64o2i = dnnl_OhwI16i64o2i;
+const format_tag_t OhwI16i64o4i = dnnl_OhwI16i64o4i;
+const format_tag_t OdhwI16i32o2i = dnnl_OdhwI16i32o2i;
+const format_tag_t OdhwI16i32o4i = dnnl_OdhwI16i32o4i;
+const format_tag_t OdhwI16i48o2i = dnnl_OdhwI16i48o2i;
+const format_tag_t OdhwI16i48o4i = dnnl_OdhwI16i48o4i;
+const format_tag_t OdhwI16i64o2i = dnnl_OdhwI16i64o2i;
+const format_tag_t OdhwI16i64o4i = dnnl_OdhwI16i64o4i;
+const format_tag_t IdhwO16o32i2o = dnnl_IdhwO16o32i2o;
+const format_tag_t IdhwO16o32i4o = dnnl_IdhwO16o32i4o;
+const format_tag_t IdhwO16o48i2o = dnnl_IdhwO16o48i2o;
+const format_tag_t IdhwO16o48i4o = dnnl_IdhwO16o48i4o;
+const format_tag_t IdhwO16o64i2o = dnnl_IdhwO16o64i2o;
+const format_tag_t IdhwO16o64i4o = dnnl_IdhwO16o64i4o;
+const format_tag_t gOwI16i32o2i = dnnl_gOwI16i32o2i;
+const format_tag_t gOwI16i32o4i = dnnl_gOwI16i32o4i;
+const format_tag_t gOwI16i48o2i = dnnl_gOwI16i48o2i;
+const format_tag_t gOwI16i48o4i = dnnl_gOwI16i48o4i;
+const format_tag_t gOwI16i64o2i = dnnl_gOwI16i64o2i;
+const format_tag_t gOwI16i64o4i = dnnl_gOwI16i64o4i;
+const format_tag_t gOhwI16i32o2i = dnnl_gOhwI16i32o2i;
+const format_tag_t gOhwI16i32o4i = dnnl_gOhwI16i32o4i;
+const format_tag_t gOhwI16i48o2i = dnnl_gOhwI16i48o2i;
+const format_tag_t gOhwI16i48o4i = dnnl_gOhwI16i48o4i;
+const format_tag_t gOhwI16i64o2i = dnnl_gOhwI16i64o2i;
+const format_tag_t gOhwI16i64o4i = dnnl_gOhwI16i64o4i;
+const format_tag_t gOdhwI16i32o2i = dnnl_gOdhwI16i32o2i;
+const format_tag_t gOdhwI16i32o4i = dnnl_gOdhwI16i32o4i;
+const format_tag_t gOdhwI16i48o2i = dnnl_gOdhwI16i48o2i;
+const format_tag_t gOdhwI16i48o4i = dnnl_gOdhwI16i48o4i;
+const format_tag_t gOdhwI16i64o2i = dnnl_gOdhwI16i64o2i;
+const format_tag_t gOdhwI16i64o4i = dnnl_gOdhwI16i64o4i;
+const format_tag_t gIdhwO16o32i2o = dnnl_gIdhwO16o32i2o;
+const format_tag_t gIdhwO16o32i4o = dnnl_gIdhwO16o32i4o;
+const format_tag_t gIdhwO16o48i2o = dnnl_gIdhwO16o48i2o;
+const format_tag_t gIdhwO16o48i4o = dnnl_gIdhwO16o48i4o;
+const format_tag_t gIdhwO16o64i2o = dnnl_gIdhwO16o64i2o;
+const format_tag_t gIdhwO16o64i4o = dnnl_gIdhwO16o64i4o;
+
+const format_tag_t Idhwo32i = dnnl_Idhwo32i;
+const format_tag_t IdhwO32i2o = dnnl_IdhwO32i2o;
+const format_tag_t IdhwO32i4o = dnnl_IdhwO32i4o;
+const format_tag_t Idhwo48i = dnnl_Idhwo48i;
+const format_tag_t IdhwO48i2o = dnnl_IdhwO48i2o;
+const format_tag_t IdhwO48i4o = dnnl_IdhwO48i4o;
+const format_tag_t Idhwo64i = dnnl_Idhwo64i;
+const format_tag_t IdhwO64i2o = dnnl_IdhwO64i2o;
+const format_tag_t IdhwO64i4o = dnnl_IdhwO64i4o;
+
+const format_tag_t gIdhwo32i = dnnl_gIdhwo32i;
+const format_tag_t gIdhwO32i2o = dnnl_gIdhwO32i2o;
+const format_tag_t gIdhwO32i4o = dnnl_gIdhwO32i4o;
+const format_tag_t gIdhwo48i = dnnl_gIdhwo48i;
+const format_tag_t gIdhwO48i2o = dnnl_gIdhwO48i2o;
+const format_tag_t gIdhwO48i4o = dnnl_gIdhwO48i4o;
+const format_tag_t gIdhwo64i = dnnl_gIdhwo64i;
+const format_tag_t gIdhwO64i2o = dnnl_gIdhwO64i2o;
+const format_tag_t gIdhwO64i4o = dnnl_gIdhwO64i4o;
+
+const format_tag_t Iwo32i = dnnl_Iwo32i;
+const format_tag_t IwO32i2o = dnnl_IwO32i2o;
+const format_tag_t IwO32i4o = dnnl_IwO32i4o;
+const format_tag_t Iwo48i = dnnl_Iwo48i;
+const format_tag_t IwO48i2o = dnnl_IwO48i2o;
+const format_tag_t IwO48i4o = dnnl_IwO48i4o;
+const format_tag_t Iwo64i = dnnl_Iwo64i;
+const format_tag_t IwO64i2o = dnnl_IwO64i2o;
+const format_tag_t IwO64i4o = dnnl_IwO64i4o;
+
+const format_tag_t gIwo32i = dnnl_gIwo32i;
+const format_tag_t gIwO32i2o = dnnl_gIwO32i2o;
+const format_tag_t gIwO32i4o = dnnl_gIwO32i4o;
+const format_tag_t gIwo48i = dnnl_gIwo48i;
+const format_tag_t gIwO48i2o = dnnl_gIwO48i2o;
+const format_tag_t gIwO48i4o = dnnl_gIwO48i4o;
+const format_tag_t gIwo64i = dnnl_gIwo64i;
+const format_tag_t gIwO64i2o = dnnl_gIwO64i2o;
+const format_tag_t gIwO64i4o = dnnl_gIwO64i4o;
+
+const format_tag_t IwO16o16i2o = dnnl_IwO16o16i2o;
+const format_tag_t IwO16o16i4o = dnnl_IwO16o16i4o;
+const format_tag_t IhwO16o16i2o = dnnl_IhwO16o16i2o;
+const format_tag_t IhwO16o16i4o = dnnl_IhwO16o16i4o;
+const format_tag_t IdhwO16o16i2o = dnnl_IdhwO16o16i2o;
+const format_tag_t IdhwO16o16i4o = dnnl_IdhwO16o16i4o;
+
+const format_tag_t gIwO16o16i2o = dnnl_gIwO16o16i2o;
+const format_tag_t gIwO16o16i4o = dnnl_gIwO16o16i4o;
+const format_tag_t gIhwO16o16i2o = dnnl_gIhwO16o16i2o;
+const format_tag_t gIhwO16o16i4o = dnnl_gIhwO16o16i4o;
+const format_tag_t gIdhwO16o16i2o = dnnl_gIdhwO16o16i2o;
+const format_tag_t gIdhwO16o16i4o = dnnl_gIdhwO16o16i4o;
+
+const format_tag_t IwO16o32i2o = dnnl_IwO16o32i2o;
+const format_tag_t IwO16o32i4o = dnnl_IwO16o32i4o;
+const format_tag_t IwO16o48i2o = dnnl_IwO16o48i2o;
+const format_tag_t IwO16o48i4o = dnnl_IwO16o48i4o;
+const format_tag_t IwO16o64i2o = dnnl_IwO16o64i2o;
+const format_tag_t IwO16o64i4o = dnnl_IwO16o64i4o;
+
+const format_tag_t gIwO16o32i2o = dnnl_gIwO16o32i2o;
+const format_tag_t gIwO16o32i4o = dnnl_gIwO16o32i4o;
+const format_tag_t gIwO16o48i2o = dnnl_gIwO16o48i2o;
+const format_tag_t gIwO16o48i4o = dnnl_gIwO16o48i4o;
+const format_tag_t gIwO16o64i2o = dnnl_gIwO16o64i2o;
+const format_tag_t gIwO16o64i4o = dnnl_gIwO16o64i4o;
+
+const format_tag_t IhwO16o32i2o = dnnl_IhwO16o32i2o;
+const format_tag_t IhwO16o32i4o = dnnl_IhwO16o32i4o;
+const format_tag_t IhwO16o48i2o = dnnl_IhwO16o48i2o;
+const format_tag_t IhwO16o48i4o = dnnl_IhwO16o48i4o;
+const format_tag_t IhwO16o64i2o = dnnl_IhwO16o64i2o;
+const format_tag_t IhwO16o64i4o = dnnl_IhwO16o64i4o;
+
+const format_tag_t gIhwO16o32i2o = dnnl_gIhwO16o32i2o;
+const format_tag_t gIhwO16o32i4o = dnnl_gIhwO16o32i4o;
+const format_tag_t gIhwO16o48i2o = dnnl_gIhwO16o48i2o;
+const format_tag_t gIhwO16o48i4o = dnnl_gIhwO16o48i4o;
+const format_tag_t gIhwO16o64i2o = dnnl_gIhwO16o64i2o;
+const format_tag_t gIhwO16o64i4o = dnnl_gIhwO16o64i4o;
+
+const format_tag_t Ihwo32i = dnnl_Ihwo32i;
+const format_tag_t IhwO32i2o = dnnl_IhwO32i2o;
+const format_tag_t IhwO32i4o = dnnl_IhwO32i4o;
+const format_tag_t Ihwo48i = dnnl_Ihwo48i;
+const format_tag_t IhwO48i2o = dnnl_IhwO48i2o;
+const format_tag_t IhwO48i4o = dnnl_IhwO48i4o;
+const format_tag_t Ihwo64i = dnnl_Ihwo64i;
+const format_tag_t IhwO64i2o = dnnl_IhwO64i2o;
+const format_tag_t IhwO64i4o = dnnl_IhwO64i4o;
+
+const format_tag_t gIhwo32i = dnnl_gIhwo32i;
+const format_tag_t gIhwO32i2o = dnnl_gIhwO32i2o;
+const format_tag_t gIhwO32i4o = dnnl_gIhwO32i4o;
+const format_tag_t gIhwo48i = dnnl_gIhwo48i;
+const format_tag_t gIhwO48i2o = dnnl_gIhwO48i2o;
+const format_tag_t gIhwO48i4o = dnnl_gIhwO48i4o;
+const format_tag_t gIhwo64i = dnnl_gIhwo64i;
+const format_tag_t gIhwO64i2o = dnnl_gIhwO64i2o;
+const format_tag_t gIhwO64i4o = dnnl_gIhwO64i4o;
+
+const format_tag_t Iwo8i = dnnl_Iwo8i;
+const format_tag_t IwO8i2o = dnnl_IwO8i2o;
+const format_tag_t IwO8i4o = dnnl_IwO8i4o;
+const format_tag_t Ihwo8i = dnnl_Ihwo8i;
+const format_tag_t IhwO8i2o = dnnl_IhwO8i2o;
+const format_tag_t IhwO8i4o = dnnl_IhwO8i4o;
+const format_tag_t Idhwo8i = dnnl_Idhwo8i;
+const format_tag_t IdhwO8i2o = dnnl_IdhwO8i2o;
+const format_tag_t IdhwO8i4o = dnnl_IdhwO8i4o;
+
+const format_tag_t Iwo16i = dnnl_Iwo16i;
+const format_tag_t IwO16i2o = dnnl_IwO16i2o;
+const format_tag_t IwO16i4o = dnnl_IwO16i4o;
+const format_tag_t Ihwo16i = dnnl_Ihwo16i;
+const format_tag_t IhwO16i2o = dnnl_IhwO16i2o;
+const format_tag_t IhwO16i4o = dnnl_IhwO16i4o;
+const format_tag_t Idhwo16i = dnnl_Idhwo16i;
+const format_tag_t IdhwO16i2o = dnnl_IdhwO16i2o;
+const format_tag_t IdhwO16i4o = dnnl_IdhwO16i4o;
+
+const format_tag_t Iwo24i = dnnl_Iwo24i;
+const format_tag_t IwO24i2o = dnnl_IwO24i2o;
+const format_tag_t IwO24i4o = dnnl_IwO24i4o;
+const format_tag_t Ihwo24i = dnnl_Ihwo24i;
+const format_tag_t IhwO24i2o = dnnl_IhwO24i2o;
+const format_tag_t IhwO24i4o = dnnl_IhwO24i4o;
+const format_tag_t Idhwo24i = dnnl_Idhwo24i;
+const format_tag_t IdhwO24i2o = dnnl_IdhwO24i2o;
+const format_tag_t IdhwO24i4o = dnnl_IdhwO24i4o;
+
+const format_tag_t gIwo8i = dnnl_gIwo8i;
+const format_tag_t gIwO8i2o = dnnl_gIwO8i2o;
+const format_tag_t gIwO8i4o = dnnl_gIwO8i4o;
+const format_tag_t gIhwo8i = dnnl_gIhwo8i;
+const format_tag_t gIhwO8i2o = dnnl_gIhwO8i2o;
+const format_tag_t gIhwO8i4o = dnnl_gIhwO8i4o;
+const format_tag_t gIdhwo8i = dnnl_gIdhwo8i;
+const format_tag_t gIdhwO8i2o = dnnl_gIdhwO8i2o;
+const format_tag_t gIdhwO8i4o = dnnl_gIdhwO8i4o;
+
+const format_tag_t gIwo16i = dnnl_gIwo16i;
+const format_tag_t gIwO16i2o = dnnl_gIwO16i2o;
+const format_tag_t gIwO16i4o = dnnl_gIwO16i4o;
+
+const format_tag_t gIhwo16i = dnnl_gIhwo16i;
+const format_tag_t gIhwO16i2o = dnnl_gIhwO16i2o;
+const format_tag_t gIhwO16i4o = dnnl_gIhwO16i4o;
+
+const format_tag_t gIdhwo16i = dnnl_gIdhwo16i;
+const format_tag_t gIdhwO16i2o = dnnl_gIdhwO16i2o;
+const format_tag_t gIdhwO16i4o = dnnl_gIdhwO16i4o;
+
+const format_tag_t gIwo24i = dnnl_gIwo24i;
+const format_tag_t gIwO24i2o = dnnl_gIwO24i2o;
+const format_tag_t gIwO24i4o = dnnl_gIwO24i4o;
+const format_tag_t gIhwo24i = dnnl_gIhwo24i;
+const format_tag_t gIhwO24i2o = dnnl_gIhwO24i2o;
+const format_tag_t gIhwO24i4o = dnnl_gIhwO24i4o;
+const format_tag_t gIdhwo24i = dnnl_gIdhwo24i;
+const format_tag_t gIdhwO24i2o = dnnl_gIdhwO24i2o;
+const format_tag_t gIdhwO24i4o = dnnl_gIdhwO24i4o;
+
+const format_tag_t hwioG16g = dnnl_hwioG16g;
+const format_tag_t hwioG8g = dnnl_hwioG8g;
+const format_tag_t dhwioG16g = dnnl_dhwioG16g;
+const format_tag_t dhwioG8g = dnnl_dhwioG8g;
+const format_tag_t Owi24o = dnnl_Owi24o;
+const format_tag_t Ohwi24o = dnnl_Ohwi24o;
+const format_tag_t Odhwi24o = dnnl_Odhwi24o;
+const format_tag_t gOwi24o = dnnl_gOwi24o;
+const format_tag_t gOhwi24o = dnnl_gOhwi24o;
+const format_tag_t gOdhwi24o = dnnl_gOdhwi24o;
+const format_tag_t OwI24o2i = dnnl_OwI24o2i;
+const format_tag_t OhwI24o2i = dnnl_OhwI24o2i;
+const format_tag_t OdhwI24o2i = dnnl_OdhwI24o2i;
+const format_tag_t gOwI24o2i = dnnl_gOwI24o2i;
+const format_tag_t gOhwI24o2i = dnnl_gOhwI24o2i;
+const format_tag_t gOdhwI24o2i = dnnl_gOdhwI24o2i;
+const format_tag_t OwI24o4i = dnnl_OwI24o4i;
+const format_tag_t OhwI24o4i = dnnl_OhwI24o4i;
+const format_tag_t OdhwI24o4i = dnnl_OdhwI24o4i;
+const format_tag_t gOwI24o4i = dnnl_gOwI24o4i;
+const format_tag_t gOhwI24o4i = dnnl_gOhwI24o4i;
+const format_tag_t gOdhwI24o4i = dnnl_gOdhwI24o4i;
+
+const format_tag_t OI8i32o = dnnl_OI8i32o;
+const format_tag_t OIw8i32o = dnnl_OIw8i32o;
+const format_tag_t OIhw8i32o = dnnl_OIhw8i32o;
+const format_tag_t OIdhw8i32o = dnnl_OIdhw8i32o;
+const format_tag_t OI8i24o = dnnl_OI8i24o;
+const format_tag_t OIw8i24o = dnnl_OIw8i24o;
+const format_tag_t OIhw8i24o = dnnl_OIhw8i24o;
+const format_tag_t OIdhw8i24o = dnnl_OIdhw8i24o;
+const format_tag_t OI8i16o = dnnl_OI8i16o;
+const format_tag_t OIw8i16o = dnnl_OIw8i16o;
+const format_tag_t OIhw8i16o = dnnl_OIhw8i16o;
+const format_tag_t OIdhw8i16o = dnnl_OIdhw8i16o;
+const format_tag_t OI8i8o = dnnl_OI8i8o;
+const format_tag_t OI8i8o2i = dnnl_OI8i8o2i;
+const format_tag_t OIw8i8o2i = dnnl_OIw8i8o2i;
+const format_tag_t OIhw8i8o2i = dnnl_OIhw8i8o2i;
+const format_tag_t OIdhw8i8o2i = dnnl_OIdhw8i8o2i;
+const format_tag_t OI8i24o2i = dnnl_OI8i24o2i;
+const format_tag_t OIw8i24o2i = dnnl_OIw8i24o2i;
+const format_tag_t OIhw8i24o2i = dnnl_OIhw8i24o2i;
+const format_tag_t OIdhw8i24o2i = dnnl_OIdhw8i24o2i;
+} // namespace format_tag
+
+using normalization_flags_t = dnnl_normalization_flags_t;
+namespace normalization_flags {
+const normalization_flags_t none = dnnl_normalization_flags_none;
+const normalization_flags_t use_global_stats = dnnl_use_global_stats;
+const normalization_flags_t use_scale = dnnl_use_scale;
+const normalization_flags_t use_shift = dnnl_use_shift;
+const normalization_flags_t fuse_norm_relu = dnnl_fuse_norm_relu;
+const normalization_flags_t fuse_norm_add_relu = dnnl_fuse_norm_add_relu;
+} // namespace normalization_flags
+
+using rnn_flags_t = dnnl_rnn_flags_t;
+namespace rnn_flags {
+const rnn_flags_t undef = dnnl_rnn_flags_undef;
+const rnn_flags_t diff_weights_overwrite
+        = dnnl_rnn_flags_diff_weights_overwrite;
+} // namespace rnn_flags
+
+using engine_kind_t = dnnl_engine_kind_t;
+namespace engine_kind {
+const engine_kind_t any_engine = dnnl_any_engine;
+const engine_kind_t cpu = dnnl_cpu;
+const engine_kind_t gpu = dnnl_gpu;
+} // namespace engine_kind
+
+enum runtime_kind_t {
+    dnnl_runtime_none,
+    dnnl_runtime_seq,
+    dnnl_runtime_omp,
+    dnnl_runtime_tbb,
+    dnnl_runtime_threadpool,
+    dnnl_runtime_ocl,
+    dnnl_runtime_sycl,
+};
+
+namespace runtime_kind {
+const runtime_kind_t none = dnnl_runtime_none;
+const runtime_kind_t seq = dnnl_runtime_seq;
+const runtime_kind_t omp = dnnl_runtime_omp;
+const runtime_kind_t tbb = dnnl_runtime_tbb;
+const runtime_kind_t threadpool = dnnl_runtime_threadpool;
+const runtime_kind_t ocl = dnnl_runtime_ocl;
+const runtime_kind_t sycl = dnnl_runtime_sycl;
+} // namespace runtime_kind
+
+using primitive_kind_t = dnnl_primitive_kind_t;
+namespace primitive_kind {
+const primitive_kind_t undefined = dnnl_undefined_primitive;
+const primitive_kind_t reorder = dnnl_reorder;
+const primitive_kind_t concat = dnnl_concat;
+const primitive_kind_t sum = dnnl_sum;
+const primitive_kind_t convolution = dnnl_convolution;
+const primitive_kind_t deconvolution = dnnl_deconvolution;
+const primitive_kind_t shuffle = dnnl_shuffle;
+const primitive_kind_t eltwise = dnnl_eltwise;
+const primitive_kind_t pooling = dnnl_pooling;
+const primitive_kind_t prelu = dnnl_prelu;
+const primitive_kind_t lrn = dnnl_lrn;
+const primitive_kind_t batch_normalization = dnnl_batch_normalization;
+const primitive_kind_t inner_product = dnnl_inner_product;
+const primitive_kind_t rnn = dnnl_rnn;
+const primitive_kind_t gemm = dnnl_gemm;
+const primitive_kind_t binary = dnnl_binary;
+const primitive_kind_t matmul = dnnl_matmul;
+const primitive_kind_t resampling = dnnl_resampling;
+const primitive_kind_t reduction = dnnl_reduction;
+const primitive_kind_t softmax = dnnl_softmax;
+const primitive_kind_t layer_normalization = dnnl_layer_normalization;
+const primitive_kind_t group_normalization = dnnl_group_normalization;
+
+// Internal only primitive kinds.
+const primitive_kind_t internal_only_start = (primitive_kind_t)(1 << 12);
+const primitive_kind_t zero_pad = internal_only_start;
+} // namespace primitive_kind
+
+using query_t = dnnl_query_t;
+namespace query {
+const query_t undef = dnnl_query_undef;
+
+const query_t engine = dnnl_query_engine;
+const query_t primitive_kind = dnnl_query_primitive_kind;
+
+const query_t num_of_inputs_s32 = dnnl_query_num_of_inputs_s32;
+const query_t num_of_outputs_s32 = dnnl_query_num_of_outputs_s32;
+
+const query_t time_estimate_f64 = dnnl_query_time_estimate_f64;
+const query_t memory_consumption_s64 = dnnl_query_memory_consumption_s64;
+
+const query_t scratchpad_engine = dnnl_query_scratchpad_engine;
+
+const query_t impl_info_str = dnnl_query_impl_info_str;
+
+const query_t reorder_src_engine = dnnl_query_reorder_src_engine;
+const query_t reorder_dst_engine = dnnl_query_reorder_dst_engine;
+
+const query_t prop_kind = dnnl_query_prop_kind;
+
+const query_t cache_blob_id_size_s64 = dnnl_query_cache_blob_id_size_s64;
+const query_t cache_blob_id = dnnl_query_cache_blob_id;
+
+const query_t strides = dnnl_query_strides;
+const query_t dilations = dnnl_query_dilations;
+const query_t padding_l = dnnl_query_padding_l;
+const query_t padding_r = dnnl_query_padding_r;
+const query_t epsilon_f32 = dnnl_query_epsilon_f32;
+const query_t flags = dnnl_query_flags;
+const query_t alg_kind = dnnl_query_alg_kind;
+const query_t alpha_f32 = dnnl_query_alpha_f32;
+const query_t beta_f32 = dnnl_query_beta_f32;
+const query_t axis_s32 = dnnl_query_axis_s32;
+const query_t local_size_s64 = dnnl_query_local_size_s64;
+const query_t k_f32 = dnnl_query_k_f32;
+const query_t p_f32 = dnnl_query_p_f32;
+const query_t factors = dnnl_query_factors;
+const query_t cell_kind = dnnl_query_cell_kind;
+const query_t direction = dnnl_query_direction;
+const query_t activation_kind = dnnl_query_activation_kind;
+const query_t kernel = dnnl_query_kernel;
+const query_t group_size_s64 = dnnl_query_group_size_s64;
+
+const query_t some_md = dnnl_query_some_md;
+const query_t src_md = dnnl_query_src_md;
+const query_t diff_src_md = dnnl_query_diff_src_md;
+const query_t weights_md = dnnl_query_weights_md;
+const query_t diff_weights_md = dnnl_query_diff_weights_md;
+const query_t dst_md = dnnl_query_dst_md;
+const query_t diff_dst_md = dnnl_query_diff_dst_md;
+const query_t exec_arg_md = dnnl_query_exec_arg_md;
+
+const query_t workspace_md = dnnl_query_workspace_md;
+const query_t scratchpad_md = dnnl_query_scratchpad_md;
+
+const query_t ndims_s32 = dnnl_query_ndims_s32;
+const query_t dims = dnnl_query_dims;
+const query_t data_type = dnnl_query_data_type;
+const query_t submemory_offset_s64 = dnnl_query_submemory_offset_s64;
+const query_t padded_dims = dnnl_query_padded_dims;
+const query_t padded_offsets = dnnl_query_padded_offsets;
+const query_t format_kind = dnnl_query_format_kind;
+const query_t inner_nblks_s32 = dnnl_query_inner_nblks_s32;
+const query_t inner_blks = dnnl_query_inner_blks;
+const query_t inner_idxs = dnnl_query_inner_idxs;
+
+#ifdef DNNL_EXPERIMENTAL_SPARSE
+const query_t sparse_encoding = dnnl_query_sparse_encoding;
+const query_t nnz_s64 = dnnl_query_nnz_s64;
+const query_t num_handles_s32 = dnnl_query_num_handles_s32;
+#else
+const query_t sparse_encoding = dnnl_query_undef;
+const query_t nnz_s64 = dnnl_query_undef;
+const query_t num_handles_s32 = dnnl_query_undef;
+#endif
+
+// Internal only query kinds.
+const query_t internal_only_start = (query_t)(1 << 12);
+const query_t zero_pad_d = internal_only_start;
+const query_t preferred_gpu_threads_per_eu = (query_t)(internal_only_start + 1);
+} // namespace query
+
+using rnn_direction_t = dnnl_rnn_direction_t;
+
+using engine_t = dnnl_engine;
+using primitive_attr_t = dnnl_primitive_attr;
+using post_ops_t = dnnl_post_ops;
+using memory_desc_t = dnnl_memory_desc;
+using memory_t = dnnl_memory;
+
+using stream_flags_t = dnnl_stream_flags_t;
+namespace stream_flags {
+const stream_flags_t in_order = dnnl_stream_in_order;
+const stream_flags_t out_of_order = dnnl_stream_out_of_order;
+const stream_flags_t default_flags = dnnl_stream_default_flags;
+#ifdef DNNL_EXPERIMENTAL_PROFILING
+const stream_flags_t profiling = dnnl_stream_profiling;
+#else
+const stream_flags_t profiling = static_cast<stream_flags_t>(1 << 2);
+#endif
+} // namespace stream_flags
+using stream_t = dnnl_stream;
+
+struct memory_storage_t;
+
+/* forward declaration of the internal primitive_desc types */
+struct batch_normalization_bwd_pd_t;
+struct batch_normalization_fwd_pd_t;
+struct batch_normalization_pd_t;
+struct binary_pd_t;
+struct concat_pd_t;
+struct convolution_bwd_data_pd_t;
+struct convolution_bwd_weights_pd_t;
+struct convolution_fwd_pd_t;
+struct convolution_pd_t;
+struct deconvolution_bwd_data_pd_t;
+struct deconvolution_bwd_weights_pd_t;
+struct deconvolution_fwd_pd_t;
+struct deconvolution_pd_t;
+struct eltwise_bwd_pd_t;
+struct eltwise_fwd_pd_t;
+struct eltwise_pd_t;
+struct gemm_pd_t;
+struct group_normalization_bwd_pd_t;
+struct group_normalization_fwd_pd_t;
+struct group_normalization_pd_t;
+struct inner_product_bwd_data_pd_t;
+struct inner_product_bwd_weights_pd_t;
+struct inner_product_fwd_pd_t;
+struct inner_product_pd_t;
+struct layer_normalization_bwd_pd_t;
+struct layer_normalization_fwd_pd_t;
+struct layer_normalization_pd_t;
+struct lrn_bwd_pd_t;
+struct lrn_fwd_pd_t;
+struct lrn_pd_t;
+struct matmul_pd_t;
+struct pooling_bwd_pd_t;
+struct pooling_fwd_pd_t;
+struct pooling_pd_t;
+struct prelu_pd_t;
+struct reduction_pd_t;
+struct reorder_pd_t;
+struct resampling_pd_t;
+struct rnn_bwd_pd_t;
+struct rnn_fwd_pd_t;
+struct rnn_pd_t;
+struct shuffle_pd_t;
+struct softmax_bwd_pd_t;
+struct softmax_fwd_pd_t;
+struct softmax_pd_t;
+struct sum_pd_t;
+
+} // namespace impl
+} // namespace dnnl
+
+#endif
+
+// vim: et ts=4 sw=4 cindent cino+=l0,\:4,N-s

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/common/cache_blob.hpp

@@ -0,0 +1,114 @@
+/*******************************************************************************
+* Copyright 2021-2023 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.
+*******************************************************************************/
+
+#ifndef COMMON_CACHE_BLOB_HPP
+#define COMMON_CACHE_BLOB_HPP
+
+#include <cstdint>
+#include <cstring>
+#include <memory>
+
+#include "c_types_map.hpp"
+
+namespace dnnl {
+namespace impl {
+
+struct cache_blob_impl_t {
+    cache_blob_impl_t() = delete;
+    cache_blob_impl_t(uint8_t *data, size_t size)
+        : pos_(0), data_(data), size_(size) {}
+
+    status_t add_binary(const uint8_t *binary, size_t binary_size) {
+        if (!binary || binary_size == 0) { return status::invalid_arguments; }
+        if (pos_ + sizeof(binary_size) + binary_size > size_) {
+            return status::invalid_arguments;
+        }
+
+        std::memcpy(data_ + pos_, &binary_size, sizeof(binary_size));
+        pos_ += sizeof(binary_size);
+        std::memcpy(data_ + pos_, binary, binary_size);
+        pos_ += binary_size;
+        return status::success;
+    }
+
+    status_t get_binary(const uint8_t **binary, size_t *binary_size) {
+        if (!binary || !binary_size) { return status::invalid_arguments; }
+        if (pos_ >= size_) { return status::invalid_arguments; }
+        (*binary_size) = *reinterpret_cast<size_t *>(data_ + pos_);
+        pos_ += sizeof(*binary_size);
+        (*binary) = data_ + pos_;
+        pos_ += *binary_size;
+        return status::success;
+    }
+
+    status_t add_value(const uint8_t *value_ptr, size_t size) {
+        if (!value_ptr) { return status::invalid_arguments; }
+        if (pos_ + size > size_) { return status::invalid_arguments; }
+
+        std::memcpy(data_ + pos_, value_ptr, size);
+        pos_ += size;
+        return status::success;
+    }
+
+    status_t get_value(uint8_t *value_ptr, size_t size) {
+        if (!value_ptr) { return status::invalid_arguments; }
+        if (pos_ >= size_) { return status::invalid_arguments; }
+        std::memcpy(value_ptr, data_ + pos_, size);
+        pos_ += size;
+        return status::success;
+    }
+
+private:
+    size_t pos_;
+    uint8_t *data_;
+    size_t size_;
+};
+
+struct cache_blob_t {
+    cache_blob_t() = default;
+    cache_blob_t(uint8_t *data, size_t size)
+        : impl_(std::make_shared<cache_blob_impl_t>(data, size)) {}
+
+    status_t add_binary(const uint8_t *binary, size_t binary_size) {
+        if (!impl_) return status::runtime_error;
+        return impl_->add_binary(binary, binary_size);
+    }
+
+    status_t get_binary(const uint8_t **binary, size_t *binary_size) const {
+        if (!impl_) return status::runtime_error;
+        return impl_->get_binary(binary, binary_size);
+    }
+
+    status_t add_value(const uint8_t *value_ptr, size_t size) {
+        if (!impl_) return status::runtime_error;
+        return impl_->add_value(value_ptr, size);
+    }
+
+    status_t get_value(uint8_t *value_ptr, size_t size) {
+        if (!impl_) return status::runtime_error;
+        return impl_->get_value(value_ptr, size);
+    }
+
+    explicit operator bool() const { return bool(impl_); }
+
+private:
+    std::shared_ptr<cache_blob_impl_t> impl_;
+};
+
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/common/cache_blob_id.hpp

@@ -0,0 +1,60 @@
+/*******************************************************************************
+* Copyright 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.
+*******************************************************************************/
+
+#ifndef COMMON_CACHE_BLOB_ID_HPP
+#define COMMON_CACHE_BLOB_ID_HPP
+
+#include <atomic>
+#include <cstdint>
+#include <mutex>
+#include <vector>
+#include <type_traits>
+
+#include "common/serialization_stream.hpp"
+
+namespace dnnl {
+namespace impl {
+
+struct primitive_desc_t;
+struct cache_blob_id_t {
+    cache_blob_id_t() : is_initialized_ {false} {}
+    cache_blob_id_t(const cache_blob_id_t &other)
+        : sstream_(other.is_initialized_ ? other.sstream_
+                                         : serialization_stream_t {})
+        , is_initialized_(!sstream_.empty()) {}
+
+    cache_blob_id_t(cache_blob_id_t &&other) = delete;
+    cache_blob_id_t &operator=(const cache_blob_id_t &other) = delete;
+    cache_blob_id_t &operator=(cache_blob_id_t &&other) = delete;
+
+    const std::vector<uint8_t> &get(
+            const engine_t *engine, const primitive_desc_t *pd);
+
+private:
+    serialization_stream_t sstream_;
+    std::once_flag flag_;
+
+    // The `std::once_flag` is neither copyable nor movable therefore we
+    // define a copy constructor that skips copying the `flag_`. To be able
+    // to carry over the `flag_`'s state from the `other` object we introduce
+    // an atomic `is_initialized_` flag.
+    std::atomic<bool> is_initialized_;
+};
+
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/common/cache_utils.hpp

@@ -0,0 +1,412 @@
+/*******************************************************************************
+* Copyright 2023 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.
+*******************************************************************************/
+
+#ifndef COMMON_CACHE_UTILS_HPP
+#define COMMON_CACHE_UTILS_HPP
+
+#include <algorithm>
+#include <future>
+#include <memory>
+#include <thread>
+#include <unordered_map>
+
+#include "oneapi/dnnl/dnnl_config.h"
+
+#if DNNL_CPU_RUNTIME != DNNL_RUNTIME_NONE
+#include "cpu/platform.hpp"
+#else
+#include <chrono>
+#endif
+
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+#include "rw_mutex.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace utils {
+
+// A key k and object o may share resources. This function moves the shared
+// resources from a copy of object o into the key k. This is used to deduplicate
+// data stored in cached objects.
+template <typename K, typename O>
+using key_merge_t = void (*)(const K &, const O &);
+
+template <typename K, typename O, typename C,
+        key_merge_t<K, O> key_merge = nullptr>
+struct cache_t {
+    using key_t = K;
+    using object_t = O;
+    using cache_object_t = C;
+    using value_t = std::shared_future<cache_object_t>;
+    using create_func_t = cache_object_t (&)(void *);
+
+    virtual ~cache_t() = default;
+
+    virtual status_t set_capacity(int capacity) = 0;
+    virtual int get_capacity() const = 0;
+
+    virtual int get_size() const = 0;
+
+    // Returns the cached value or cache_object_t() on a miss
+    virtual cache_object_t get(const key_t &key) = 0;
+
+    // Returns the cached object associated with key, the object generated by
+    // the create(create_context) function, or an empty object in case of
+    // errors. The function create() is only called on a cache miss. The
+    // returned object is added to the cache on a cache miss.
+    cache_object_t get_or_create(
+            const key_t &key, create_func_t create, void *create_context) {
+        std::promise<cache_object_t> p_promise;
+        // Try to get the shared future from the cache, if it's missing then a
+        // shared future with no shared state is returned and the passed shared
+        // future is added, otherwise a valid shared future is returned and no
+        // insertion is performed.
+        auto p_future = get_or_add(key, p_promise.get_future());
+
+        if (p_future.valid()) {
+            // The requested object is present in the cache or is being created
+            // by another thread.
+            return p_future.get();
+        } else {
+            // The requested object is NOT present in the cache therefore we
+            // have to create it and notify the waiting threads once the
+            // creation is done.
+            cache_object_t cv = create(create_context);
+            if (cv.status != status::success) {
+                // Communicate an error.
+                p_promise.set_value({nullptr, cv.status});
+                // Remove the shared future from the cache because it's
+                // invalidated. An invalidated shared future is the one that
+                // stores a nullptr.
+                remove_if_invalidated(key);
+                return {nullptr, cv.status};
+            } else {
+                // Store the created object in the shared future and notify the
+                // waiting threads.
+                p_promise.set_value(cv);
+
+                // The key_t may contains pointers that should reside within the
+                // stored object. Therefore the pointers in the key may need
+                // updated.
+                update_entry(key, cv.get_value());
+                return cv;
+            }
+        }
+    }
+
+protected:
+    virtual value_t get_or_add(const key_t &key, const value_t &value) = 0;
+    virtual void remove_if_invalidated(const key_t &key) = 0;
+    virtual void update_entry(const key_t &key, const object_t &p) = 0;
+    static utils::rw_mutex_t &rw_mutex() {
+        static utils::rw_mutex_t mutex;
+        return mutex;
+    }
+};
+
+// The cache uses LRU replacement policy
+template <typename K, typename O, typename C,
+        key_merge_t<K, O> key_merge = nullptr>
+struct lru_cache_t final : public cache_t<K, O, C, key_merge> {
+    using lru_base_t = cache_t<K, O, C, key_merge>;
+    using key_t = typename lru_base_t::key_t;
+    using object_t = typename lru_base_t::object_t;
+    using cache_object_t = typename lru_base_t::cache_object_t;
+    using value_t = typename lru_base_t::value_t;
+    lru_cache_t(int capacity) : capacity_(capacity) {}
+
+    ~lru_cache_t() override {
+        if (cache_mapper().empty()) return;
+
+#if defined(_WIN32) \
+        && (defined(DNNL_WITH_SYCL) || DNNL_GPU_RUNTIME == DNNL_RUNTIME_OCL)
+        // The ntdll.dll library is located in system32, therefore setting
+        // additional environment is not required.
+        HMODULE handle = LoadLibraryExA(
+                "ntdll.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32);
+        if (!handle) {
+            release_cache();
+            return;
+        }
+
+        // RtlDllShutdownInProgress returns TRUE if the whole process terminates
+        // and FALSE if DLL is being unloaded dynamically or if it’s called from
+        // an executable.
+        auto f = reinterpret_cast<BOOLEAN (*)(void)>(
+                GetProcAddress(handle, "RtlDllShutdownInProgress"));
+        if (!f) {
+            auto ret = FreeLibrary(handle);
+            assert(ret);
+            MAYBE_UNUSED(ret);
+            release_cache();
+            return;
+        }
+
+        bool is_process_termination_in_progress = f();
+
+        auto ret = FreeLibrary(handle);
+        assert(ret);
+        MAYBE_UNUSED(ret);
+
+        if (is_process_termination_in_progress) {
+            // The whole process is being terminated hence destroying content of
+            // the cache cannot be done safely. However we can check all entries
+            // and remove those that are not affected e.g. native CPU.
+            for (auto it = cache_mapper().begin();
+                    it != cache_mapper().end();) {
+                if (!it->first.has_runtime_dependencies()) {
+                    it = cache_mapper().erase(it);
+                } else {
+                    ++it;
+                }
+            }
+            release_cache();
+        } else {
+            // Three scenarios possible:
+            //    1. oneDNN is being dynamically unloaded
+            //    2. Another dynamic library that contains statically linked
+            //       oneDNN is dynamically unloaded
+            //    3. oneDNN is statically linked in an executable which is done
+            //       and now the process terminates In all these scenarios
+            //       content of the cache can be safely destroyed.
+        }
+#else
+            // Always destroy the content of the cache for non-Windows OSes, and
+            // non-sycl and non-ocl runtimes because there is no a problem with
+            // library unloading order in such cases.
+#endif
+    }
+
+    cache_object_t get(const key_t &key) override {
+        value_t e;
+        {
+            utils::lock_read_t lock_r(this->rw_mutex());
+            if (capacity_ == 0) { return cache_object_t(); }
+            e = get_future(key);
+        }
+
+        if (e.valid()) return e.get();
+        return cache_object_t();
+    }
+
+    int get_capacity() const override {
+        utils::lock_read_t lock_r(this->rw_mutex());
+        return capacity_;
+    };
+
+    status_t set_capacity(int capacity) override {
+        utils::lock_write_t lock_w(this->rw_mutex());
+        capacity_ = capacity;
+        // Check if number of entries exceeds the new capacity
+        if (get_size_no_lock() > capacity_) {
+            // Evict excess entries
+            int n_excess_entries = get_size_no_lock() - capacity_;
+            evict(n_excess_entries);
+        }
+        return status::success;
+    }
+    void set_capacity_without_clearing(int capacity) {
+        utils::lock_write_t lock_w(this->rw_mutex());
+        capacity_ = capacity;
+    }
+
+    int get_size() const override {
+        utils::lock_read_t lock_r(this->rw_mutex());
+        return get_size_no_lock();
+    }
+
+protected:
+    int get_size_no_lock() const { return (int)cache_mapper().size(); }
+
+    value_t get_or_add(const key_t &key, const value_t &value) override {
+        {
+            // 1. Section with shared access (read lock)
+            utils::lock_read_t lock_r(this->rw_mutex());
+            // Check if the cache is enabled.
+            if (capacity_ == 0) { return value_t(); }
+            // Check if the requested entry is present in the cache (likely
+            // cache_hit)
+            auto e = get_future(key);
+            if (e.valid()) { return e; }
+        }
+
+        utils::lock_write_t lock_w(this->rw_mutex());
+        // 2. Section with exclusive access (write lock).
+        // In a multithreaded scenario, in the context of one thread the cache
+        // may have changed by another thread between releasing the read lock
+        // and acquiring the write lock (a.k.a. ABA problem), therefore
+        // additional checks have to be performed for correctness. Double check
+        // the capacity due to possible race condition
+        if (capacity_ == 0) { return value_t(); }
+
+        // Double check if the requested entry is present in the cache (unlikely
+        // cache_hit).
+        auto e = get_future(key);
+        if (!e.valid()) {
+            // If the entry is missing in the cache then add it (cache_miss)
+            add(key, value);
+        }
+        return e;
+    }
+
+    void remove_if_invalidated(const key_t &key) override {
+        utils::lock_write_t lock_w(this->rw_mutex());
+
+        if (capacity_ == 0) { return; }
+
+        auto it = cache_mapper().find(key);
+        // The entry has been already evicted at this point
+        if (it == cache_mapper().end()) { return; }
+
+        const auto &value = it->second.value_;
+        // If the entry is not invalidated
+        if (!value.get().is_empty()) { return; }
+
+        // Remove the invalidated entry
+        cache_mapper().erase(it);
+    }
+
+private:
+    static size_t get_timestamp() {
+#if DNNL_CPU_RUNTIME != DNNL_RUNTIME_NONE
+        return cpu::platform::get_timestamp();
+#else
+        return std::chrono::steady_clock::now().time_since_epoch().count();
+#endif
+    }
+
+    void update_entry(const key_t &key, const object_t &p) override {
+        // Cast to void as compilers may warn about comparing compile time
+        // constant function pointers with nullptr, as that is often not an
+        // intended behavior
+        if ((void *)key_merge == nullptr) return;
+
+        utils::lock_write_t lock_w(this->rw_mutex());
+
+        if (capacity_ == 0) { return; }
+
+        // There is nothing to do in two cases:
+        // 1. The requested entry is not in the cache because it has been evicted
+        //    by another thread
+        // 2. After the requested entry had been evicted it was inserted again
+        //    by another thread
+        auto it = cache_mapper().find(key);
+        if (it == cache_mapper().end()
+                || it->first.thread_id() != key.thread_id()) {
+            return;
+        }
+
+        key_merge(it->first, p);
+    }
+
+    void evict(int n) {
+        using v_t =
+                typename std::unordered_map<key_t, timed_entry_t>::value_type;
+
+        if (n == capacity_) {
+            cache_mapper().clear();
+            return;
+        }
+
+        for (int e = 0; e < n; e++) {
+            // Find the smallest timestamp
+            // TODO: revisit the eviction algorithm due to O(n) complexity, E.g.
+            // maybe evict multiple entries at once.
+            auto it = std::min_element(cache_mapper().begin(),
+                    cache_mapper().end(),
+                    [&](const v_t &left, const v_t &right) {
+                        // By default, load() and operator T use sequentially
+                        // consistent memory ordering, which enforces writing
+                        // the timestamps into registers in the same exact order
+                        // they are read from the CPU cache line. Since eviction
+                        // is performed under a write lock, this order is not
+                        // important, therefore we can safely use the weakest
+                        // memory ordering (relaxed). This brings about a few
+                        // microseconds performance improvement for default
+                        // cache capacity.
+                        return left.second.timestamp_.load(
+                                       std::memory_order_relaxed)
+                                < right.second.timestamp_.load(
+                                        std::memory_order_relaxed);
+                    });
+            auto res = cache_mapper().erase(it->first);
+            MAYBE_UNUSED(res);
+            assert(res);
+        }
+    }
+    void add(const key_t &key, const value_t &value) {
+        // std::list::size() method has linear complexity. Check the cache size
+        // using std::unordered_map::size();
+        if (get_size_no_lock() == capacity_) {
+            // Evict the least recently used entry
+            evict(1);
+        }
+
+        size_t timestamp = get_timestamp();
+
+        auto res = cache_mapper().emplace(std::piecewise_construct,
+                std::forward_as_tuple(key),
+                std::forward_as_tuple(value, timestamp));
+        MAYBE_UNUSED(res);
+        assert(res.second);
+    }
+    value_t get_future(const key_t &key) {
+        auto it = cache_mapper().find(key);
+        if (it == cache_mapper().end()) return value_t();
+
+        size_t timestamp = get_timestamp();
+        it->second.timestamp_.store(timestamp);
+        // Return the entry
+        return it->second.value_;
+    }
+
+    int capacity_;
+    struct timed_entry_t {
+        value_t value_;
+        std::atomic<size_t> timestamp_;
+        timed_entry_t(const value_t &value, size_t timestamp)
+            : value_(value), timestamp_(timestamp) {}
+    };
+
+    std::unordered_map<key_t, timed_entry_t> &cache_mapper() {
+        return cache_mapper_;
+    }
+
+    const std::unordered_map<key_t, timed_entry_t> &cache_mapper() const {
+        return cache_mapper_;
+    }
+
+    // Leaks cached resources. Used to avoid issues with calling destructors
+    // allocated by an already unloaded dynamic library.
+    void release_cache() {
+        auto t = utils::make_unique<std::unordered_map<key_t, timed_entry_t>>();
+        std::swap(*t, cache_mapper_);
+        t.release();
+    }
+    // Each entry in the cache has a corresponding key and timestamp. NOTE:
+    // pairs that contain atomics cannot be stored in an unordered_map *as an
+    // element*, since it invokes the copy constructor of std::atomic, which is
+    // deleted.
+    std::unordered_map<key_t, timed_entry_t> cache_mapper_;
+};
+
+} // namespace utils
+} // namespace impl
+} // namespace dnnl
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/common/compiler_workarounds.hpp

@@ -0,0 +1,84 @@
+/*******************************************************************************
+* Copyright 2020-2023 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.
+*******************************************************************************/
+
+#ifndef COMPILER_WORKAROUNDS_HPP
+#define COMPILER_WORKAROUNDS_HPP
+
+#if (defined __GNUC__) && (!defined(__INTEL_COMPILER)) \
+        && (!defined(__INTEL_LLVM_COMPILER)) && (!defined(__clang__major__))
+#define NEED_GCC_WA_CHECK 1
+#endif
+
+// Workaround 01: clang.
+//
+// Clang has an issue [1] with `#pragma omp simd` that might lead to segfault.
+// The essential conditions are:
+//  1. Optimization level is O1 or O2. Surprisingly, O3 is fine.
+//  2. Conditional check inside the vectorization loop.
+// Since there is no reliable way to determine the first condition, we disable
+// vectorization for clang altogether for now.
+//
+// [1] https://bugs.llvm.org/show_bug.cgi?id=48104
+#if (defined __clang_major__) && (__clang_major__ >= 6)
+#define CLANG_WA_01_SAFE_TO_USE_OMP_SIMD 0
+#else
+#define CLANG_WA_01_SAFE_TO_USE_OMP_SIMD 1
+#endif
+
+// Workaround 02: clang.
+//
+// Clang 6+ generates incorrect code with OMP_SIMD in some particular cases.
+// Unlike CLANG_WA_01_SAFE_TO_USE_OMP_SIMD, the issue happens even with -O3.
+#if (defined __clang_major__) && (__clang_major__ >= 6)
+#define CLANG_WA_02_SAFE_TO_USE_OMP_SIMD 0
+#else
+#define CLANG_WA_02_SAFE_TO_USE_OMP_SIMD 1
+#endif
+
+// Workaround 03: GCC
+//
+// For very large functions with too much control flow (i.e. if, switch, goto
+// statements), GCC 7 may struggle to perform optimizations based on tree
+// dominator (i.e. -ftree-dominator-opts, which is enabled with O1), thereby
+// producing an internal compiler error (ICE). Specifically, it seems that the
+// jump threading optimization is the culprit, which cannot be disabled on its
+// own. There is no reliable way to reproduce the ICE, therefore it is not clear
+// which __GCC_MINOR__ version fixes issue.
+#if (defined NEED_GCC_WA_CHECK) && (__GNUC__ == 7)
+#define GCC_WA_NO_TREE_DOMINATOR_OPTS 1
+#else
+#define GCC_WA_NO_TREE_DOMINATOR_OPTS 0
+#endif
+
+// Workaround 04: GCC
+//
+// GCC 10 & 11 && 12 (at least versiona 10.1, 10.3 & 11.1, 12.2) report false positives
+// in xbyak when -Warray-bounds build setting is on
+#if (defined NEED_GCC_WA_CHECK) && (__GNUC__ >= 10)
+#pragma GCC diagnostic ignored "-Warray-bounds"
+#endif
+
+// Workaround 05: GCC
+//
+// NOTE: inside lambda, type cast variables captured by reference using
+// either c-like "(type)var" or functional "type(var)" notation in order
+// to avoid gcc7 bug with c++14 standard
+// (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83204).
+#if (defined NEED_GCC_WA_CHECK) && (__GNUC__ <= 7)
+#define GCC_WA_LAMBDA_C_CAST
+#endif
+
+#endif // COMPILER_WORKAROUNDS_HPP

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/common/convolution_pd.hpp

@@ -0,0 +1,473 @@
+/*******************************************************************************
+* Copyright 2016-2023 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.
+*******************************************************************************/
+
+#ifndef COMMON_CONVOLUTION_PD_HPP
+#define COMMON_CONVOLUTION_PD_HPP
+
+#include "oneapi/dnnl/dnnl.h"
+
+#include "c_types_map.hpp"
+#include "primitive_desc.hpp"
+#include "utils.hpp"
+
+namespace dnnl {
+namespace impl {
+
+status_t conv_desc_init(convolution_desc_t *conv_desc, prop_kind_t prop_kind,
+        alg_kind_t alg_kind, const memory_desc_t *src_desc,
+        const memory_desc_t *weights_desc, const memory_desc_t *bias_desc,
+        const memory_desc_t *dst_desc, const dims_t strides,
+        const dims_t dilates, const dims_t padding_l, const dims_t padding_r);
+
+memory_desc_t *conv_prop_invariant_src_d(convolution_desc_t *desc);
+memory_desc_t *conv_prop_invariant_wei_d(convolution_desc_t *desc);
+memory_desc_t *conv_prop_invariant_bia_d(convolution_desc_t *desc);
+memory_desc_t *conv_prop_invariant_dst_d(convolution_desc_t *desc);
+const memory_desc_t *conv_prop_invariant_src_d(const convolution_desc_t *desc);
+const memory_desc_t *conv_prop_invariant_wei_d(const convolution_desc_t *desc);
+const memory_desc_t *conv_prop_invariant_bia_d(const convolution_desc_t *desc);
+const memory_desc_t *conv_prop_invariant_dst_d(const convolution_desc_t *desc);
+
+struct convolution_fwd_pd_t;
+
+struct convolution_pd_t : public primitive_desc_t {
+    static constexpr auto base_pkind = primitive_kind::convolution;
+
+    const convolution_desc_t *desc() const { return &desc_; }
+    const op_desc_t *op_desc() const override {
+        return reinterpret_cast<const op_desc_t *>(this->desc());
+    }
+
+    status_t query(query_t what, int idx, void *result) const override {
+        switch (what) {
+            case query::prop_kind:
+                *(prop_kind_t *)result = desc()->prop_kind;
+                break;
+            case query::alg_kind:
+                *(alg_kind_t *)result = desc()->alg_kind;
+                break;
+            case query::strides:
+                *(const dims_t **)result = &desc()->strides;
+                break;
+            case query::dilations:
+                *(const dims_t **)result = &desc()->dilates;
+                break;
+            case query::padding_l:
+                *(const dims_t **)result = &desc()->padding[0];
+                break;
+            case query::padding_r:
+                *(const dims_t **)result = &desc()->padding[1];
+                break;
+            default: return primitive_desc_t::query(what, idx, result);
+        }
+        return status::success;
+    }
+
+    /* common conv aux functions */
+
+    dim_t MB() const { return invariant_src_md()->dims[0]; }
+
+    dim_t IC() const { return invariant_src_md()->dims[1]; }
+    dim_t OC() const { return invariant_dst_md()->dims[1]; }
+    dim_t G() const { return with_groups() ? invariant_wei_md()->dims[0] : 1; }
+
+    dim_t ID() const {
+        return ndims() >= 5 ? invariant_src_md()->dims[ndims() - 3] : 1;
+    }
+    dim_t IH() const {
+        return ndims() >= 4 ? invariant_src_md()->dims[ndims() - 2] : 1;
+    }
+    dim_t IW() const { return invariant_src_md()->dims[ndims() - 1]; }
+
+    dim_t OD() const {
+        return ndims() >= 5 ? invariant_dst_md()->dims[ndims() - 3] : 1;
+    }
+    dim_t OH() const {
+        return ndims() >= 4 ? invariant_dst_md()->dims[ndims() - 2] : 1;
+    }
+    dim_t OW() const { return invariant_dst_md()->dims[ndims() - 1]; }
+
+    dim_t KD() const {
+        return ndims() >= 5
+                ? invariant_wei_md()->dims[ndims() + with_groups() - 3]
+                : 1;
+    }
+    dim_t KH() const {
+        return ndims() >= 4
+                ? invariant_wei_md()->dims[ndims() + with_groups() - 2]
+                : 1;
+    }
+    dim_t KW() const {
+        return invariant_wei_md()->dims[ndims() + with_groups() - 1];
+    }
+
+    dim_t KSD() const { return ndims() >= 5 ? desc_.strides[ndims() - 5] : 1; }
+    dim_t KSH() const { return ndims() >= 4 ? desc_.strides[ndims() - 4] : 1; }
+    dim_t KSW() const { return desc_.strides[ndims() - 3]; }
+
+    dim_t KDD() const { return ndims() >= 5 ? desc_.dilates[ndims() - 5] : 0; }
+    dim_t KDH() const { return ndims() >= 4 ? desc_.dilates[ndims() - 4] : 1; }
+    dim_t KDW() const { return desc_.dilates[ndims() - 3]; }
+
+    dim_t padFront() const {
+        return ndims() >= 5 ? desc_.padding[0][ndims() - 5] : 0;
+    }
+    dim_t padBack() const {
+        return ndims() >= 5 ? desc_.padding[1][ndims() - 5] : 0;
+    }
+    dim_t padT() const {
+        return ndims() >= 4 ? desc_.padding[0][ndims() - 4] : 0;
+    }
+    dim_t padB() const {
+        return ndims() >= 4 ? desc_.padding[1][ndims() - 4] : 0;
+    }
+    dim_t padL() const { return desc_.padding[0][ndims() - 3]; }
+    dim_t padR() const { return desc_.padding[1][ndims() - 3]; }
+
+    int ndims() const { return invariant_src_md()->ndims; }
+
+    bool with_bias() const {
+        return !memory_desc_wrapper(invariant_bia_md()).is_zero();
+    }
+    bool with_groups() const {
+        return invariant_wei_md()->ndims == ndims() + 1;
+    }
+
+    bool is_fwd() const {
+        return utils::one_of(desc_.prop_kind, prop_kind::forward_training,
+                prop_kind::forward_inference);
+    }
+
+    bool is_bwd_d() const {
+        return desc_.prop_kind == prop_kind::backward_data;
+    }
+
+    bool is_bwd_w() const {
+        return desc_.prop_kind == prop_kind::backward_weights;
+    }
+
+    bool has_zero_dim_memory() const {
+        const auto s_d = memory_desc_wrapper(*invariant_src_md());
+        const auto d_d = memory_desc_wrapper(*invariant_dst_md());
+        return s_d.has_zero_dim() || d_d.has_zero_dim();
+    }
+
+protected:
+    convolution_desc_t desc_;
+    const convolution_fwd_pd_t *hint_fwd_pd_;
+
+    convolution_pd_t(const convolution_desc_t *adesc,
+            const primitive_attr_t *attr,
+            const convolution_fwd_pd_t *hint_fwd_pd)
+        : primitive_desc_t(attr, base_pkind)
+        , desc_(*adesc)
+        , hint_fwd_pd_(hint_fwd_pd) {}
+
+    bool set_default_formats_common_template(memory_desc_t &src_md,
+            format_tag_t src_tag, memory_desc_t &wei_md, format_tag_t wei_tag,
+            memory_desc_t &dst_md, format_tag_t dst_tag,
+            memory_desc_t &bia_md) {
+        using namespace format_tag;
+
+#define IS_OK(f) \
+    do { \
+        if ((f) != status::success) return false; \
+    } while (0)
+        if (src_md.format_kind == format_kind::any
+                && !utils::one_of(src_tag, any, undef))
+            IS_OK(memory_desc_init_by_tag(src_md, src_tag));
+        if (dst_md.format_kind == format_kind::any
+                && !utils::one_of(dst_tag, any, undef))
+            IS_OK(memory_desc_init_by_tag(dst_md, dst_tag));
+        if (wei_md.format_kind == format_kind::any
+                && !utils::one_of(wei_tag, any, undef))
+            IS_OK(memory_desc_init_by_tag(wei_md, wei_tag));
+        if (with_bias() && bia_md.format_kind == format_kind::any)
+            IS_OK(memory_desc_init_by_tag(bia_md, x));
+#undef IS_OK
+
+        return true;
+    }
+
+    bool set_default_alg_kind(alg_kind_t alg_kind) {
+        assert(utils::one_of(alg_kind, alg_kind::convolution_direct,
+                alg_kind::convolution_winograd));
+        if (desc_.alg_kind == alg_kind::convolution_auto)
+            desc_.alg_kind = alg_kind;
+        return desc_.alg_kind == alg_kind;
+    }
+
+    bool expect_data_types(data_type_t src_dt, data_type_t wei_dt,
+            data_type_t bia_dt, data_type_t dst_dt, data_type_t acc_dt) const {
+        bool ok = true
+                && (src_dt == data_type::undef
+                        || invariant_src_md()->data_type == src_dt)
+                && (wei_dt == data_type::undef
+                        || invariant_wei_md()->data_type == wei_dt)
+                && (dst_dt == data_type::undef
+                        || invariant_dst_md()->data_type == dst_dt)
+                && (acc_dt == data_type::undef
+                        || desc_.accum_data_type == acc_dt);
+        if (with_bias() && bia_dt != data_type::undef)
+            ok = ok && invariant_bia_md()->data_type == bia_dt;
+        return ok;
+    }
+
+    bool attr_scales_ok(const std::vector<int> &supported_args
+            = {DNNL_ARG_SRC, DNNL_ARG_WEIGHTS, DNNL_ARG_DST}) const {
+        bool ok = attr()->scales_.has_default_values(supported_args);
+        for (int arg : supported_args) {
+            const auto &mask = attr()->scales_.get(arg).mask_;
+            if (arg == DNNL_ARG_WEIGHTS)
+                ok = ok && (mask == 0 || mask == (with_groups() ? 3 : 1));
+            else
+                ok = ok && (mask == 0);
+        }
+        return ok;
+    }
+};
+
+struct convolution_fwd_pd_t : public convolution_pd_t {
+    typedef convolution_fwd_pd_t base_class;
+    typedef convolution_fwd_pd_t hint_class;
+
+    arg_usage_t arg_usage(int arg) const override {
+        if (utils::one_of(arg, DNNL_ARG_SRC, DNNL_ARG_WEIGHTS))
+            return arg_usage_t::input;
+
+        if (arg == DNNL_ARG_BIAS && with_bias()) return arg_usage_t::input;
+
+        if (arg == DNNL_ARG_DST) return arg_usage_t::output;
+
+        return primitive_desc_t::arg_usage(arg);
+    }
+
+    const memory_desc_t *arg_md(
+            int arg, bool user_input = false) const override {
+        switch (arg) {
+            case DNNL_ARG_SRC: return src_md(0);
+            case DNNL_ARG_WEIGHTS: return weights_md(0);
+            case DNNL_ARG_BIAS: return weights_md(1);
+            case DNNL_ARG_DST: return dst_md(0, user_input);
+            default: return convolution_pd_t::arg_md(arg);
+        }
+    }
+
+    const memory_desc_t *src_md(
+            int index = 0, bool user_input = false) const override {
+        if (index == 0) return user_input ? &desc()->src_desc : &src_md_;
+        return &glob_zero_md;
+    }
+    const memory_desc_t *dst_md(
+            int index = 0, bool user_input = false) const override {
+        if (index == 0) return user_input ? &desc()->dst_desc : &dst_md_;
+        return &glob_zero_md;
+    }
+    const memory_desc_t *weights_md(
+            int index = 0, bool user_input = false) const override {
+        if (index == 0)
+            return user_input ? &desc()->weights_desc : &weights_md_;
+        if (index == 1) return user_input ? &desc()->bias_desc : &bias_md_;
+        return &glob_zero_md;
+    }
+
+    int n_inputs() const override {
+        return 2 + with_bias() + attr_post_op_dw_inputs() + n_binary_po_inputs()
+                + n_prelu_po_inputs();
+    }
+
+    int n_outputs() const override { return 1; }
+
+protected:
+    memory_desc_t src_md_;
+    memory_desc_t weights_md_;
+    memory_desc_t bias_md_;
+    memory_desc_t dst_md_;
+
+    convolution_fwd_pd_t(const convolution_desc_t *adesc,
+            const primitive_attr_t *attr,
+            const convolution_fwd_pd_t *hint_fwd_pd)
+        : convolution_pd_t(adesc, attr, hint_fwd_pd)
+        , src_md_(desc_.src_desc)
+        , weights_md_(desc_.weights_desc)
+        , bias_md_(desc_.bias_desc)
+        , dst_md_(desc_.dst_desc) {}
+
+    bool set_default_formats_common(
+            format_tag_t src_tag, format_tag_t wei_tag, format_tag_t dst_tag) {
+        return set_default_formats_common_template(src_md_, src_tag,
+                weights_md_, wei_tag, dst_md_, dst_tag, bias_md_);
+    }
+
+    int attr_post_op_dw_inputs() const {
+        const auto &po = attr_.post_ops_;
+        int conv = po.find(primitive_kind::convolution);
+        if (conv == -1) return 0;
+        return po.entry_[conv].depthwise_conv.bias_dt == data_type::undef ? 1
+                                                                          : 2;
+    }
+};
+
+struct convolution_bwd_data_pd_t : public convolution_pd_t {
+    typedef convolution_bwd_data_pd_t base_class;
+    typedef convolution_fwd_pd_t hint_class;
+
+    arg_usage_t arg_usage(int arg) const override {
+        if (utils::one_of(arg, DNNL_ARG_WEIGHTS, DNNL_ARG_DIFF_DST))
+            return arg_usage_t::input;
+
+        if (arg == DNNL_ARG_DIFF_SRC) return arg_usage_t::output;
+
+        return primitive_desc_t::arg_usage(arg);
+    }
+
+    const memory_desc_t *arg_md(
+            int arg, bool user_input = false) const override {
+        switch (arg) {
+            case DNNL_ARG_DIFF_SRC: return diff_src_md(0);
+            case DNNL_ARG_WEIGHTS: return weights_md(0);
+            case DNNL_ARG_BIAS: return weights_md(1);
+            case DNNL_ARG_DIFF_DST: return diff_dst_md(0, user_input);
+            default: return convolution_pd_t::arg_md(arg);
+        }
+    }
+
+    const memory_desc_t *diff_src_md(
+            int index = 0, bool user_input = false) const override {
+        if (index == 0)
+            return user_input ? &desc()->diff_src_desc : &diff_src_md_;
+        return &glob_zero_md;
+    }
+    const memory_desc_t *diff_dst_md(
+            int index = 0, bool user_input = false) const override {
+        if (index == 0)
+            return user_input ? &desc()->diff_dst_desc : &diff_dst_md_;
+        return &glob_zero_md;
+    }
+    const memory_desc_t *weights_md(
+            int index = 0, bool user_input = false) const override {
+        if (index == 0)
+            return user_input ? &desc()->weights_desc : &weights_md_;
+        if (index == 1) return user_input ? &desc()->bias_desc : &bias_md_;
+        return &glob_zero_md;
+    }
+
+    int n_inputs() const override { return 2 + with_bias(); }
+    int n_outputs() const override { return 1; }
+
+    virtual bool support_bias() const { return false; }
+
+protected:
+    memory_desc_t diff_src_md_;
+    memory_desc_t weights_md_;
+    memory_desc_t bias_md_;
+    memory_desc_t diff_dst_md_;
+
+    convolution_bwd_data_pd_t(const convolution_desc_t *adesc,
+            const primitive_attr_t *attr,
+            const convolution_fwd_pd_t *hint_fwd_pd)
+        : convolution_pd_t(adesc, attr, hint_fwd_pd)
+        , diff_src_md_(desc_.diff_src_desc)
+        , weights_md_(desc_.weights_desc)
+        , bias_md_(desc_.bias_desc)
+        , diff_dst_md_(desc_.diff_dst_desc) {}
+
+    bool set_default_formats_common(format_tag_t diff_src_tag,
+            format_tag_t wei_tag, format_tag_t diff_dst_tag) {
+        return set_default_formats_common_template(diff_src_md_, diff_src_tag,
+                weights_md_, wei_tag, diff_dst_md_, diff_dst_tag, bias_md_);
+    }
+};
+
+struct convolution_bwd_weights_pd_t : public convolution_pd_t {
+    typedef convolution_bwd_weights_pd_t base_class;
+    typedef convolution_fwd_pd_t hint_class;
+
+    convolution_bwd_weights_pd_t(const convolution_desc_t *adesc,
+            const primitive_attr_t *attr,
+            const convolution_fwd_pd_t *hint_fwd_pd)
+        : convolution_pd_t(adesc, attr, hint_fwd_pd)
+        , src_md_(desc_.src_desc)
+        , diff_weights_md_(desc_.diff_weights_desc)
+        , diff_bias_md_(desc_.diff_bias_desc)
+        , diff_dst_md_(desc_.diff_dst_desc) {}
+
+    arg_usage_t arg_usage(int arg) const override {
+        if (utils::one_of(arg, DNNL_ARG_SRC, DNNL_ARG_DIFF_DST))
+            return arg_usage_t::input;
+
+        if (arg == DNNL_ARG_DIFF_WEIGHTS) return arg_usage_t::output;
+
+        if (arg == DNNL_ARG_DIFF_BIAS && with_bias())
+            return arg_usage_t::output;
+
+        return primitive_desc_t::arg_usage(arg);
+    }
+
+    const memory_desc_t *arg_md(
+            int arg, bool user_input = false) const override {
+        switch (arg) {
+            case DNNL_ARG_SRC: return src_md(0);
+            case DNNL_ARG_DIFF_WEIGHTS: return diff_weights_md(0);
+            case DNNL_ARG_DIFF_BIAS: return diff_weights_md(1);
+            case DNNL_ARG_DIFF_DST: return diff_dst_md(0, user_input);
+            default: return convolution_pd_t::arg_md(arg);
+        }
+    }
+
+    const memory_desc_t *src_md(
+            int index = 0, bool user_input = false) const override {
+        if (index == 0) return user_input ? &desc()->src_desc : &src_md_;
+        return &glob_zero_md;
+    }
+    const memory_desc_t *diff_dst_md(
+            int index = 0, bool user_input = false) const override {
+        if (index == 0)
+            return user_input ? &desc()->diff_dst_desc : &diff_dst_md_;
+        return &glob_zero_md;
+    }
+    const memory_desc_t *diff_weights_md(
+            int index = 0, bool user_input = false) const override {
+        if (index == 0)
+            return user_input ? &desc()->diff_weights_desc : &diff_weights_md_;
+        if (index == 1)
+            return user_input ? &desc()->diff_bias_desc : &diff_bias_md_;
+        return &glob_zero_md;
+    }
+
+    int n_inputs() const override { return 2; }
+    int n_outputs() const override { return 1 + with_bias(); }
+
+protected:
+    memory_desc_t src_md_;
+    memory_desc_t diff_weights_md_;
+    memory_desc_t diff_bias_md_;
+    memory_desc_t diff_dst_md_;
+
+    bool set_default_formats_common(format_tag_t src_tag,
+            format_tag_t diff_wei_tag, format_tag_t diff_dst_tag) {
+        return set_default_formats_common_template(src_md_, src_tag,
+                diff_weights_md_, diff_wei_tag, diff_dst_md_, diff_dst_tag,
+                diff_bias_md_);
+    }
+};
+
+} // namespace impl
+} // namespace dnnl
+
+#endif
+
+// vim: et ts=4 sw=4 cindent cino+=l0,\:4,N-s

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/common/cpp_compat.hpp

@@ -0,0 +1,54 @@
+/*******************************************************************************
+* Copyright 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.
+*******************************************************************************/
+
+#ifndef COMMON_CPP_COMPAT_HPP
+#define COMMON_CPP_COMPAT_HPP
+
+#include <exception>
+#include <type_traits>
+
+namespace dnnl {
+namespace impl {
+namespace cpp_compat {
+
+// oneDNN relies on C++11 standard. However, for DPCPP runtime the standard we
+// use to build oneDNN must be C++17 per requirements. Some C++11 features have
+// been deprecated in C++17, which triggers deprecations warnings. This file
+// contains a compatibility layer for such C++ features.
+
+// Older than C++17.
+#if defined(__cplusplus) && __cplusplus < 201703L
+inline int uncaught_exceptions() {
+    return (int)std::uncaught_exception();
+}
+
+template <class F, class... ArgTypes>
+using invoke_result = std::result_of<F(ArgTypes...)>;
+#else
+
+inline int uncaught_exceptions() {
+    return std::uncaught_exceptions();
+}
+
+template <class F, class... ArgTypes>
+using invoke_result = std::invoke_result<F, ArgTypes...>;
+
+#endif
+} // namespace cpp_compat
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/common/dnnl_thread.hpp

@@ -0,0 +1,678 @@
+/*******************************************************************************
+* Copyright 2017-2023 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.
+*******************************************************************************/
+
+#ifndef COMMON_DNNL_THREAD_HPP
+#define COMMON_DNNL_THREAD_HPP
+
+#include <algorithm>
+#include <functional>
+#include <mutex>
+
+#include "utils.hpp"
+#include "z_magic.hpp"
+
+// IMPORTANT NOTICE:
+// This header is special in the library since it enables all threading
+// functionality in the product including tests.
+// tests/test_thread.{c,h}pp files rely on this header file by:
+// * Substituting `threadpool_utils` namespace to re-use threadpool functions
+//   and enable a second threadpool different from the library;
+// * Re-defining `DNNL_CPU_THREADING_RUNTIME` macro value when it is supposed
+//   to be `DNNL_RUNTIME_SEQ`, e.g., for CPU_NONE configuration.
+//      1. It implies all parts of code relying on this macro should stay in the
+//         file.
+//      2. It implies there are no function bodies in the translation units
+//         related to the library. Tests threading layer uses dnnl::impl::func
+//         signature, and if library has symbols defined, regardless of
+//         redefinition, it will take those that were compiled with original
+//         macro value.
+//
+// Potential drawback could be increased binary size but it doesn't happen much
+// due to linker optimizations. The newer compiler and C++ standard, the less
+// binary size will be achieved.
+
+#if DNNL_CPU_THREADING_RUNTIME == DNNL_RUNTIME_THREADPOOL
+#include "counting_barrier.hpp"
+#endif
+
+#if defined(DNNL_ENABLE_ITT_TASKS)
+#include "common/ittnotify.hpp"
+#endif
+
+#if DNNL_CPU_THREADING_RUNTIME == DNNL_RUNTIME_SEQ
+#define DNNL_THR_SYNC 1
+inline int dnnl_get_max_threads() {
+    return 1;
+}
+inline int dnnl_in_parallel() {
+    return 0;
+}
+inline void dnnl_thr_barrier() {}
+
+#elif DNNL_CPU_THREADING_RUNTIME == DNNL_RUNTIME_OMP
+#include "omp.h"
+#define DNNL_THR_SYNC 1
+inline int dnnl_get_max_threads() {
+    return omp_get_max_threads();
+}
+inline int dnnl_in_parallel() {
+    return omp_in_parallel();
+}
+inline void dnnl_thr_barrier() {
+#pragma omp barrier
+}
+
+#elif DNNL_CPU_THREADING_RUNTIME == DNNL_RUNTIME_TBB
+#include "tbb/parallel_for.h"
+#include "tbb/task_arena.h"
+#define DNNL_THR_SYNC 0
+inline int dnnl_get_max_threads() {
+    return tbb::this_task_arena::max_concurrency();
+}
+inline int dnnl_in_parallel() {
+    return 0;
+}
+inline void dnnl_thr_barrier() {
+    assert(!"no barrier in TBB");
+}
+
+#elif DNNL_CPU_THREADING_RUNTIME == DNNL_RUNTIME_THREADPOOL
+#include <thread>
+#include "oneapi/dnnl/dnnl_threadpool_iface.hpp"
+#define DNNL_THR_SYNC 0
+
+#include "cpu/platform.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace threadpool_utils {
+
+// Each thread maintains a thread-local pointer to a threadpool which is
+// 'active' for the current thread. If this pointer is a nullptr, all the work
+// is executed sequentially.
+
+// Sets `tp` to be the active threadpool for the calling thread. This will
+// make all calls to `get_active_threadpool()` to return `tp` thus enabling
+// `parallel()` and `parallel_nd()` to submit work to `tp`.
+void activate_threadpool(dnnl::threadpool_interop::threadpool_iface *tp);
+
+// Resets the active threadpool for the calling thread to nullptr. After this
+// call `parallel()` and `parallel_nd()` would execute work sequentially.
+void deactivate_threadpool();
+
+// Returns the active threadpool for the calling thread.
+dnnl::threadpool_interop::threadpool_iface *get_active_threadpool();
+
+// returns the maximum concurrency available in the given global context
+int get_max_concurrency();
+
+int &get_threadlocal_max_concurrency();
+
+} // namespace threadpool_utils
+} // namespace impl
+} // namespace dnnl
+
+inline int dnnl_get_max_threads() {
+    using namespace dnnl::impl::threadpool_utils;
+    dnnl::threadpool_interop::threadpool_iface *tp = get_active_threadpool();
+
+    // This is the maximum number of threads oneDNN will use by default
+    int max_concurrency = dnnl::impl::threadpool_utils::get_max_concurrency();
+
+    // Use the default max_concurrency only when no tp is passed by
+    // user (e.g. primitive creation).
+    return tp ? std::max(1, tp->get_num_threads()) : max_concurrency;
+}
+inline int dnnl_in_parallel() {
+    using namespace dnnl::impl::threadpool_utils;
+    dnnl::threadpool_interop::threadpool_iface *tp = get_active_threadpool();
+    return tp ? tp->get_in_parallel() : 0;
+}
+inline void dnnl_thr_barrier() {
+    assert(!"no barrier with THREADPOOL");
+}
+#endif
+
+/* The purpose of this function is to provide the number of threads the library
+ * is aware of when this function is invoked. Since oneDNN does not allow nested
+ * parallelism, inside a parallel region the number of available threads is 1.
+ * Otherwise, the number of current threads varies between threading runtimes:
+ * - for OpenMP and TBB, return the max number of threads since the number of
+ *   threads is held in a global object throughout the entire execution.
+ * - for Threadpool, since the global object in oneDNN changes throughout
+ *   execution, two situations can occur:
+ *   a) if the library *is* aware of a threadpool when this function is invoked,
+ *   return the number of available threads in the threadpool;
+ *   b) if the library *is not* aware of a threadpool when this function is
+ *   invoked, return 1 since the main thread will do the work.
+ */
+inline int dnnl_get_current_num_threads() {
+    if (dnnl_in_parallel()) return 1;
+#if DNNL_CPU_THREADING_RUNTIME == DNNL_RUNTIME_OMP
+    return omp_get_max_threads();
+#elif DNNL_CPU_THREADING_RUNTIME == DNNL_RUNTIME_TBB
+    return tbb::this_task_arena::max_concurrency();
+#elif DNNL_CPU_THREADING_RUNTIME == DNNL_RUNTIME_THREADPOOL
+    using namespace dnnl::impl::threadpool_utils;
+    dnnl::threadpool_interop::threadpool_iface *tp = get_active_threadpool();
+    return (tp) ? dnnl_get_max_threads() : 1;
+#else
+    return 1;
+#endif
+}
+
+#if DNNL_CPU_THREADING_RUNTIME == DNNL_RUNTIME_OMP
+#define PRAGMA_OMP(...) PRAGMA_MACRO(CHAIN2(omp, __VA_ARGS__))
+#define OMP_GET_THREAD_NUM() omp_get_thread_num()
+#define OMP_GET_NUM_THREADS() omp_get_num_threads()
+#else
+#define PRAGMA_OMP(...)
+#define OMP_GET_THREAD_NUM() 0
+#define OMP_GET_NUM_THREADS() 1
+#endif
+
+// MSVC still supports omp 2.0 only
+#if defined(_MSC_VER) && !defined(__clang__) && !defined(__INTEL_COMPILER)
+#define collapse(x)
+#define PRAGMA_OMP_SIMD(...)
+#else
+#define PRAGMA_OMP_SIMD(...) PRAGMA_MACRO(CHAIN2(omp, simd __VA_ARGS__))
+#endif // defined(_MSC_VER) && !defined(__clang__) && !defined(__INTEL_COMPILER)
+
+// process simdlen; it is supported for Clang >= 3.9; ICC >= 17.0; GCC >= 6.1
+// No support on Windows.
+#if (defined(__clang_major__) \
+        && (__clang_major__ < 3 \
+                || (__clang_major__ == 3 && __clang_minor__ < 9))) \
+        || (defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1700) \
+        || (!defined(__INTEL_COMPILER) && !defined(__clang__) \
+                && (defined(_MSC_VER) || __GNUC__ < 6 \
+                        || (__GNUC__ == 6 && __GNUC_MINOR__ < 1)))
+#define simdlen(x)
+#endif // long simdlen if
+
+namespace dnnl {
+namespace impl {
+
+inline bool dnnl_thr_syncable() {
+    return DNNL_THR_SYNC == 1;
+}
+
+template <typename T, typename U>
+inline void balance211(T n, U team, U tid, T &n_start, T &n_end) {
+    T n_min = 1;
+    T &n_my = n_end;
+    if (team <= 1 || n == 0) {
+        n_start = 0;
+        n_my = n;
+    } else if (n_min == 1) {
+        // team = T1 + T2
+        // n = T1*n1 + T2*n2  (n1 - n2 = 1)
+        T n1 = utils::div_up(n, (T)team);
+        T n2 = n1 - 1;
+        T T1 = n - n2 * (T)team;
+        n_my = (T)tid < T1 ? n1 : n2;
+        n_start = (T)tid <= T1 ? (T)tid * n1 : T1 * n1 + ((T)tid - T1) * n2;
+    }
+
+    n_end += n_start;
+}
+
+template <typename T, typename U>
+void balance2D(U nthr, U ithr, T ny, T &ny_start, T &ny_end, T nx, T &nx_start,
+        T &nx_end, T nx_divider) {
+    const T grp_count = nstl::min(nx_divider, static_cast<T>(nthr));
+    const int grp_size_big = nthr / static_cast<int>(grp_count) + 1;
+    const int grp_size_small = nthr / static_cast<int>(grp_count);
+    const int n_grp_big = nthr % static_cast<int>(grp_count);
+    const int threads_in_big_groups = n_grp_big * grp_size_big;
+
+    const int ithr_bound_distance = ithr - threads_in_big_groups;
+    T grp, grp_ithr, grp_nthr;
+    if (ithr_bound_distance < 0) { // ithr in first groups
+        grp = ithr / grp_size_big;
+        grp_ithr = ithr % grp_size_big;
+        grp_nthr = grp_size_big;
+    } else { // ithr in last groups
+        grp = n_grp_big + ithr_bound_distance / grp_size_small;
+        grp_ithr = ithr_bound_distance % grp_size_small;
+        grp_nthr = grp_size_small;
+    }
+
+    balance211(nx, grp_count, grp, nx_start, nx_end);
+    balance211(ny, grp_nthr, grp_ithr, ny_start, ny_end);
+}
+
+/* Functions:
+ *  - parallel(nthr, f)                  - executes f in parallel using at
+ *                                         most nthr threads. If nthr equals
+ *                                         0 dnnl_get_current_num_threads() threads
+ *                                         is used
+ *  - for_nd(ithr, nthr, dims..., f)     - multidimensional for loop for
+ *                                         already created threads
+ *  - for_nd_ext(ithr, nthr, dims..., f) - multidimensional for loop for
+ *                                         already created threads that passes
+ *                                         ithr and nthr
+ *  - parallel_nd(dims..., f)            - creates a parallel section and then
+ *                                         calls for_nd
+ *  - parallel_nd_ext(dims..., f)        - creates a parallel section and then
+ *                                         calls for_nd_ext
+ *  - parallel_nd_in_omp(dims..., f)     - queries current nthr and ithr and
+ *                                         then calls for_nd (mostly for
+ *                                         convenience)
+ */
+
+/* general parallelization */
+inline int adjust_num_threads(int nthr, dim_t work_amount) {
+    if (nthr == 0) nthr = dnnl_get_current_num_threads();
+#if DNNL_CPU_THREADING_RUNTIME == DNNL_RUNTIME_OMP
+    return (work_amount == 1 || omp_in_parallel()) ? 1 : nthr;
+#else
+    return (int)std::min((dim_t)nthr, work_amount);
+#endif
+}
+
+static inline void parallel(int nthr, const std::function<void(int, int)> &f) {
+    nthr = adjust_num_threads(nthr, INT64_MAX);
+#if DNNL_CPU_THREADING_RUNTIME == DNNL_RUNTIME_SEQ
+    for (int i = 0; i < nthr; ++i) {
+        f(i, nthr);
+    }
+#else
+#if defined(DNNL_ENABLE_ITT_TASKS)
+    auto task_primitive_kind = itt::primitive_task_get_current_kind();
+    bool itt_enable = itt::get_itt(itt::__itt_task_level_high);
+#endif
+    if (nthr == 1) {
+        f(0, 1);
+        return;
+    }
+#if DNNL_CPU_THREADING_RUNTIME == DNNL_RUNTIME_OMP
+#pragma omp parallel num_threads(nthr)
+    {
+        int nthr_ = omp_get_num_threads();
+        int ithr_ = omp_get_thread_num();
+        assert(nthr_ == nthr);
+#if defined(DNNL_ENABLE_ITT_TASKS)
+        if (ithr_ && itt_enable) itt::primitive_task_start(task_primitive_kind);
+#endif
+        f(ithr_, nthr_);
+#if defined(DNNL_ENABLE_ITT_TASKS)
+        if (ithr_ && itt_enable) itt::primitive_task_end();
+#endif
+    }
+#elif DNNL_CPU_THREADING_RUNTIME == DNNL_RUNTIME_TBB
+    tbb::parallel_for(
+            0, nthr,
+            [&](int ithr) {
+#if defined(DNNL_ENABLE_ITT_TASKS)
+                bool mark_task = itt::primitive_task_get_current_kind()
+                        == primitive_kind::undefined;
+                if (mark_task && itt_enable)
+                    itt::primitive_task_start(task_primitive_kind);
+#endif
+                f(ithr, nthr);
+#if defined(DNNL_ENABLE_ITT_TASKS)
+                if (mark_task && itt_enable) itt::primitive_task_end();
+#endif
+            },
+            tbb::static_partitioner());
+#elif DNNL_CPU_THREADING_RUNTIME == DNNL_RUNTIME_THREADPOOL
+    using namespace dnnl::impl::threadpool_utils;
+    dnnl::threadpool_interop::threadpool_iface *tp = get_active_threadpool();
+    if (!tp || dnnl_in_parallel()) {
+        threadpool_utils::deactivate_threadpool();
+        for (int ithr = 0; ithr < nthr; ithr++) {
+            f(ithr, nthr);
+        }
+        threadpool_utils::activate_threadpool(tp);
+    } else {
+        bool async = tp->get_flags()
+                & dnnl::threadpool_interop::threadpool_iface::ASYNCHRONOUS;
+        counting_barrier_t b;
+        if (async) b.init(nthr);
+        tp->parallel_for(nthr, [&, tp](int ithr, int nthr) {
+            bool is_master = threadpool_utils::get_active_threadpool() == tp;
+            if (!is_master) {
+                threadpool_utils::activate_threadpool(tp);
+#if defined(DNNL_ENABLE_ITT_TASKS)
+                if (itt_enable) itt::primitive_task_start(task_primitive_kind);
+#endif
+            }
+            f(ithr, nthr);
+            if (!is_master) {
+#if defined(DNNL_ENABLE_ITT_TASKS)
+                if (itt_enable) itt::primitive_task_end();
+#endif
+                threadpool_utils::deactivate_threadpool();
+            }
+            if (async) b.notify();
+        });
+        if (async) b.wait();
+    }
+#endif
+#endif
+}
+
+// XXX: IMPORTANT!!!
+// Keep the functions below static.
+//
+// The threading file is included in gtests and benchdnn. When
+// the functions are not static it can cause a crash in gtests and
+// benchdnn on macOS with Intel 2021 compiler.
+
+/* for_nd section */
+static inline void for_nd(const int ithr, const int nthr, dim_t D0,
+        const std::function<void(dim_t)> &f) {
+    dim_t start {0}, end {0};
+    balance211(D0, nthr, ithr, start, end);
+    for (dim_t d0 = start; d0 < end; ++d0)
+        f(d0);
+}
+static inline void for_nd(const int ithr, const int nthr, dim_t D0, dim_t D1,
+        const std::function<void(dim_t, dim_t)> &f) {
+    const dim_t work_amount = D0 * D1;
+    if (work_amount == 0) return;
+    dim_t start {0}, end {0};
+    balance211(work_amount, nthr, ithr, start, end);
+
+    dim_t d0 {0}, d1 {0};
+    utils::nd_iterator_init(start, d0, D0, d1, D1);
+    for (dim_t iwork = start; iwork < end; ++iwork) {
+        f(d0, d1);
+        utils::nd_iterator_step(d0, D0, d1, D1);
+    }
+}
+static inline void for_nd(const int ithr, const int nthr, dim_t D0, dim_t D1,
+        dim_t D2, const std::function<void(dim_t, dim_t, dim_t)> &f) {
+    const dim_t work_amount = D0 * D1 * D2;
+    if (work_amount == 0) return;
+    dim_t start {0}, end {0};
+    balance211(work_amount, nthr, ithr, start, end);
+
+    dim_t d0 {0}, d1 {0}, d2 {0};
+    utils::nd_iterator_init(start, d0, D0, d1, D1, d2, D2);
+    for (dim_t iwork = start; iwork < end; ++iwork) {
+        f(d0, d1, d2);
+        utils::nd_iterator_step(d0, D0, d1, D1, d2, D2);
+    }
+}
+static inline void for_nd(const int ithr, const int nthr, dim_t D0, dim_t D1,
+        dim_t D2, dim_t D3,
+        const std::function<void(dim_t, dim_t, dim_t, dim_t)> &f) {
+    const dim_t work_amount = D0 * D1 * D2 * D3;
+    if (work_amount == 0) return;
+    dim_t start {0}, end {0};
+    balance211(work_amount, nthr, ithr, start, end);
+
+    dim_t d0 {0}, d1 {0}, d2 {0}, d3 {0};
+    utils::nd_iterator_init(start, d0, D0, d1, D1, d2, D2, d3, D3);
+    for (dim_t iwork = start; iwork < end; ++iwork) {
+        f(d0, d1, d2, d3);
+        utils::nd_iterator_step(d0, D0, d1, D1, d2, D2, d3, D3);
+    }
+}
+static inline void for_nd(const int ithr, const int nthr, dim_t D0, dim_t D1,
+        dim_t D2, dim_t D3, dim_t D4,
+        const std::function<void(dim_t, dim_t, dim_t, dim_t, dim_t)> &f) {
+    const dim_t work_amount = D0 * D1 * D2 * D3 * D4;
+    if (work_amount == 0) return;
+    dim_t start {0}, end {0};
+    balance211(work_amount, nthr, ithr, start, end);
+
+    dim_t d0 {0}, d1 {0}, d2 {0}, d3 {0}, d4 {0};
+    utils::nd_iterator_init(start, d0, D0, d1, D1, d2, D2, d3, D3, d4, D4);
+    for (dim_t iwork = start; iwork < end; ++iwork) {
+        f(d0, d1, d2, d3, d4);
+        utils::nd_iterator_step(d0, D0, d1, D1, d2, D2, d3, D3, d4, D4);
+    }
+}
+static inline void for_nd(const int ithr, const int nthr, dim_t D0, dim_t D1,
+        dim_t D2, dim_t D3, dim_t D4, dim_t D5,
+        const std::function<void(dim_t, dim_t, dim_t, dim_t, dim_t, dim_t)>
+                &f) {
+    const dim_t work_amount = D0 * D1 * D2 * D3 * D4 * D5;
+    if (work_amount == 0) return;
+    dim_t start {0}, end {0};
+    balance211(work_amount, nthr, ithr, start, end);
+
+    dim_t d0 {0}, d1 {0}, d2 {0}, d3 {0}, d4 {0}, d5 {0};
+    utils::nd_iterator_init(
+            start, d0, D0, d1, D1, d2, D2, d3, D3, d4, D4, d5, D5);
+    for (dim_t iwork = start; iwork < end; ++iwork) {
+        f(d0, d1, d2, d3, d4, d5);
+        utils::nd_iterator_step(d0, D0, d1, D1, d2, D2, d3, D3, d4, D4, d5, D5);
+    }
+}
+
+/* for_nd_ext section */
+static inline void for_nd_ext(const int ithr, const int nthr, dim_t D0,
+        const std::function<void(int, int, dim_t)> &f) {
+    dim_t start {0}, end {0};
+    balance211(D0, nthr, ithr, start, end);
+    for (dim_t d0 = start; d0 < end; ++d0)
+        f(ithr, nthr, d0);
+}
+static inline void for_nd_ext(const int ithr, const int nthr, dim_t D0,
+        dim_t D1, const std::function<void(int, int, dim_t, dim_t)> &f) {
+    const dim_t work_amount = D0 * D1;
+    if (work_amount == 0) return;
+    dim_t start {0}, end {0};
+    balance211(work_amount, nthr, ithr, start, end);
+
+    dim_t d0 {0}, d1 {0};
+    utils::nd_iterator_init(start, d0, D0, d1, D1);
+    for (dim_t iwork = start; iwork < end; ++iwork) {
+        f(ithr, nthr, d0, d1);
+        utils::nd_iterator_step(d0, D0, d1, D1);
+    }
+}
+static inline void for_nd_ext(const int ithr, const int nthr, dim_t D0,
+        dim_t D1, dim_t D2,
+        const std::function<void(int, int, dim_t, dim_t, dim_t)> &f) {
+    const dim_t work_amount = D0 * D1 * D2;
+    if (work_amount == 0) return;
+    dim_t start {0}, end {0};
+    balance211(work_amount, nthr, ithr, start, end);
+
+    dim_t d0 {0}, d1 {0}, d2 {0};
+    utils::nd_iterator_init(start, d0, D0, d1, D1, d2, D2);
+    for (dim_t iwork = start; iwork < end; ++iwork) {
+        f(ithr, nthr, d0, d1, d2);
+        utils::nd_iterator_step(d0, D0, d1, D1, d2, D2);
+    }
+}
+static inline void for_nd_ext(const int ithr, const int nthr, dim_t D0,
+        dim_t D1, dim_t D2, dim_t D3,
+        const std::function<void(int, int, dim_t, dim_t, dim_t, dim_t)> &f) {
+    const dim_t work_amount = D0 * D1 * D2 * D3;
+    if (work_amount == 0) return;
+    dim_t start {0}, end {0};
+    balance211(work_amount, nthr, ithr, start, end);
+
+    dim_t d0 {0}, d1 {0}, d2 {0}, d3 {0};
+    utils::nd_iterator_init(start, d0, D0, d1, D1, d2, D2, d3, D3);
+    for (dim_t iwork = start; iwork < end; ++iwork) {
+        f(ithr, nthr, d0, d1, d2, d3);
+        utils::nd_iterator_step(d0, D0, d1, D1, d2, D2, d3, D3);
+    }
+}
+static inline void for_nd_ext(const int ithr, const int nthr, dim_t D0,
+        dim_t D1, dim_t D2, dim_t D3, dim_t D4,
+        const std::function<void(int, int, dim_t, dim_t, dim_t, dim_t, dim_t)>
+                &f) {
+    const dim_t work_amount = D0 * D1 * D2 * D3 * D4;
+    if (work_amount == 0) return;
+    dim_t start {0}, end {0};
+    balance211(work_amount, nthr, ithr, start, end);
+
+    dim_t d0 {0}, d1 {0}, d2 {0}, d3 {0}, d4 {0};
+    utils::nd_iterator_init(start, d0, D0, d1, D1, d2, D2, d3, D3, d4, D4);
+    for (dim_t iwork = start; iwork < end; ++iwork) {
+        f(ithr, nthr, d0, d1, d2, d3, d4);
+        utils::nd_iterator_step(d0, D0, d1, D1, d2, D2, d3, D3, d4, D4);
+    }
+}
+static inline void for_nd_ext(const int ithr, const int nthr, dim_t D0,
+        dim_t D1, dim_t D2, dim_t D3, dim_t D4, dim_t D5,
+        const std::function<void(
+                int, int, dim_t, dim_t, dim_t, dim_t, dim_t, dim_t)> &f) {
+    const dim_t work_amount = D0 * D1 * D2 * D3 * D4 * D5;
+    if (work_amount == 0) return;
+    dim_t start {0}, end {0};
+    balance211(work_amount, nthr, ithr, start, end);
+
+    dim_t d0 {0}, d1 {0}, d2 {0}, d3 {0}, d4 {0}, d5 {0};
+    utils::nd_iterator_init(
+            start, d0, D0, d1, D1, d2, D2, d3, D3, d4, D4, d5, D5);
+    for (dim_t iwork = start; iwork < end; ++iwork) {
+        f(ithr, nthr, d0, d1, d2, d3, d4, d5);
+        utils::nd_iterator_step(d0, D0, d1, D1, d2, D2, d3, D3, d4, D4, d5, D5);
+    }
+}
+
+/* parallel_nd_ext section */
+static inline void parallel_nd_ext(
+        int nthr, dim_t D0, const std::function<void(int, int, dim_t)> &f) {
+    const dim_t work_amount = D0;
+    nthr = adjust_num_threads(nthr, work_amount);
+    if (nthr)
+        parallel(nthr,
+                [&](int ithr, int nthr) { for_nd_ext(ithr, nthr, D0, f); });
+}
+static inline void parallel_nd_ext(int nthr, dim_t D0, dim_t D1,
+        const std::function<void(int, int, dim_t, dim_t)> &f) {
+    const dim_t work_amount = D0 * D1;
+    nthr = adjust_num_threads(nthr, work_amount);
+    if (nthr)
+        parallel(nthr,
+                [&](int ithr, int nthr) { for_nd_ext(ithr, nthr, D0, D1, f); });
+}
+static inline void parallel_nd_ext(int nthr, dim_t D0, dim_t D1, dim_t D2,
+        const std::function<void(int, int, dim_t, dim_t, dim_t)> &f) {
+    const dim_t work_amount = D0 * D1 * D2;
+    nthr = adjust_num_threads(nthr, work_amount);
+    if (nthr)
+        parallel(nthr, [&](int ithr, int nthr) {
+            for_nd_ext(ithr, nthr, D0, D1, D2, f);
+        });
+}
+static inline void parallel_nd_ext(int nthr, dim_t D0, dim_t D1, dim_t D2,
+        dim_t D3,
+        const std::function<void(int, int, dim_t, dim_t, dim_t, dim_t)> &f) {
+    const dim_t work_amount = D0 * D1 * D2 * D3;
+    nthr = adjust_num_threads(nthr, work_amount);
+    if (nthr)
+        parallel(nthr, [&](int ithr, int nthr) {
+            for_nd_ext(ithr, nthr, D0, D1, D2, D3, f);
+        });
+}
+static inline void parallel_nd_ext(int nthr, dim_t D0, dim_t D1, dim_t D2,
+        dim_t D3, dim_t D4,
+        const std::function<void(int, int, dim_t, dim_t, dim_t, dim_t, dim_t)>
+                &f) {
+    const dim_t work_amount = D0 * D1 * D2 * D3 * D4;
+    nthr = adjust_num_threads(nthr, work_amount);
+    if (nthr)
+        parallel(nthr, [&](int ithr, int nthr) {
+            for_nd_ext(ithr, nthr, D0, D1, D2, D3, D4, f);
+        });
+}
+static inline void parallel_nd_ext(int nthr, dim_t D0, dim_t D1, dim_t D2,
+        dim_t D3, dim_t D4, dim_t D5,
+        const std::function<void(
+                int, int, dim_t, dim_t, dim_t, dim_t, dim_t, dim_t)> &f) {
+    const dim_t work_amount = D0 * D1 * D2 * D3 * D4 * D5;
+    nthr = adjust_num_threads(nthr, work_amount);
+    if (nthr)
+        parallel(nthr, [&](int ithr, int nthr) {
+            for_nd_ext(ithr, nthr, D0, D1, D2, D3, D4, D5, f);
+        });
+}
+
+/* parallel_nd section */
+static inline void parallel_nd(dim_t D0, const std::function<void(dim_t)> &f) {
+    int nthr = adjust_num_threads(dnnl_get_current_num_threads(), D0);
+    if (nthr)
+        parallel(nthr, [&](int ithr, int nthr) { for_nd(ithr, nthr, D0, f); });
+}
+static inline void parallel_nd(
+        dim_t D0, dim_t D1, const std::function<void(dim_t, dim_t)> &f) {
+    const dim_t work_amount = D0 * D1;
+    int nthr = adjust_num_threads(dnnl_get_current_num_threads(), work_amount);
+    if (nthr)
+        parallel(nthr,
+                [&](int ithr, int nthr) { for_nd(ithr, nthr, D0, D1, f); });
+}
+static inline void parallel_nd(dim_t D0, dim_t D1, dim_t D2,
+        const std::function<void(dim_t, dim_t, dim_t)> &f) {
+    const dim_t work_amount = D0 * D1 * D2;
+    int nthr = adjust_num_threads(dnnl_get_current_num_threads(), work_amount);
+    if (nthr)
+        parallel(nthr,
+                [&](int ithr, int nthr) { for_nd(ithr, nthr, D0, D1, D2, f); });
+}
+static inline void parallel_nd(dim_t D0, dim_t D1, dim_t D2, dim_t D3,
+        const std::function<void(dim_t, dim_t, dim_t, dim_t)> &f) {
+    const dim_t work_amount = D0 * D1 * D2 * D3;
+    int nthr = adjust_num_threads(dnnl_get_current_num_threads(), work_amount);
+    if (nthr)
+        parallel(nthr, [&](int ithr, int nthr) {
+            for_nd(ithr, nthr, D0, D1, D2, D3, f);
+        });
+}
+static inline void parallel_nd(dim_t D0, dim_t D1, dim_t D2, dim_t D3, dim_t D4,
+        const std::function<void(dim_t, dim_t, dim_t, dim_t, dim_t)> &f) {
+    const dim_t work_amount = D0 * D1 * D2 * D3 * D4;
+    int nthr = adjust_num_threads(dnnl_get_current_num_threads(), work_amount);
+    if (nthr)
+        parallel(nthr, [&](int ithr, int nthr) {
+            for_nd(ithr, nthr, D0, D1, D2, D3, D4, f);
+        });
+}
+static inline void parallel_nd(dim_t D0, dim_t D1, dim_t D2, dim_t D3, dim_t D4,
+        dim_t D5,
+        const std::function<void(dim_t, dim_t, dim_t, dim_t, dim_t, dim_t)>
+                &f) {
+    const dim_t work_amount = D0 * D1 * D2 * D3 * D4 * D5;
+    int nthr = adjust_num_threads(dnnl_get_current_num_threads(), work_amount);
+    if (nthr)
+        parallel(nthr, [&](int ithr, int nthr) {
+            for_nd(ithr, nthr, D0, D1, D2, D3, D4, D5, f);
+        });
+}
+
+/* parallel_nd_in_omp section */
+
+template <typename... Args>
+void parallel_nd_in_omp(Args &&...args) {
+#if DNNL_CPU_THREADING_RUNTIME == DNNL_RUNTIME_SEQ
+    for_nd(0, 1, utils::forward<Args>(args)...);
+#elif DNNL_CPU_THREADING_RUNTIME == DNNL_RUNTIME_OMP
+    for_nd(omp_get_thread_num(), omp_get_num_threads(),
+            utils::forward<Args>(args)...);
+#elif (DNNL_CPU_THREADING_RUNTIME == DNNL_RUNTIME_TBB \
+        || DNNL_CPU_THREADING_RUNTIME == DNNL_RUNTIME_THREADPOOL)
+    assert(!"parallel_nd_in_omp() is not supported by this DNNL_CPU_RUNTIME");
+#endif
+}
+
+} // namespace impl
+} // namespace dnnl
+
+#endif
+
+// vim: et ts=4 sw=4 cindent cino+=l0,\:4,N-s

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/common/dnnl_traits.hpp

@@ -0,0 +1,151 @@
+/*******************************************************************************
+* Copyright 2016-2023 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.
+*******************************************************************************/
+
+#ifndef COMMON_DNNL_TRAITS_HPP
+#define COMMON_DNNL_TRAITS_HPP
+
+#include <assert.h>
+#include <stdint.h>
+
+#include "oneapi/dnnl/dnnl.h"
+
+#include "bfloat16.hpp"
+#include "c_types_map.hpp"
+#include "float16.hpp"
+#include "nstl.hpp"
+#include "opdesc.hpp"
+#include "utils.hpp"
+#include "z_magic.hpp"
+
+namespace dnnl {
+namespace impl {
+
+template <data_type_t>
+struct prec_traits {}; /* ::type -> float */
+template <typename>
+struct data_traits {}; /* ::data_type -> f32 */
+template <int>
+struct typesize_traits {}; /* ::data_type_size -> f32 */
+template <primitive_kind_t>
+struct pkind_traits {}; /* ::desc_type, ::query_d */
+
+template <>
+struct prec_traits<data_type::f16> {
+    typedef float16_t type;
+};
+template <>
+struct prec_traits<data_type::bf16> {
+    typedef bfloat16_t type;
+};
+template <>
+struct prec_traits<data_type::f32> {
+    typedef float type;
+};
+template <>
+struct prec_traits<data_type::f64> {
+    typedef double type;
+};
+template <>
+struct prec_traits<data_type::s32> {
+    typedef int32_t type;
+};
+template <>
+struct prec_traits<data_type::s8> {
+    typedef int8_t type;
+};
+template <>
+struct prec_traits<data_type::u8> {
+    typedef uint8_t type;
+};
+template <>
+struct prec_traits<data_type::boolean> {
+    typedef bool type;
+};
+
+template <>
+struct data_traits<float16_t> {
+    static constexpr data_type_t data_type = data_type::f16;
+};
+template <>
+struct data_traits<bfloat16_t> {
+    static constexpr data_type_t data_type = data_type::bf16;
+};
+template <>
+struct data_traits<float> {
+    static constexpr data_type_t data_type = data_type::f32;
+};
+template <>
+struct data_traits<int32_t> {
+    static constexpr data_type_t data_type = data_type::s32;
+};
+template <>
+struct data_traits<int8_t> {
+    static constexpr data_type_t data_type = data_type::s8;
+};
+template <>
+struct data_traits<uint8_t> {
+    static constexpr data_type_t data_type = data_type::u8;
+};
+template <>
+struct data_traits<bool> {
+    static constexpr data_type_t data_type = data_type::boolean;
+};
+
+template <>
+struct typesize_traits<4> {
+    typedef float type;
+};
+template <>
+struct typesize_traits<2> {
+    typedef int16_t type;
+};
+template <>
+struct typesize_traits<1> {
+    typedef uint8_t type;
+};
+
+#define PKIND_TRAITS_INST(op) \
+    template <> \
+    struct pkind_traits<primitive_kind::op> { \
+        typedef CONCAT2(op, _desc_t) desc_type; \
+    }
+PKIND_TRAITS_INST(convolution);
+PKIND_TRAITS_INST(deconvolution);
+PKIND_TRAITS_INST(shuffle);
+PKIND_TRAITS_INST(eltwise);
+PKIND_TRAITS_INST(softmax);
+PKIND_TRAITS_INST(pooling);
+PKIND_TRAITS_INST(prelu);
+PKIND_TRAITS_INST(lrn);
+PKIND_TRAITS_INST(batch_normalization);
+PKIND_TRAITS_INST(group_normalization);
+PKIND_TRAITS_INST(layer_normalization);
+PKIND_TRAITS_INST(inner_product);
+PKIND_TRAITS_INST(rnn);
+PKIND_TRAITS_INST(gemm);
+PKIND_TRAITS_INST(zero_pad);
+PKIND_TRAITS_INST(binary);
+PKIND_TRAITS_INST(matmul);
+PKIND_TRAITS_INST(resampling);
+PKIND_TRAITS_INST(reduction);
+#undef PKIND_TRAITS_INST
+
+} // namespace impl
+} // namespace dnnl
+
+#endif
+
+// vim: et ts=4 sw=4 cindent cino+=l0,\:4,N-s

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/common/eltwise_pd.hpp

@@ -0,0 +1,298 @@
+/*******************************************************************************
+* Copyright 2016-2023 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.
+*******************************************************************************/
+
+#ifndef COMMON_ELTWISE_PD_HPP
+#define COMMON_ELTWISE_PD_HPP
+
+#include "oneapi/dnnl/dnnl.h"
+
+#include "c_types_map.hpp"
+#include "primitive_desc.hpp"
+
+namespace dnnl {
+namespace impl {
+
+struct eltwise_fwd_pd_t;
+
+status_t eltwise_desc_init(eltwise_desc_t *eltwise_desc, prop_kind_t prop_kind,
+        alg_kind_t alg_kind, const memory_desc_t *src_desc,
+        const memory_desc_t *dst_desc, const memory_desc_t *diff_src_desc,
+        const memory_desc_t *diff_dst_desc, float alpha, float beta);
+
+struct eltwise_pd_t : public primitive_desc_t {
+    static constexpr auto base_pkind = primitive_kind::eltwise;
+
+    const eltwise_desc_t *desc() const { return &desc_; }
+    const op_desc_t *op_desc() const override {
+        return reinterpret_cast<const op_desc_t *>(this->desc());
+    }
+
+    status_t query(query_t what, int idx, void *result) const override {
+        switch (what) {
+            case query::prop_kind:
+                *(prop_kind_t *)result = desc()->prop_kind;
+                break;
+            case query::alg_kind:
+                *(alg_kind_t *)result = desc()->alg_kind;
+                break;
+            case query::alpha_f32: *(float *)result = desc()->alpha; break;
+            case query::beta_f32: *(float *)result = desc()->beta; break;
+            default: return primitive_desc_t::query(what, idx, result);
+        }
+        return status::success;
+    }
+
+    /* common eltwise aux functions */
+
+    dim_t MB() const { return data_md()->dims[0]; }
+    dim_t C() const { return ndims() >= 2 ? data_md()->dims[1] : 1; }
+    dim_t D() const { return ndims() >= 5 ? data_md()->dims[ndims() - 3] : 1; }
+    dim_t H() const { return ndims() >= 4 ? data_md()->dims[ndims() - 2] : 1; }
+    dim_t W() const { return ndims() >= 3 ? data_md()->dims[ndims() - 1] : 1; }
+
+    int ndims() const { return data_md()->ndims; }
+
+    bool is_fwd() const {
+        return utils::one_of(desc_.prop_kind, prop_kind::forward_training,
+                prop_kind::forward_inference);
+    }
+
+    bool has_zero_dim_memory() const {
+        return memory_desc_wrapper(data_md()).has_zero_dim();
+    }
+
+    bool use_dst() const {
+        using namespace alg_kind;
+        return !is_fwd()
+                && utils::one_of(desc_.alg_kind, eltwise_relu_use_dst_for_bwd,
+                        eltwise_tanh_use_dst_for_bwd,
+                        eltwise_elu_use_dst_for_bwd,
+                        eltwise_sqrt_use_dst_for_bwd,
+                        eltwise_logistic_use_dst_for_bwd,
+                        eltwise_exp_use_dst_for_bwd,
+                        eltwise_clip_v2_use_dst_for_bwd);
+    }
+
+protected:
+    eltwise_desc_t desc_;
+    const eltwise_fwd_pd_t *hint_fwd_pd_;
+
+    memory_desc_t src_md_;
+    memory_desc_t dst_md_;
+
+    eltwise_pd_t(const eltwise_desc_t *adesc, const primitive_attr_t *attr,
+            const eltwise_fwd_pd_t *hint_fwd_pd)
+        : primitive_desc_t(attr, base_pkind)
+        , desc_(*adesc)
+        , hint_fwd_pd_(hint_fwd_pd)
+        , src_md_(desc_.src_desc)
+        , dst_md_(desc_.dst_desc) {}
+
+private:
+    const memory_desc_t *data_md(int index = 0) const {
+        return use_dst() ? dst_md(index) : src_md(index);
+    }
+};
+
+struct eltwise_fwd_pd_t : public eltwise_pd_t {
+    typedef eltwise_fwd_pd_t base_class;
+    typedef eltwise_fwd_pd_t hint_class;
+
+    arg_usage_t arg_usage(int arg) const override {
+        if (arg == DNNL_ARG_SRC) return arg_usage_t::input;
+
+        if (arg == DNNL_ARG_DST) return arg_usage_t::output;
+
+        return primitive_desc_t::arg_usage(arg);
+    }
+
+    const memory_desc_t *arg_md(
+            int arg, bool user_input = false) const override {
+        switch (arg) {
+            case DNNL_ARG_SRC: return src_md(0);
+            case DNNL_ARG_DST: return dst_md(0, user_input);
+            default: return eltwise_pd_t::arg_md(arg);
+        }
+    }
+
+    const memory_desc_t *src_md(
+            int index = 0, bool user_input = false) const override {
+        if (index == 0) return user_input ? &desc()->src_desc : &src_md_;
+        return &glob_zero_md;
+    }
+    const memory_desc_t *dst_md(
+            int index = 0, bool user_input = false) const override {
+        if (index == 0) return user_input ? &desc()->dst_desc : &dst_md_;
+        return &glob_zero_md;
+    }
+
+    int n_inputs() const override { return 1 + n_binary_po_inputs(); }
+    int n_outputs() const override { return 1; }
+
+    static bool eltwise_preserves_zero(
+            alg_kind_t alg, float alpha, float beta) {
+        using namespace alg_kind;
+        using namespace utils;
+        return one_of(alg, eltwise_relu, eltwise_tanh, eltwise_elu,
+                       eltwise_square, eltwise_abs, eltwise_sqrt, eltwise_swish,
+                       eltwise_gelu_tanh, eltwise_gelu_erf, eltwise_round,
+                       eltwise_hardswish)
+                || one_of(alg, eltwise_relu_use_dst_for_bwd,
+                        eltwise_tanh_use_dst_for_bwd,
+                        eltwise_elu_use_dst_for_bwd,
+                        eltwise_sqrt_use_dst_for_bwd)
+                || (one_of(alg, eltwise_clip, eltwise_clip_v2) && alpha <= 0
+                        && beta >= 0)
+                || (alg == eltwise_linear && beta == 0)
+                || (alg == eltwise_pow && beta > 0);
+    }
+
+    static bool eltwise_preserves_zero(
+            const post_ops_t::entry_t::eltwise_t &eltwise) {
+        return eltwise_preserves_zero(eltwise.alg, eltwise.alpha, eltwise.beta);
+    }
+
+    bool is_zero_preserved() const {
+        return eltwise_preserves_zero(desc_.alg_kind, desc_.alpha, desc_.beta);
+    }
+
+protected:
+    eltwise_fwd_pd_t(const eltwise_desc_t *adesc, const primitive_attr_t *attr,
+            const eltwise_fwd_pd_t *hint_fwd_pd)
+        : eltwise_pd_t(adesc, attr, hint_fwd_pd) {}
+
+    bool set_default_formats_common() {
+        return IMPLICATION(dst_md_.format_kind == format_kind::any,
+                memory_desc_init_by_md_and_dt(
+                        dst_md_, src_md_, dst_md_.data_type)
+                        == status::success);
+    }
+};
+
+struct eltwise_bwd_pd_t : public eltwise_pd_t {
+    typedef eltwise_bwd_pd_t base_class;
+    typedef eltwise_fwd_pd_t hint_class;
+
+    arg_usage_t arg_usage(int arg) const override {
+        if (use_dst() ? arg == DNNL_ARG_DST : arg == DNNL_ARG_SRC)
+            return arg_usage_t::input;
+
+        if (arg == DNNL_ARG_DIFF_DST) return arg_usage_t::input;
+        if (arg == DNNL_ARG_DIFF_SRC) return arg_usage_t::output;
+
+        return primitive_desc_t::arg_usage(arg);
+    }
+
+    const memory_desc_t *arg_md(
+            int arg, bool user_input = false) const override {
+        switch (arg) {
+            case DNNL_ARG_SRC: return src_md(0);
+            case DNNL_ARG_DST: return dst_md(0, user_input);
+            case DNNL_ARG_DIFF_SRC: return diff_src_md(0);
+            case DNNL_ARG_DIFF_DST: return diff_dst_md(0, user_input);
+            default: return eltwise_pd_t::arg_md(arg);
+        }
+    }
+
+    // To avoid additional logic in implementations
+    const memory_desc_t *data_md(int index = 0) const {
+        return use_dst() ? dst_md(index) : src_md(index);
+    }
+    const memory_desc_t *src_md(
+            int index = 0, bool user_input = false) const override {
+        if (index == 0 && !use_dst())
+            return user_input ? &desc()->src_desc : &src_md_;
+        return &glob_zero_md;
+    }
+    const memory_desc_t *dst_md(
+            int index = 0, bool user_input = false) const override {
+        if (index == 0 && use_dst())
+            return user_input ? &desc()->dst_desc : &dst_md_;
+        return &glob_zero_md;
+    }
+    const memory_desc_t *diff_dst_md(
+            int index = 0, bool user_input = false) const override {
+        if (index == 0)
+            return user_input ? &desc()->diff_dst_desc : &diff_dst_md_;
+        return &glob_zero_md;
+    }
+    const memory_desc_t *diff_src_md(
+            int index = 0, bool user_input = false) const override {
+        if (index == 0)
+            return user_input ? &desc()->diff_src_desc : &diff_src_md_;
+        return &glob_zero_md;
+    }
+
+    int n_inputs() const override { return 2; }
+    int n_outputs() const override { return 1; }
+
+    static bool eltwise_preserves_zero(
+            alg_kind_t alg, float alpha, float beta) {
+        // Unlike forward counterpart, bwd works on two tensors (with same formats)
+        // and if alg moves zero to non-zero, it's fine, because diff_dst will
+        // still have zeros in padding and multiplication of zero and non-zero
+        // gives desired result. However, it doesn't work in case of special fp
+        // values which are NaN or infinity which give NaN when multiplying on
+        // zero, so excluding all those algs from here.
+        using namespace alg_kind;
+        using namespace utils;
+        return one_of(alg, eltwise_abs, eltwise_clip, eltwise_clip_v2,
+                       eltwise_elu, eltwise_exp, eltwise_gelu_erf,
+                       eltwise_gelu_tanh, eltwise_hardsigmoid, eltwise_linear,
+                       eltwise_logistic, eltwise_mish, eltwise_relu,
+                       eltwise_soft_relu, eltwise_square, eltwise_swish,
+                       eltwise_tanh)
+                || one_of(alg, eltwise_elu_use_dst_for_bwd,
+                        eltwise_exp_use_dst_for_bwd,
+                        eltwise_logistic_use_dst_for_bwd,
+                        eltwise_relu_use_dst_for_bwd,
+                        eltwise_tanh_use_dst_for_bwd,
+                        eltwise_clip_v2_use_dst_for_bwd)
+                || (alg == eltwise_pow && beta >= 1);
+    }
+
+    bool is_zero_preserved() const {
+        return eltwise_preserves_zero(desc_.alg_kind, desc_.alpha, desc_.beta);
+    }
+
+protected:
+    memory_desc_t diff_src_md_;
+    memory_desc_t diff_dst_md_;
+
+    eltwise_bwd_pd_t(const eltwise_desc_t *adesc, const primitive_attr_t *attr,
+            const eltwise_fwd_pd_t *hint_fwd_pd)
+        : eltwise_pd_t(adesc, attr, hint_fwd_pd)
+        , diff_src_md_(desc_.diff_src_desc)
+        , diff_dst_md_(desc_.diff_dst_desc) {}
+
+    bool set_default_formats_common() {
+        return IMPLICATION(diff_dst_md_.format_kind == format_kind::any,
+                       memory_desc_init_by_md_and_dt(
+                               diff_dst_md_, *data_md(), diff_dst_md_.data_type)
+                               == status::success)
+                && IMPLICATION(diff_src_md_.format_kind == format_kind::any,
+                        memory_desc_init_by_md_and_dt(diff_src_md_, *data_md(),
+                                diff_src_md_.data_type)
+                                == status::success);
+    }
+};
+
+} // namespace impl
+} // namespace dnnl
+
+#endif
+
+// vim: et ts=4 sw=4 cindent cino+=l0,\:4,N-s

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/common/experimental.hpp

@@ -0,0 +1,29 @@
+/*******************************************************************************
+* Copyright 2022 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.
+*******************************************************************************/
+#ifndef EXPERIMENTAL_HPP
+#define EXPERIMENTAL_HPP
+
+namespace dnnl {
+namespace impl {
+namespace experimental {
+
+bool use_bnorm_stats_one_pass();
+
+} // namespace experimental
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/common/gemm_pd.hpp

@@ -0,0 +1,119 @@
+/*******************************************************************************
+* Copyright 2019-2023 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.
+*******************************************************************************/
+
+#ifndef COMMON_GEMM_PD_HPP
+#define COMMON_GEMM_PD_HPP
+
+#include "oneapi/dnnl/dnnl.h"
+
+#include "common/c_types_map.hpp"
+#include "common/gemm_utils.hpp"
+#include "common/primitive_desc.hpp"
+#include "common/utils.hpp"
+
+namespace dnnl {
+namespace impl {
+
+struct gemm_pd_t : public primitive_desc_t {
+    static constexpr auto base_pkind = primitive_kind::gemm;
+
+    typedef gemm_pd_t base_class;
+    typedef gemm_pd_t hint_class;
+
+    const gemm_desc_t *desc() const { return &desc_; }
+    const op_desc_t *op_desc() const override {
+        return reinterpret_cast<const op_desc_t *>(this->desc());
+    }
+
+    arg_usage_t arg_usage(int arg) const override {
+        if (utils::one_of(arg, DNNL_ARG_SRC_0, DNNL_ARG_SRC_1))
+            return arg_usage_t::input;
+
+        if (arg == DNNL_ARG_DST) return arg_usage_t::output;
+
+        return primitive_desc_t::arg_usage(arg);
+    }
+
+    const memory_desc_t *arg_md(
+            int arg, bool user_input = false) const override {
+        switch (arg) {
+            case DNNL_ARG_SRC_0: return src_md(0);
+            case DNNL_ARG_SRC_1: return src_md(1);
+            case DNNL_ARG_BIAS: return src_md(2);
+            case DNNL_ARG_DST: return dst_md(0, user_input);
+            default: return primitive_desc_t::arg_md(arg);
+        }
+    }
+
+    const memory_desc_t *src_md(
+            int index = 0, bool user_input = false) const override {
+        switch (index) {
+            case 0: return &desc_.a_desc;
+            case 1: return &desc_.b_desc;
+            case 2: return &desc_.bias_desc;
+            default: return &glob_zero_md;
+        }
+    }
+    const memory_desc_t *dst_md(
+            int index = 0, bool user_input = false) const override {
+        return index == 0 ? &desc_.c_desc : &glob_zero_md;
+    }
+    bool with_bias() const { return desc_.bias_desc.ndims != 0; }
+
+    int n_inputs() const override { return 2; }
+    int n_outputs() const override { return 1; }
+
+protected:
+    // Note: we do not copy memory desc locally to avoid
+    // overheads. This means we lose the users memory descs when we
+    // resolve the 'any' tags.
+    gemm_desc_t desc_;
+
+    gemm_pd_t(const gemm_desc_t *adesc, const primitive_attr_t *attr,
+            const hint_class *hint_fwd_pd)
+        : primitive_desc_t(attr, base_pkind), desc_(*adesc) {}
+
+    // By default, we just resolve 'any' with blocked layout and trivial strides
+    bool set_default_format(memory_desc_t *md) {
+        memory_desc_wrapper mdw(md);
+        if (mdw.format_any()) {
+            if (mdw.has_runtime_dims_or_strides()) return false;
+            status_t status = memory_desc_init_by_strides(*md, nullptr);
+            if (status != status::success) return false;
+        }
+
+        return true;
+    }
+
+    bool set_default_formats() {
+        bool ok = true;
+
+        for (auto md : {&desc_.a_desc, &desc_.b_desc, &desc_.bias_desc,
+                     &desc_.c_desc}) {
+            ok = ok && set_default_format(md);
+        }
+
+        auto status = attr_.post_ops_.set_default_formats(&desc_.c_desc);
+        ok = ok && (status == status::success);
+
+        return ok;
+    }
+};
+
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/common/gemm_types.hpp

@@ -0,0 +1,161 @@
+/*******************************************************************************
+* Copyright 2019-2023 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.
+*******************************************************************************/
+
+#ifndef COMMON_GEMM_TYPES_HPP
+#define COMMON_GEMM_TYPES_HPP
+
+#include <assert.h>
+#include "common/c_types_map.hpp"
+#include "common/memory_desc.hpp"
+
+namespace dnnl {
+namespace impl {
+
+enum transpose_t { dnnl_notrans, dnnl_trans };
+
+namespace transpose {
+const transpose_t notrans = dnnl_notrans;
+const transpose_t trans = dnnl_trans;
+} // namespace transpose
+
+enum offsetc_t { dnnl_fixed, dnnl_column, dnnl_row };
+
+namespace offsetc {
+const offsetc_t fixed = dnnl_fixed;
+const offsetc_t column = dnnl_column;
+const offsetc_t row = dnnl_row;
+} // namespace offsetc
+
+enum sum_ab_t { dnnl_sum_a_row, dnnl_sum_b_col, dnnl_sum_none };
+namespace sum_ab {
+const sum_ab_t sum_a_row = dnnl_sum_a_row;
+const sum_ab_t sum_b_col = dnnl_sum_b_col;
+const sum_ab_t sum_none = dnnl_sum_none;
+} // namespace sum_ab
+
+// A descriptor for a matrix multiplication (gemm) operation. To make the
+// interface consistent, the descriptor represent the GEMM operation in row
+// major.
+struct gemm_desc_t {
+    // The kind of primitive. Used for self identifying the primitive
+    // descriptor. Must be #dnnl_gemm.
+    dnnl_primitive_kind_t primitive_kind;
+    memory_desc_t a_desc;
+    memory_desc_t b_desc;
+    memory_desc_t c_desc;
+    memory_desc_t bias_desc;
+    // Type for accumulating A*B.
+    dnnl_data_type_t acc_type;
+    // Sum across k dimension in either A or B tensor
+    // and output to sum_ab tensor.
+    sum_ab_t sum_ab;
+    dnnl_data_type_t sum_ab_type;
+
+    // These accessors are to be used by the GEMM implementation. Because the
+    // GEMM implementation currently assumes column major. These accessors
+    // return data in column major fashion.
+
+    inline bool is_batched() const { return c_desc.ndims >= 3; }
+
+    // Simplified accessors that comply to GEMM API
+    transpose_t get_trans(const memory_desc_t &md) const {
+        return md.format_desc.blocking.strides[md.ndims - 1] != 1
+                ? transpose::trans
+                : transpose::notrans;
+    }
+    transpose_t transa() const { return get_trans(b_desc); };
+    transpose_t transb() const { return get_trans(a_desc); };
+    transpose_t trans_bias() const { return get_trans(bias_desc); }
+
+    dnnl_dim_t batch() const {
+        // if ndims < 3, it should return 1
+        int64_t batch = 1;
+        for (int i = 0; i < c_desc.ndims - 2; ++i) {
+            if (c_desc.dims[i] == DNNL_RUNTIME_DIM_VAL)
+                return DNNL_RUNTIME_DIM_VAL;
+            batch *= c_desc.dims[i];
+        }
+        return batch;
+    }
+
+    // Number of rows of C.
+    dnnl_dim_t m() const { return c_desc.dims[c_desc.ndims - 1]; }
+    // Number of columns of C.
+    dnnl_dim_t n() const { return c_desc.dims[c_desc.ndims - 2]; }
+    // Size of inner dimension shared between A and B.
+    dnnl_dim_t k() const { return a_desc.dims[a_desc.ndims - 1]; }
+
+    static dnnl_dim_t get_stride(const memory_desc_t &md, int dim = 0) {
+        return (dim >= md.ndims - 2 || md.dims[dim] == 1)
+                ? 0
+                : md.format_desc.blocking.strides[dim];
+    }
+
+    /** Stride between 2 matrices A in a batch. */
+    dnnl_dim_t stride_a(int dim = 0) const { return get_stride(b_desc, dim); };
+    /** Stride between 2 matrices B in a batch. */
+    dnnl_dim_t stride_b(int dim = 0) const { return get_stride(a_desc, dim); };
+    /** Stride between 2 matrices C in a batch. */
+    dnnl_dim_t stride_c(int dim = 0) const { return get_stride(c_desc, dim); };
+
+    // This assumes that one of the dimensions has strides 1
+    static dnnl_dim_t get_ld(const memory_desc_t &md) {
+        auto strides = md.format_desc.blocking.strides;
+        assert(strides[md.ndims - 1] == 1 || strides[md.ndims - 2] == 1);
+        return strides[md.ndims - 1] != 1 ? strides[md.ndims - 1]
+                                          : strides[md.ndims - 2];
+    }
+    // Leading dimension of A.
+    dnnl_dim_t lda() const { return get_ld(b_desc); }
+    // Leading dimension of B.
+    dnnl_dim_t ldb() const { return get_ld(a_desc); }
+    // Leading dimension of C.
+    dnnl_dim_t ldc() const { return get_ld(c_desc); }
+    /** Leading dimension of bias. */
+    dnnl_dim_t ld_bias() const { return get_ld(bias_desc); }
+
+    // Type of matrix A.
+    dnnl_data_type_t a_type() const { return b_desc.data_type; }
+    // Type of matrix B.
+    dnnl_data_type_t b_type() const { return a_desc.data_type; }
+    // Type of matrix C.
+    dnnl_data_type_t c_type() const { return c_desc.data_type; }
+    // Type of bias.
+    dnnl_data_type_t bias_type() const { return bias_desc.data_type; }
+    // Type of bias.
+    int bias_mask() const {
+        assert(bias_desc.ndims <= 3);
+        int mask = 0;
+        // TODO: update the mask for batched dimension if we start
+        // supporting more batch dimensions
+        if (is_batched()) mask |= (bias_desc.dims[0] > 1) ? 1 << 0 : 0;
+
+        // because the bias mask is in row major, we have to convert
+        // to col major here by swapping two last dimensions
+        int m_idx = is_batched();
+        mask |= (bias_desc.dims[m_idx] > 1) ? 1 << (bias_desc.ndims - m_idx)
+                                            : 0;
+        mask |= (bias_desc.dims[m_idx + 1] > 1)
+                ? 1 << (bias_desc.ndims - (m_idx + 1))
+                : 0;
+        return mask;
+    }
+};
+
+} // namespace impl
+} // namespace dnnl
+
+#endif // COMMON_GEMM_TYPES_HPP

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/common/impl_registration.hpp

@@ -0,0 +1,235 @@
+/*******************************************************************************
+* Copyright 2021-2023 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.
+*******************************************************************************/
+
+#ifndef COMMON_IMPL_REGISTRATION_HPP
+#define COMMON_IMPL_REGISTRATION_HPP
+
+#include "oneapi/dnnl/dnnl_config.h"
+
+// Workload section
+
+// Note: REG_BWD_D_PK is a dedicated macro for deconv to enable bwd_d conv.
+#if BUILD_TRAINING
+#define REG_BWD_PK(...) __VA_ARGS__
+#define REG_BWD_D_PK(...) __VA_ARGS__
+#else
+#define REG_BWD_PK(...) \
+    { nullptr }
+#define REG_BWD_D_PK(...) \
+    { nullptr }
+#endif
+
+// Primitives section
+
+// Note:
+// `_P` is a mandatory suffix for macros. This is to avoid a conflict with
+// `REG_BINARY`, Windows-defined macro.
+
+#if BUILD_PRIMITIVE_ALL || BUILD_BATCH_NORMALIZATION
+#define REG_BNORM_P(...) __VA_ARGS__
+#else
+#define REG_BNORM_P(...) \
+    {}
+#endif
+
+#if BUILD_PRIMITIVE_ALL || BUILD_BINARY
+#define REG_BINARY_P(...) __VA_ARGS__
+#else
+#define REG_BINARY_P(...) \
+    { nullptr }
+#endif
+
+#if BUILD_PRIMITIVE_ALL || BUILD_CONCAT
+#define REG_CONCAT_P(...) __VA_ARGS__
+#else
+#define REG_CONCAT_P(...) \
+    { nullptr }
+#endif
+
+#if BUILD_PRIMITIVE_ALL || BUILD_CONVOLUTION
+#define REG_CONV_P(...) __VA_ARGS__
+#else
+#define REG_CONV_P(...) \
+    {}
+#endif
+
+#if BUILD_PRIMITIVE_ALL || BUILD_DECONVOLUTION
+#define REG_DECONV_P(...) __VA_ARGS__
+// This case is special, it requires handling of convolution_bwd_d internally
+// since major optimizations are based on convolution implementations.
+#ifndef REG_CONV_P
+#error "REG_CONV_P is not defined. Check that convolution is defined prior deconvolution."
+#else
+#undef REG_CONV_P
+#define REG_CONV_P(...) __VA_ARGS__
+#endif
+
+#ifndef REG_BWD_D_PK
+#error "REG_BWD_D_PK is not defined. Dedicated macro was not enabled."
+#else
+#undef REG_BWD_D_PK
+#define REG_BWD_D_PK(...) __VA_ARGS__
+#endif
+
+#else // BUILD_PRIMITIVE_ALL || BUILD_DECONVOLUTION
+#define REG_DECONV_P(...) \
+    {}
+#endif
+
+#if BUILD_PRIMITIVE_ALL || BUILD_ELTWISE
+#define REG_ELTWISE_P(...) __VA_ARGS__
+#else
+#define REG_ELTWISE_P(...) \
+    {}
+#endif
+
+#if BUILD_PRIMITIVE_ALL || BUILD_GROUP_NORMALIZATION
+#define REG_GNORM_P(...) __VA_ARGS__
+#else
+#define REG_GNORM_P(...) \
+    {}
+#endif
+
+#if BUILD_PRIMITIVE_ALL || BUILD_INNER_PRODUCT
+#define REG_IP_P(...) __VA_ARGS__
+#else
+#define REG_IP_P(...) \
+    {}
+#endif
+
+#if BUILD_PRIMITIVE_ALL || BUILD_LAYER_NORMALIZATION
+#define REG_LNORM_P(...) __VA_ARGS__
+#else
+#define REG_LNORM_P(...) \
+    {}
+#endif
+
+#if BUILD_PRIMITIVE_ALL || BUILD_LRN
+#define REG_LRN_P(...) __VA_ARGS__
+#else
+#define REG_LRN_P(...) \
+    {}
+#endif
+
+#if BUILD_PRIMITIVE_ALL || BUILD_MATMUL
+#define REG_MATMUL_P(...) __VA_ARGS__
+#else
+#define REG_MATMUL_P(...) \
+    { nullptr }
+#endif
+
+#if BUILD_PRIMITIVE_ALL || BUILD_POOLING
+#define REG_POOLING_P(...) __VA_ARGS__
+#else
+#define REG_POOLING_P(...) \
+    {}
+#endif
+
+#if BUILD_PRIMITIVE_ALL || BUILD_PRELU
+#define REG_PRELU_P(...) __VA_ARGS__
+#else
+#define REG_PRELU_P(...) \
+    {}
+#endif
+
+#if BUILD_PRIMITIVE_ALL || BUILD_REDUCTION
+#define REG_REDUCTION_P(...) __VA_ARGS__
+#else
+#define REG_REDUCTION_P(...) \
+    { nullptr }
+#endif
+
+#if BUILD_PRIMITIVE_ALL || BUILD_REORDER
+#define REG_REORDER_P(...) __VA_ARGS__
+#else
+#define REG_REORDER_P(...) \
+    {}
+#endif
+
+#if BUILD_PRIMITIVE_ALL || BUILD_RESAMPLING
+#define REG_RESAMPLING_P(...) __VA_ARGS__
+#else
+#define REG_RESAMPLING_P(...) \
+    {}
+#endif
+
+#if BUILD_PRIMITIVE_ALL || BUILD_RNN
+#define REG_RNN_P(...) __VA_ARGS__
+#else
+#define REG_RNN_P(...) \
+    {}
+#endif
+
+#if BUILD_PRIMITIVE_ALL || BUILD_SHUFFLE
+#define REG_SHUFFLE_P(...) __VA_ARGS__
+#else
+#define REG_SHUFFLE_P(...) \
+    { nullptr }
+#endif
+
+#if BUILD_PRIMITIVE_ALL || BUILD_SOFTMAX
+#define REG_SOFTMAX_P(...) __VA_ARGS__
+#else
+#define REG_SOFTMAX_P(...) \
+    {}
+#endif
+
+#if BUILD_PRIMITIVE_ALL || BUILD_SUM
+#define REG_SUM_P(...) __VA_ARGS__
+#else
+#define REG_SUM_P(...) \
+    { nullptr }
+#endif
+
+// Primitive CPU ISA section is in src/cpu/platform.hpp
+
+#if BUILD_PRIMITIVE_GPU_ISA_ALL || BUILD_GEN9
+#define REG_GEN9_ISA(...) __VA_ARGS__
+#else
+#define REG_GEN9_ISA(...)
+#endif
+
+#if BUILD_PRIMITIVE_GPU_ISA_ALL || BUILD_GEN11
+#define REG_GEN11_ISA(...) __VA_ARGS__
+#else
+#define REG_GEN11_ISA(...)
+#endif
+
+#if BUILD_PRIMITIVE_GPU_ISA_ALL || BUILD_XELP
+#define REG_XELP_ISA(...) __VA_ARGS__
+#else
+#define REG_XELP_ISA(...)
+#endif
+
+#if BUILD_PRIMITIVE_GPU_ISA_ALL || BUILD_XEHP
+#define REG_XEHP_ISA(...) __VA_ARGS__
+#else
+#define REG_XEHP_ISA(...)
+#endif
+
+#if BUILD_PRIMITIVE_GPU_ISA_ALL || BUILD_XEHPG
+#define REG_XEHPG_ISA(...) __VA_ARGS__
+#else
+#define REG_XEHPG_ISA(...)
+#endif
+
+#if BUILD_PRIMITIVE_GPU_ISA_ALL || BUILD_XEHPC
+#define REG_XEHPC_ISA(...) __VA_ARGS__
+#else
+#define REG_XEHPC_ISA(...)
+#endif
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/common/internal_defs.hpp

@@ -0,0 +1,36 @@
+/*******************************************************************************
+* Copyright 2020 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.
+*******************************************************************************/
+
+#ifndef COMMON_INTERNAL_DEFS_HPP
+#define COMMON_INTERNAL_DEFS_HPP
+
+#if defined(DNNL_DLL)
+#define DNNL_WEAK DNNL_HELPER_DLL_EXPORT
+#else
+#if defined(__GNUC__) || defined(__clang__)
+#define DNNL_WEAK __attribute__((weak))
+#else
+#define DNNL_WEAK
+#endif
+#endif
+
+#if defined(DNNL_DLL)
+#define DNNL_STRONG DNNL_HELPER_DLL_EXPORT
+#else
+#define DNNL_STRONG
+#endif
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/common/ittnotify/disable_warnings.h

@@ -0,0 +1,29 @@
+/*
+  Copyright (C) 2005-2019 Intel Corporation
+
+  SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause
+*/
+
+#include "ittnotify_config.h"
+
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+
+#if defined _MSC_VER
+
+#pragma warning (disable: 593)   /* parameter "XXXX" was set but never used                 */
+#pragma warning (disable: 344)   /* typedef name has already been declared (with same type) */
+#pragma warning (disable: 174)   /* expression has no effect                                */
+#pragma warning (disable: 4127)  /* conditional expression is constant                      */
+#pragma warning (disable: 4306)  /* conversion from '?' to '?' of greater size              */
+
+#endif
+
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+#if defined __INTEL_COMPILER
+
+#pragma warning (disable: 869)  /* parameter "XXXXX" was never referenced                  */
+#pragma warning (disable: 1418) /* external function definition with no prior declaration  */
+#pragma warning (disable: 1419) /* external declaration in primary source file             */
+
+#endif /* __INTEL_COMPILER */

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/common/ittnotify/ittnotify_config.h

@@ -0,0 +1,667 @@
+/*
+  Copyright (C) 2005-2019 Intel Corporation
+
+  SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause
+*/
+#ifndef _ITTNOTIFY_CONFIG_H_
+#define _ITTNOTIFY_CONFIG_H_
+
+/** @cond exclude_from_documentation */
+#ifndef ITT_OS_WIN
+#  define ITT_OS_WIN   1
+#endif /* ITT_OS_WIN */
+
+#ifndef ITT_OS_LINUX
+#  define ITT_OS_LINUX 2
+#endif /* ITT_OS_LINUX */
+
+#ifndef ITT_OS_MAC
+#  define ITT_OS_MAC   3
+#endif /* ITT_OS_MAC */
+
+#ifndef ITT_OS_FREEBSD
+#  define ITT_OS_FREEBSD   4
+#endif /* ITT_OS_FREEBSD */
+
+#ifndef ITT_OS
+#  if defined WIN32 || defined _WIN32
+#    define ITT_OS ITT_OS_WIN
+#  elif defined( __APPLE__ ) && defined( __MACH__ )
+#    define ITT_OS ITT_OS_MAC
+#  elif defined( __FreeBSD__ )
+#    define ITT_OS ITT_OS_FREEBSD
+#  else
+#    define ITT_OS ITT_OS_LINUX
+#  endif
+#endif /* ITT_OS */
+
+#ifndef ITT_PLATFORM_WIN
+#  define ITT_PLATFORM_WIN 1
+#endif /* ITT_PLATFORM_WIN */
+
+#ifndef ITT_PLATFORM_POSIX
+#  define ITT_PLATFORM_POSIX 2
+#endif /* ITT_PLATFORM_POSIX */
+
+#ifndef ITT_PLATFORM_MAC
+#  define ITT_PLATFORM_MAC 3
+#endif /* ITT_PLATFORM_MAC */
+
+#ifndef ITT_PLATFORM_FREEBSD
+#  define ITT_PLATFORM_FREEBSD 4
+#endif /* ITT_PLATFORM_FREEBSD */
+
+#ifndef ITT_PLATFORM
+#  if ITT_OS==ITT_OS_WIN
+#    define ITT_PLATFORM ITT_PLATFORM_WIN
+#  elif ITT_OS==ITT_OS_MAC
+#    define ITT_PLATFORM ITT_PLATFORM_MAC
+#  elif ITT_OS==ITT_OS_FREEBSD
+#    define ITT_PLATFORM ITT_PLATFORM_FREEBSD
+#  else
+#    define ITT_PLATFORM ITT_PLATFORM_POSIX
+#  endif
+#endif /* ITT_PLATFORM */
+
+#if defined(_UNICODE) && !defined(UNICODE)
+#define UNICODE
+#endif
+
+#include <stddef.h>
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#include <tchar.h>
+#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#include <stdint.h>
+#if defined(UNICODE) || defined(_UNICODE)
+#include <wchar.h>
+#endif /* UNICODE || _UNICODE */
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+#ifndef ITTAPI_CDECL
+#  if ITT_PLATFORM==ITT_PLATFORM_WIN
+#    define ITTAPI_CDECL __cdecl
+#  else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#    if defined _M_IX86 || defined __i386__
+#      define ITTAPI_CDECL __attribute__ ((cdecl))
+#    else  /* _M_IX86 || __i386__ */
+#      define ITTAPI_CDECL /* actual only on x86 platform */
+#    endif /* _M_IX86 || __i386__ */
+#  endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* ITTAPI_CDECL */
+
+#ifndef STDCALL
+#  if ITT_PLATFORM==ITT_PLATFORM_WIN
+#    define STDCALL __stdcall
+#  else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#    if defined _M_IX86 || defined __i386__
+#      define STDCALL __attribute__ ((stdcall))
+#    else  /* _M_IX86 || __i386__ */
+#      define STDCALL /* supported only on x86 platform */
+#    endif /* _M_IX86 || __i386__ */
+#  endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* STDCALL */
+
+#define ITTAPI    ITTAPI_CDECL
+#define LIBITTAPI ITTAPI_CDECL
+
+/* TODO: Temporary for compatibility! */
+#define ITTAPI_CALL    ITTAPI_CDECL
+#define LIBITTAPI_CALL ITTAPI_CDECL
+
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+/* use __forceinline (VC++ specific) */
+#if defined(__MINGW32__) && !defined(__cplusplus)
+#define ITT_INLINE           static __inline__ __attribute__((__always_inline__,__gnu_inline__))
+#else
+#define ITT_INLINE           static __forceinline
+#endif /* __MINGW32__ */
+
+#define ITT_INLINE_ATTRIBUTE /* nothing */
+#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+/*
+ * Generally, functions are not inlined unless optimization is specified.
+ * For functions declared inline, this attribute inlines the function even
+ * if no optimization level was specified.
+ */
+#ifdef __STRICT_ANSI__
+#define ITT_INLINE           static
+#define ITT_INLINE_ATTRIBUTE __attribute__((unused))
+#else  /* __STRICT_ANSI__ */
+#define ITT_INLINE           static inline
+#define ITT_INLINE_ATTRIBUTE __attribute__((always_inline, unused))
+#endif /* __STRICT_ANSI__ */
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+/** @endcond */
+
+#ifndef ITT_ARCH_IA32
+#  define ITT_ARCH_IA32  1
+#endif /* ITT_ARCH_IA32 */
+
+#ifndef ITT_ARCH_IA32E
+#  define ITT_ARCH_IA32E 2
+#endif /* ITT_ARCH_IA32E */
+
+#ifndef ITT_ARCH_IA64
+#  define ITT_ARCH_IA64 3
+#endif /* ITT_ARCH_IA64 */
+
+#ifndef ITT_ARCH_ARM
+#  define ITT_ARCH_ARM  4
+#endif /* ITT_ARCH_ARM */
+
+#ifndef ITT_ARCH_PPC64
+#  define ITT_ARCH_PPC64  5
+#endif /* ITT_ARCH_PPC64 */
+
+#ifndef ITT_ARCH_ARM64
+#  define ITT_ARCH_ARM64  6
+#endif /* ITT_ARCH_ARM64 */
+
+#ifndef ITT_ARCH
+#  if defined _M_IX86 || defined __i386__
+#    define ITT_ARCH ITT_ARCH_IA32
+#  elif defined _M_X64 || defined _M_AMD64 || defined __x86_64__
+#    define ITT_ARCH ITT_ARCH_IA32E
+#  elif defined _M_IA64 || defined __ia64__
+#    define ITT_ARCH ITT_ARCH_IA64
+#  elif defined _M_ARM || defined __arm__
+#    define ITT_ARCH ITT_ARCH_ARM
+#  elif defined __aarch64__
+#    define ITT_ARCH ITT_ARCH_ARM64
+#  elif defined __powerpc64__
+#    define ITT_ARCH ITT_ARCH_PPC64
+#  endif
+#endif
+
+#ifdef __cplusplus
+#  define ITT_EXTERN_C extern "C"
+#  define ITT_EXTERN_C_BEGIN extern "C" {
+#  define ITT_EXTERN_C_END }
+#else
+#  define ITT_EXTERN_C /* nothing */
+#  define ITT_EXTERN_C_BEGIN /* nothing */
+#  define ITT_EXTERN_C_END /* nothing */
+#endif /* __cplusplus */
+
+#define ITT_TO_STR_AUX(x) #x
+#define ITT_TO_STR(x)     ITT_TO_STR_AUX(x)
+
+#define __ITT_BUILD_ASSERT(expr, suffix) do { \
+    static char __itt_build_check_##suffix[(expr) ? 1 : -1]; \
+    __itt_build_check_##suffix[0] = 0; \
+} while(0)
+#define _ITT_BUILD_ASSERT(expr, suffix)  __ITT_BUILD_ASSERT((expr), suffix)
+#define ITT_BUILD_ASSERT(expr)           _ITT_BUILD_ASSERT((expr), __LINE__)
+
+#define ITT_MAGIC { 0xED, 0xAB, 0xAB, 0xEC, 0x0D, 0xEE, 0xDA, 0x30 }
+
+/* Replace with snapshot date YYYYMMDD for promotion build. */
+#define API_VERSION_BUILD    20180723
+
+#ifndef API_VERSION_NUM
+#define API_VERSION_NUM 3.23.0
+#endif /* API_VERSION_NUM */
+
+#define API_VERSION "ITT-API-Version " ITT_TO_STR(API_VERSION_NUM) \
+                                " (" ITT_TO_STR(API_VERSION_BUILD) ")"
+
+/* OS communication functions */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#include <windows.h>
+typedef HMODULE           lib_t;
+typedef DWORD             TIDT;
+typedef CRITICAL_SECTION  mutex_t;
+#ifdef __cplusplus
+#define MUTEX_INITIALIZER {}
+#else
+#define MUTEX_INITIALIZER { 0 }
+#endif
+#define strong_alias(name, aliasname) /* empty for Windows */
+#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#include <dlfcn.h>
+#if defined(UNICODE) || defined(_UNICODE)
+#include <wchar.h>
+#endif /* UNICODE */
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE 1 /* need for PTHREAD_MUTEX_RECURSIVE */
+#endif /* _GNU_SOURCE */
+#ifndef __USE_UNIX98
+#define __USE_UNIX98 1 /* need for PTHREAD_MUTEX_RECURSIVE, on SLES11.1 with gcc 4.3.4 wherein pthread.h missing dependency on __USE_XOPEN2K8 */
+#endif /*__USE_UNIX98*/
+#include <pthread.h>
+typedef void*             lib_t;
+typedef pthread_t         TIDT;
+typedef pthread_mutex_t   mutex_t;
+#define MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
+#define _strong_alias(name, aliasname) \
+            extern __typeof (name) aliasname __attribute__ ((alias (#name)));
+#define strong_alias(name, aliasname) _strong_alias(name, aliasname)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_get_proc(lib, name) GetProcAddress(lib, name)
+#define __itt_mutex_init(mutex)   InitializeCriticalSection(mutex)
+#define __itt_mutex_lock(mutex)   EnterCriticalSection(mutex)
+#define __itt_mutex_unlock(mutex) LeaveCriticalSection(mutex)
+#define __itt_mutex_destroy(mutex) DeleteCriticalSection(mutex)
+#define __itt_load_lib(name)      LoadLibraryA(name)
+#define __itt_unload_lib(handle)  FreeLibrary(handle)
+#define __itt_system_error()      (int)GetLastError()
+#define __itt_fstrcmp(s1, s2)     lstrcmpA(s1, s2)
+#define __itt_fstrnlen(s, l)      strnlen_s(s, l)
+#define __itt_fstrcpyn(s1, b, s2, l) strncpy_s(s1, b, s2, l)
+#define __itt_thread_id()         GetCurrentThreadId()
+#define __itt_thread_yield()      SwitchToThread()
+#ifndef ITT_SIMPLE_INIT
+ITT_INLINE long
+__itt_interlocked_increment(volatile long* ptr) ITT_INLINE_ATTRIBUTE;
+ITT_INLINE long __itt_interlocked_increment(volatile long* ptr)
+{
+    return InterlockedIncrement(ptr);
+}
+ITT_INLINE long
+__itt_interlocked_compare_exchange(volatile long* ptr, long exchange, long comperand) ITT_INLINE_ATTRIBUTE;
+ITT_INLINE long
+__itt_interlocked_compare_exchange(volatile long* ptr, long exchange, long comperand)
+{
+    return InterlockedCompareExchange(ptr, exchange, comperand);
+}
+#endif /* ITT_SIMPLE_INIT */
+
+#define DL_SYMBOLS (1)
+#define PTHREAD_SYMBOLS (1)
+
+#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+#define __itt_get_proc(lib, name) dlsym(lib, name)
+#define __itt_mutex_init(mutex)   {\
+    pthread_mutexattr_t mutex_attr;                                         \
+    int error_code = pthread_mutexattr_init(&mutex_attr);                   \
+    if (error_code)                                                         \
+        __itt_report_error(__itt_error_system, "pthread_mutexattr_init",    \
+                           error_code);                                     \
+    error_code = pthread_mutexattr_settype(&mutex_attr,                     \
+                                           PTHREAD_MUTEX_RECURSIVE);        \
+    if (error_code)                                                         \
+        __itt_report_error(__itt_error_system, "pthread_mutexattr_settype", \
+                           error_code);                                     \
+    error_code = pthread_mutex_init(mutex, &mutex_attr);                    \
+    if (error_code)                                                         \
+        __itt_report_error(__itt_error_system, "pthread_mutex_init",        \
+                           error_code);                                     \
+    error_code = pthread_mutexattr_destroy(&mutex_attr);                    \
+    if (error_code)                                                         \
+        __itt_report_error(__itt_error_system, "pthread_mutexattr_destroy", \
+                           error_code);                                     \
+}
+#define __itt_mutex_lock(mutex)   pthread_mutex_lock(mutex)
+#define __itt_mutex_unlock(mutex) pthread_mutex_unlock(mutex)
+#define __itt_mutex_destroy(mutex) pthread_mutex_destroy(mutex)
+#define __itt_load_lib(name)      dlopen(name, RTLD_LAZY)
+#define __itt_unload_lib(handle)  dlclose(handle)
+#define __itt_system_error()      errno
+#define __itt_fstrcmp(s1, s2)     strcmp(s1, s2)
+
+/* makes customer code define safe APIs for SDL_STRNLEN_S and SDL_STRNCPY_S */
+#ifdef SDL_STRNLEN_S
+#define __itt_fstrnlen(s, l)      SDL_STRNLEN_S(s, l)
+#else
+#define __itt_fstrnlen(s, l)      strlen(s)
+#endif /* SDL_STRNLEN_S */
+#ifdef SDL_STRNCPY_S
+#define __itt_fstrcpyn(s1, b, s2, l) SDL_STRNCPY_S(s1, b, s2, l)
+#else
+#define __itt_fstrcpyn(s1, b, s2, l) {                                      \
+    if (b > 0) {                                                            \
+        /* 'volatile' is used to suppress the warning that a destination */ \
+        /*  bound depends on the length of the source.                   */ \
+        volatile size_t num_to_copy = (size_t)(b - 1) < (size_t)(l) ?       \
+                (size_t)(b - 1) : (size_t)(l);                              \
+        strncpy(s1, s2, num_to_copy);                                       \
+        s1[num_to_copy] = 0;                                                \
+    }                                                                       \
+}
+#endif /* SDL_STRNCPY_S */
+
+#define __itt_thread_id()         pthread_self()
+#define __itt_thread_yield()      sched_yield()
+#if ITT_ARCH==ITT_ARCH_IA64
+#ifdef __INTEL_COMPILER
+#define __TBB_machine_fetchadd4(addr, val) __fetchadd4_acq((void *)addr, val)
+#else  /* __INTEL_COMPILER */
+/* TODO: Add Support for not Intel compilers for IA-64 architecture */
+#endif /* __INTEL_COMPILER */
+#elif ITT_ARCH==ITT_ARCH_IA32 || ITT_ARCH==ITT_ARCH_IA32E /* ITT_ARCH!=ITT_ARCH_IA64 */
+ITT_INLINE long
+__TBB_machine_fetchadd4(volatile void* ptr, long addend) ITT_INLINE_ATTRIBUTE;
+ITT_INLINE long __TBB_machine_fetchadd4(volatile void* ptr, long addend)
+{
+    long result;
+    __asm__ __volatile__("lock\nxadd %0,%1"
+                          : "=r"(result),"=m"(*(volatile int*)ptr)
+                          : "0"(addend), "m"(*(volatile int*)ptr)
+                          : "memory");
+    return result;
+}
+#else
+#define __TBB_machine_fetchadd4(addr, val) __sync_fetch_and_add(addr, val)
+#endif /* ITT_ARCH==ITT_ARCH_IA64 */
+#ifndef ITT_SIMPLE_INIT
+ITT_INLINE long
+__itt_interlocked_increment(volatile long* ptr) ITT_INLINE_ATTRIBUTE;
+ITT_INLINE long __itt_interlocked_increment(volatile long* ptr)
+{
+    return __TBB_machine_fetchadd4(ptr, 1) + 1L;
+}
+ITT_INLINE long
+__itt_interlocked_compare_exchange(volatile long* ptr, long exchange, long comperand) ITT_INLINE_ATTRIBUTE;
+ITT_INLINE long
+__itt_interlocked_compare_exchange(volatile long* ptr, long exchange, long comperand)
+{
+    return __sync_val_compare_and_swap(ptr, exchange, comperand);
+}
+#endif /* ITT_SIMPLE_INIT */
+
+void* dlopen(const char*, int) __attribute__((weak));
+void* dlsym(void*, const char*) __attribute__((weak));
+int dlclose(void*) __attribute__((weak));
+#define DL_SYMBOLS (dlopen && dlsym && dlclose)
+
+int pthread_mutex_init(pthread_mutex_t*, const pthread_mutexattr_t*) __attribute__((weak));
+int pthread_mutex_lock(pthread_mutex_t*) __attribute__((weak));
+int pthread_mutex_unlock(pthread_mutex_t*) __attribute__((weak));
+int pthread_mutex_destroy(pthread_mutex_t*) __attribute__((weak));
+int pthread_mutexattr_init(pthread_mutexattr_t*) __attribute__((weak));
+int pthread_mutexattr_settype(pthread_mutexattr_t*, int) __attribute__((weak));
+int pthread_mutexattr_destroy(pthread_mutexattr_t*) __attribute__((weak));
+pthread_t pthread_self(void) __attribute__((weak));
+#define PTHREAD_SYMBOLS (pthread_mutex_init && pthread_mutex_lock && pthread_mutex_unlock && pthread_mutex_destroy && pthread_mutexattr_init && pthread_mutexattr_settype && pthread_mutexattr_destroy && pthread_self)
+
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+/* strdup() is not included into C99 which results in a compiler warning about
+ * implicitly declared symbol. To avoid the issue strdup is implemented
+ * manually.
+ */
+#define ITT_STRDUP_MAX_STRING_SIZE 4096
+#define __itt_fstrdup(s, new_s) do {                                        \
+    if (s != NULL) {                                                        \
+        size_t s_len = __itt_fstrnlen(s, ITT_STRDUP_MAX_STRING_SIZE);       \
+        new_s = (char *)malloc(s_len + 1);                                  \
+        if (new_s != NULL) {                                                \
+            __itt_fstrcpyn(new_s, s_len + 1, s, s_len);                     \
+        }                                                                   \
+    }                                                                       \
+} while(0)
+
+typedef enum {
+    __itt_thread_normal  = 0,
+    __itt_thread_ignored = 1
+} __itt_thread_state;
+
+#pragma pack(push, 8)
+
+typedef struct ___itt_thread_info
+{
+    const char* nameA; /*!< Copy of original name in ASCII. */
+#if defined(UNICODE) || defined(_UNICODE)
+    const wchar_t* nameW; /*!< Copy of original name in UNICODE. */
+#else  /* UNICODE || _UNICODE */
+    void* nameW;
+#endif /* UNICODE || _UNICODE */
+    TIDT               tid;
+    __itt_thread_state state;   /*!< Thread state (paused or normal) */
+    int                extra1;  /*!< Reserved to the runtime */
+    void*              extra2;  /*!< Reserved to the runtime */
+    struct ___itt_thread_info* next;
+} __itt_thread_info;
+
+#include "ittnotify_types.h" /* For __itt_group_id definition */
+
+typedef struct ___itt_api_info_20101001
+{
+    const char*    name;
+    void**         func_ptr;
+    void*          init_func;
+    __itt_group_id group;
+}  __itt_api_info_20101001;
+
+typedef struct ___itt_api_info
+{
+    const char*    name;
+    void**         func_ptr;
+    void*          init_func;
+    void*          null_func;
+    __itt_group_id group;
+}  __itt_api_info;
+
+typedef struct __itt_counter_info
+{
+    const char* nameA;  /*!< Copy of original name in ASCII. */
+#if defined(UNICODE) || defined(_UNICODE)
+    const wchar_t* nameW; /*!< Copy of original name in UNICODE. */
+#else  /* UNICODE || _UNICODE */
+    void* nameW;
+#endif /* UNICODE || _UNICODE */
+    const char* domainA;  /*!< Copy of original name in ASCII. */
+#if defined(UNICODE) || defined(_UNICODE)
+    const wchar_t* domainW; /*!< Copy of original name in UNICODE. */
+#else  /* UNICODE || _UNICODE */
+    void* domainW;
+#endif /* UNICODE || _UNICODE */
+    int type;
+    long index;
+    int   extra1; /*!< Reserved to the runtime */
+    void* extra2; /*!< Reserved to the runtime */
+    struct __itt_counter_info* next;
+}  __itt_counter_info_t;
+
+struct ___itt_domain;
+struct ___itt_string_handle;
+struct ___itt_histogram;
+
+#include "ittnotify.h"
+
+typedef struct ___itt_global
+{
+    unsigned char          magic[8];
+    unsigned long          version_major;
+    unsigned long          version_minor;
+    unsigned long          version_build;
+    volatile long          api_initialized;
+    volatile long          mutex_initialized;
+    volatile long          atomic_counter;
+    mutex_t                mutex;
+    lib_t                  lib;
+    void*                  error_handler;
+    const char**           dll_path_ptr;
+    __itt_api_info*        api_list_ptr;
+    struct ___itt_global*  next;
+    /* Joinable structures below */
+    __itt_thread_info*     thread_list;
+    struct ___itt_domain*  domain_list;
+    struct ___itt_string_handle* string_list;
+    __itt_collection_state state;
+    __itt_counter_info_t*  counter_list;
+    unsigned int           ipt_collect_events;
+    struct ___itt_histogram* histogram_list;
+} __itt_global;
+
+#pragma pack(pop)
+
+#define NEW_THREAD_INFO_W(gptr,h,h_tail,t,s,n) { \
+    h = (__itt_thread_info*)malloc(sizeof(__itt_thread_info)); \
+    if (h != NULL) { \
+        h->tid    = t; \
+        h->nameA  = NULL; \
+        h->nameW  = n ? _wcsdup(n) : NULL; \
+        h->state  = s; \
+        h->extra1 = 0;    /* reserved */ \
+        h->extra2 = NULL; /* reserved */ \
+        h->next   = NULL; \
+        if (h_tail == NULL) \
+            (gptr)->thread_list = h; \
+        else \
+            h_tail->next = h; \
+    } \
+}
+
+#define NEW_THREAD_INFO_A(gptr,h,h_tail,t,s,n) { \
+    h = (__itt_thread_info*)malloc(sizeof(__itt_thread_info)); \
+    if (h != NULL) { \
+        h->tid    = t; \
+        char *n_copy = NULL; \
+        __itt_fstrdup(n, n_copy); \
+        h->nameA  = n_copy; \
+        h->nameW  = NULL; \
+        h->state  = s; \
+        h->extra1 = 0;    /* reserved */ \
+        h->extra2 = NULL; /* reserved */ \
+        h->next   = NULL; \
+        if (h_tail == NULL) \
+            (gptr)->thread_list = h; \
+        else \
+            h_tail->next = h; \
+    } \
+}
+
+#define NEW_DOMAIN_W(gptr,h,h_tail,name) { \
+    h = (__itt_domain*)malloc(sizeof(__itt_domain)); \
+    if (h != NULL) { \
+        h->flags  = 1;    /* domain is enabled by default */ \
+        h->nameA  = NULL; \
+        h->nameW  = name ? _wcsdup(name) : NULL; \
+        h->extra1 = 0;    /* reserved */ \
+        h->extra2 = NULL; /* reserved */ \
+        h->next   = NULL; \
+        if (h_tail == NULL) \
+            (gptr)->domain_list = h; \
+        else \
+            h_tail->next = h; \
+    } \
+}
+
+#define NEW_DOMAIN_A(gptr,h,h_tail,name) { \
+    h = (__itt_domain*)malloc(sizeof(__itt_domain)); \
+    if (h != NULL) { \
+        h->flags  = 1;    /* domain is enabled by default */ \
+        char *name_copy = NULL; \
+        __itt_fstrdup(name, name_copy); \
+        h->nameA  = name_copy; \
+        h->nameW  = NULL; \
+        h->extra1 = 0;    /* reserved */ \
+        h->extra2 = NULL; /* reserved */ \
+        h->next   = NULL; \
+        if (h_tail == NULL) \
+            (gptr)->domain_list = h; \
+        else \
+            h_tail->next = h; \
+    } \
+}
+
+#define NEW_STRING_HANDLE_W(gptr,h,h_tail,name) { \
+    h = (__itt_string_handle*)malloc(sizeof(__itt_string_handle)); \
+    if (h != NULL) { \
+        h->strA   = NULL; \
+        h->strW   = name ? _wcsdup(name) : NULL; \
+        h->extra1 = 0;    /* reserved */ \
+        h->extra2 = NULL; /* reserved */ \
+        h->next   = NULL; \
+        if (h_tail == NULL) \
+            (gptr)->string_list = h; \
+        else \
+            h_tail->next = h; \
+    } \
+}
+
+#define NEW_STRING_HANDLE_A(gptr,h,h_tail,name) { \
+    h = (__itt_string_handle*)malloc(sizeof(__itt_string_handle)); \
+    if (h != NULL) { \
+        char *name_copy = NULL; \
+        __itt_fstrdup(name, name_copy); \
+        h->strA  = name_copy; \
+        h->strW   = NULL; \
+        h->extra1 = 0;    /* reserved */ \
+        h->extra2 = NULL; /* reserved */ \
+        h->next   = NULL; \
+        if (h_tail == NULL) \
+            (gptr)->string_list = h; \
+        else \
+            h_tail->next = h; \
+    } \
+}
+
+#define NEW_COUNTER_W(gptr,h,h_tail,name,domain,type) { \
+    h = (__itt_counter_info_t*)malloc(sizeof(__itt_counter_info_t)); \
+    if (h != NULL) { \
+        h->nameA   = NULL; \
+        h->nameW   = name ? _wcsdup(name) : NULL; \
+        h->domainA   = NULL; \
+        h->domainW   = name ? _wcsdup(domain) : NULL; \
+        h->type = (int)type; \
+        h->index = 0; \
+        h->next   = NULL; \
+        if (h_tail == NULL) \
+            (gptr)->counter_list = h; \
+        else \
+            h_tail->next = h; \
+    } \
+}
+
+#define NEW_COUNTER_A(gptr,h,h_tail,name,domain,type) { \
+    h = (__itt_counter_info_t*)malloc(sizeof(__itt_counter_info_t)); \
+    if (h != NULL) { \
+        char *name_copy = NULL; \
+        __itt_fstrdup(name, name_copy); \
+        h->nameA  = name_copy; \
+        h->nameW   = NULL; \
+        char *domain_copy = NULL; \
+        __itt_fstrdup(domain, domain_copy); \
+        h->domainA  = domain_copy; \
+        h->domainW   = NULL; \
+        h->type = (int)type; \
+        h->index = 0; \
+        h->next   = NULL; \
+        if (h_tail == NULL) \
+            (gptr)->counter_list = h; \
+        else \
+            h_tail->next = h; \
+    } \
+}
+
+#define NEW_HISTOGRAM_W(gptr,h,h_tail,domain,name,x_type,y_type) { \
+    h = (__itt_histogram*)malloc(sizeof(__itt_histogram)); \
+    if (h != NULL) { \
+        h->domain = domain; \
+        h->nameA  = NULL; \
+        h->nameW  = name ? _wcsdup(name) : NULL; \
+        h->x_type = x_type; \
+        h->y_type = y_type; \
+        h->extra1 = 0; \
+        h->extra2 = NULL; \
+        if (h_tail == NULL) \
+            (gptr)->histogram_list = h; \
+        else \
+            h_tail->next = h; \
+    } \
+}
+
+#define NEW_HISTOGRAM_A(gptr,h,h_tail,domain,name,x_type,y_type) { \
+    h = (__itt_histogram*)malloc(sizeof(__itt_histogram)); \
+    if (h != NULL) { \
+        h->domain = domain; \
+        char *name_copy = NULL; \
+        __itt_fstrdup(name, name_copy); \
+        h->nameA  = name_copy; \
+        h->nameW  = NULL; \
+        h->x_type = x_type; \
+        h->y_type = y_type; \
+        h->extra1 = 0; \
+        h->extra2 = NULL; \
+        if (h_tail == NULL) \
+            (gptr)->histogram_list = h; \
+        else \
+            h_tail->next = h; \
+    } \
+}
+
+#endif /* _ITTNOTIFY_CONFIG_H_ */

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/common/ittnotify/ittnotify_static.h

@@ -0,0 +1,355 @@
+/*
+  Copyright (C) 2005-2019 Intel Corporation
+
+  SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause
+*/
+
+#include "ittnotify_config.h"
+
+#ifndef ITT_FORMAT_DEFINED
+#  ifndef ITT_FORMAT
+#    define ITT_FORMAT
+#  endif /* ITT_FORMAT */
+#  ifndef ITT_NO_PARAMS
+#    define ITT_NO_PARAMS
+#  endif /* ITT_NO_PARAMS */
+#endif /* ITT_FORMAT_DEFINED */
+
+/*
+ * parameters for macro expected:
+ * ITT_STUB(api, type, func_name, arguments, params, func_name_in_dll, group, printf_fmt)
+ */
+#ifdef __ITT_INTERNAL_INIT
+
+#ifndef __ITT_INTERNAL_BODY
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_domain*, domain_createA, (const char    *name), (ITT_FORMAT name), domain_createA, __itt_group_structure, "\"%s\"")
+ITT_STUB(ITTAPI, __itt_domain*, domain_createW, (const wchar_t *name), (ITT_FORMAT name), domain_createW, __itt_group_structure, "\"%S\"")
+#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_domain*, domain_create,  (const char    *name), (ITT_FORMAT name), domain_create,  __itt_group_structure, "\"%s\"")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+ITT_STUBV(ITTAPI, void, module_load_with_sections, (__itt_module_object* module_obj), (ITT_FORMAT module_obj), module_load_with_sections, __itt_group_module, "%p")
+ITT_STUBV(ITTAPI, void, module_unload_with_sections, (__itt_module_object* module_obj), (ITT_FORMAT module_obj), module_unload_with_sections, __itt_group_module, "%p")
+
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_string_handle*, string_handle_createA, (const char    *name), (ITT_FORMAT name), string_handle_createA, __itt_group_structure, "\"%s\"")
+ITT_STUB(ITTAPI, __itt_string_handle*, string_handle_createW, (const wchar_t *name), (ITT_FORMAT name), string_handle_createW, __itt_group_structure, "\"%S\"")
+#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_string_handle*, string_handle_create,  (const char    *name), (ITT_FORMAT name), string_handle_create,  __itt_group_structure, "\"%s\"")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_counter, counter_createA, (const char    *name, const char    *domain), (ITT_FORMAT name, domain), counter_createA, __itt_group_counter, "\"%s\", \"%s\"")
+ITT_STUB(ITTAPI, __itt_counter, counter_createW, (const wchar_t *name, const wchar_t *domain), (ITT_FORMAT name, domain), counter_createW, __itt_group_counter, "\"%s\", \"%s\"")
+#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_counter, counter_create,  (const char    *name, const char    *domain), (ITT_FORMAT name, domain), counter_create,  __itt_group_counter, "\"%s\", \"%s\"")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_counter, counter_create_typedA, (const char    *name, const char    *domain, __itt_metadata_type type), (ITT_FORMAT name, domain, type), counter_create_typedA, __itt_group_counter, "\"%s\", \"%s\", %d")
+ITT_STUB(ITTAPI, __itt_counter, counter_create_typedW, (const wchar_t *name, const wchar_t *domain, __itt_metadata_type type), (ITT_FORMAT name, domain, type), counter_create_typedW, __itt_group_counter, "\"%s\", \"%s\", %d")
+#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_counter, counter_create_typed,  (const char    *name, const char    *domain, __itt_metadata_type type), (ITT_FORMAT name, domain, type), counter_create_typed,  __itt_group_counter, "\"%s\", \"%s\", %d")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+
+ITT_STUBV(ITTAPI, void, pause,  (void), (ITT_NO_PARAMS), pause,  __itt_group_control | __itt_group_legacy, "no args")
+ITT_STUBV(ITTAPI, void, resume, (void), (ITT_NO_PARAMS), resume, __itt_group_control | __itt_group_legacy, "no args")
+
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, thread_set_nameA, (const char    *name), (ITT_FORMAT name), thread_set_nameA, __itt_group_thread, "\"%s\"")
+ITT_STUBV(ITTAPI, void, thread_set_nameW, (const wchar_t *name), (ITT_FORMAT name), thread_set_nameW, __itt_group_thread, "\"%S\"")
+#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, thread_set_name,  (const char    *name), (ITT_FORMAT name), thread_set_name,  __itt_group_thread, "\"%s\"")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, thread_ignore, (void), (ITT_NO_PARAMS), thread_ignore, __itt_group_thread, "no args")
+
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(LIBITTAPI, int,  thr_name_setA, (const char    *name, int namelen), (ITT_FORMAT name, namelen), thr_name_setA, __itt_group_thread | __itt_group_legacy, "\"%s\", %d")
+ITT_STUB(LIBITTAPI, int,  thr_name_setW, (const wchar_t *name, int namelen), (ITT_FORMAT name, namelen), thr_name_setW, __itt_group_thread | __itt_group_legacy, "\"%S\", %d")
+#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUB(LIBITTAPI, int,  thr_name_set,  (const char    *name, int namelen), (ITT_FORMAT name, namelen), thr_name_set,  __itt_group_thread | __itt_group_legacy, "\"%s\", %d")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUBV(LIBITTAPI, void, thr_ignore,   (void),                             (ITT_NO_PARAMS),            thr_ignore,    __itt_group_thread | __itt_group_legacy, "no args")
+
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_histogram*, histogram_createA, (const __itt_domain* domain, const char* name, __itt_metadata_type x_type, __itt_metadata_type y_type), (ITT_FORMAT domain, name, x_type, y_type), histogram_createA, __itt_group_structure, "%p, \"%s\", %d, %d")
+ITT_STUB(ITTAPI, __itt_histogram*, histogram_createW, (const __itt_domain* domain, const wchar_t* name, __itt_metadata_type x_type, __itt_metadata_type y_type), (ITT_FORMAT domain, name, x_type, y_type), histogram_createW, __itt_group_structure, "%p, \"%s\", %d, %d")
+#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_histogram*, histogram_create, (const __itt_domain* domain, const char* name, __itt_metadata_type x_type, __itt_metadata_type y_type), (ITT_FORMAT domain, name, x_type, y_type), histogram_create, __itt_group_structure, "%p, \"%s\", %d, %d")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+#endif /* __ITT_INTERNAL_BODY */
+
+ITT_STUBV(ITTAPI, void, enable_attach, (void), (ITT_NO_PARAMS), enable_attach, __itt_group_all, "no args")
+
+#else  /* __ITT_INTERNAL_INIT */
+
+ITT_STUBV(ITTAPI, void, detach, (void), (ITT_NO_PARAMS), detach, __itt_group_control | __itt_group_legacy, "no args")
+
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, sync_createA, (void *addr, const char    *objtype, const char    *objname, int attribute), (ITT_FORMAT addr, objtype, objname, attribute), sync_createA, __itt_group_sync | __itt_group_fsync, "%p, \"%s\", \"%s\", %x")
+ITT_STUBV(ITTAPI, void, sync_createW, (void *addr, const wchar_t *objtype, const wchar_t *objname, int attribute), (ITT_FORMAT addr, objtype, objname, attribute), sync_createW, __itt_group_sync | __itt_group_fsync, "%p, \"%S\", \"%S\", %x")
+ITT_STUBV(ITTAPI, void, sync_renameA, (void *addr, const char    *name), (ITT_FORMAT addr, name), sync_renameA, __itt_group_sync | __itt_group_fsync, "%p, \"%s\"")
+ITT_STUBV(ITTAPI, void, sync_renameW, (void *addr, const wchar_t *name), (ITT_FORMAT addr, name), sync_renameW, __itt_group_sync | __itt_group_fsync, "%p, \"%S\"")
+#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, sync_create,  (void *addr, const char    *objtype, const char    *objname, int attribute), (ITT_FORMAT addr, objtype, objname, attribute), sync_create,  __itt_group_sync | __itt_group_fsync, "%p, \"%s\", \"%s\", %x")
+ITT_STUBV(ITTAPI, void, sync_rename,  (void *addr, const char    *name), (ITT_FORMAT addr, name), sync_rename,  __itt_group_sync | __itt_group_fsync, "%p, \"%s\"")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, sync_destroy,    (void *addr), (ITT_FORMAT addr), sync_destroy,   __itt_group_sync | __itt_group_fsync, "%p")
+
+ITT_STUBV(ITTAPI, void, sync_prepare,    (void* addr), (ITT_FORMAT addr), sync_prepare,   __itt_group_sync,  "%p")
+ITT_STUBV(ITTAPI, void, sync_cancel,     (void *addr), (ITT_FORMAT addr), sync_cancel,    __itt_group_sync,  "%p")
+ITT_STUBV(ITTAPI, void, sync_acquired,   (void *addr), (ITT_FORMAT addr), sync_acquired,  __itt_group_sync,  "%p")
+ITT_STUBV(ITTAPI, void, sync_releasing,  (void* addr), (ITT_FORMAT addr), sync_releasing, __itt_group_sync,  "%p")
+
+ITT_STUBV(ITTAPI, void, suppress_push,       (unsigned int mask),                             (ITT_FORMAT mask), suppress_push,  __itt_group_suppress,  "%p")
+ITT_STUBV(ITTAPI, void, suppress_pop,        (void),                                          (ITT_NO_PARAMS),   suppress_pop,   __itt_group_suppress,  "no args")
+ITT_STUBV(ITTAPI, void, suppress_mark_range, (__itt_suppress_mode_t mode, unsigned int mask, void * address, size_t size),(ITT_FORMAT mode, mask, address, size), suppress_mark_range, __itt_group_suppress, "%d, %p, %p, %d")
+ITT_STUBV(ITTAPI, void, suppress_clear_range,(__itt_suppress_mode_t mode, unsigned int mask, void * address, size_t size),(ITT_FORMAT mode, mask, address, size), suppress_clear_range,__itt_group_suppress, "%d, %p, %p, %d")
+
+ITT_STUBV(ITTAPI, void, fsync_prepare,   (void* addr), (ITT_FORMAT addr), sync_prepare,   __itt_group_fsync, "%p")
+ITT_STUBV(ITTAPI, void, fsync_cancel,    (void *addr), (ITT_FORMAT addr), sync_cancel,    __itt_group_fsync, "%p")
+ITT_STUBV(ITTAPI, void, fsync_acquired,  (void *addr), (ITT_FORMAT addr), sync_acquired,  __itt_group_fsync, "%p")
+ITT_STUBV(ITTAPI, void, fsync_releasing, (void* addr), (ITT_FORMAT addr), sync_releasing, __itt_group_fsync, "%p")
+
+ITT_STUBV(ITTAPI, void, model_site_begin,          (__itt_model_site *site, __itt_model_site_instance *instance, const char *name), (ITT_FORMAT site, instance, name), model_site_begin, __itt_group_model, "%p, %p, \"%s\"")
+ITT_STUBV(ITTAPI, void, model_site_end,            (__itt_model_site *site, __itt_model_site_instance *instance),                   (ITT_FORMAT site, instance),       model_site_end,   __itt_group_model, "%p, %p")
+ITT_STUBV(ITTAPI, void, model_task_begin,          (__itt_model_task *task, __itt_model_task_instance *instance, const char *name), (ITT_FORMAT task, instance, name), model_task_begin, __itt_group_model, "%p, %p, \"%s\"")
+ITT_STUBV(ITTAPI, void, model_task_end,            (__itt_model_task *task, __itt_model_task_instance *instance),                   (ITT_FORMAT task, instance),       model_task_end,   __itt_group_model, "%p, %p")
+ITT_STUBV(ITTAPI, void, model_lock_acquire,        (void *lock), (ITT_FORMAT lock), model_lock_acquire, __itt_group_model, "%p")
+ITT_STUBV(ITTAPI, void, model_lock_release,        (void *lock), (ITT_FORMAT lock), model_lock_release, __itt_group_model, "%p")
+ITT_STUBV(ITTAPI, void, model_record_allocation,   (void *addr, size_t size), (ITT_FORMAT addr, size), model_record_allocation,   __itt_group_model, "%p, %d")
+ITT_STUBV(ITTAPI, void, model_record_deallocation, (void *addr),              (ITT_FORMAT addr),       model_record_deallocation, __itt_group_model, "%p")
+ITT_STUBV(ITTAPI, void, model_induction_uses,      (void* addr, size_t size), (ITT_FORMAT addr, size), model_induction_uses,      __itt_group_model, "%p, %d")
+ITT_STUBV(ITTAPI, void, model_reduction_uses,      (void* addr, size_t size), (ITT_FORMAT addr, size), model_reduction_uses,      __itt_group_model, "%p, %d")
+ITT_STUBV(ITTAPI, void, model_observe_uses,        (void* addr, size_t size), (ITT_FORMAT addr, size), model_observe_uses,        __itt_group_model, "%p, %d")
+ITT_STUBV(ITTAPI, void, model_clear_uses,          (void* addr),              (ITT_FORMAT addr),       model_clear_uses,          __itt_group_model, "%p")
+
+#ifndef __ITT_INTERNAL_BODY
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, model_site_beginW,         (const wchar_t *name),     (ITT_FORMAT name),       model_site_beginW,         __itt_group_model, "\"%s\"")
+ITT_STUBV(ITTAPI, void, model_task_beginW,         (const wchar_t *name),     (ITT_FORMAT name),       model_task_beginW,         __itt_group_model, "\"%s\"")
+ITT_STUBV(ITTAPI, void, model_iteration_taskW,     (const wchar_t *name),     (ITT_FORMAT name),       model_iteration_taskW,     __itt_group_model, "\"%s\"")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, model_site_beginA,         (const char *name),        (ITT_FORMAT name),       model_site_beginA,         __itt_group_model, "\"%s\"")
+ITT_STUBV(ITTAPI, void, model_site_beginAL,        (const char *name, size_t len), (ITT_FORMAT name, len), model_site_beginAL,    __itt_group_model, "\"%s\", %d")
+ITT_STUBV(ITTAPI, void, model_task_beginA,         (const char *name),        (ITT_FORMAT name),       model_task_beginA,         __itt_group_model, "\"%s\"")
+ITT_STUBV(ITTAPI, void, model_task_beginAL,        (const char *name, size_t len), (ITT_FORMAT name, len), model_task_beginAL,    __itt_group_model, "\"%s\", %d")
+ITT_STUBV(ITTAPI, void, model_iteration_taskA,     (const char *name),        (ITT_FORMAT name),       model_iteration_taskA,     __itt_group_model, "\"%s\"")
+ITT_STUBV(ITTAPI, void, model_iteration_taskAL,    (const char *name, size_t len), (ITT_FORMAT name, len), model_iteration_taskAL, __itt_group_model, "\"%s\", %d")
+ITT_STUBV(ITTAPI, void, model_site_end_2,          (void),                    (ITT_NO_PARAMS),         model_site_end_2,          __itt_group_model, "no args")
+ITT_STUBV(ITTAPI, void, model_task_end_2,          (void),                    (ITT_NO_PARAMS),         model_task_end_2,          __itt_group_model, "no args")
+ITT_STUBV(ITTAPI, void, model_lock_acquire_2,      (void *lock),              (ITT_FORMAT lock),       model_lock_acquire_2,      __itt_group_model, "%p")
+ITT_STUBV(ITTAPI, void, model_lock_release_2,      (void *lock),              (ITT_FORMAT lock),       model_lock_release_2,      __itt_group_model, "%p")
+ITT_STUBV(ITTAPI, void, model_aggregate_task,      (size_t count),            (ITT_FORMAT count),      model_aggregate_task,      __itt_group_model, "%d")
+ITT_STUBV(ITTAPI, void, model_disable_push,        (__itt_model_disable x),   (ITT_FORMAT x),          model_disable_push,        __itt_group_model, "%p")
+ITT_STUBV(ITTAPI, void, model_disable_pop,         (void),                    (ITT_NO_PARAMS),         model_disable_pop,         __itt_group_model, "no args")
+#endif /* __ITT_INTERNAL_BODY */
+
+#ifndef __ITT_INTERNAL_BODY
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_heap_function, heap_function_createA, (const char    *name, const char    *domain), (ITT_FORMAT name, domain), heap_function_createA, __itt_group_heap, "\"%s\", \"%s\"")
+ITT_STUB(ITTAPI, __itt_heap_function, heap_function_createW, (const wchar_t *name, const wchar_t *domain), (ITT_FORMAT name, domain), heap_function_createW, __itt_group_heap, "\"%s\", \"%s\"")
+#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_heap_function, heap_function_create,  (const char    *name, const char    *domain), (ITT_FORMAT name, domain), heap_function_create,  __itt_group_heap, "\"%s\", \"%s\"")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* __ITT_INTERNAL_BODY */
+ITT_STUBV(ITTAPI, void, heap_allocate_begin,   (__itt_heap_function h, size_t size, int initialized),             (ITT_FORMAT h, size, initialized),       heap_allocate_begin, __itt_group_heap, "%p, %lu, %d")
+ITT_STUBV(ITTAPI, void, heap_allocate_end,     (__itt_heap_function h, void** addr, size_t size, int initialized), (ITT_FORMAT h, addr, size, initialized), heap_allocate_end,   __itt_group_heap, "%p, %p, %lu, %d")
+ITT_STUBV(ITTAPI, void, heap_free_begin,       (__itt_heap_function h, void*  addr), (ITT_FORMAT h, addr), heap_free_begin, __itt_group_heap, "%p, %p")
+ITT_STUBV(ITTAPI, void, heap_free_end,         (__itt_heap_function h, void*  addr), (ITT_FORMAT h, addr), heap_free_end,   __itt_group_heap, "%p, %p")
+ITT_STUBV(ITTAPI, void, heap_reallocate_begin, (__itt_heap_function h, void*  addr, size_t new_size, int initialized),                  (ITT_FORMAT h, addr, new_size, initialized),           heap_reallocate_begin, __itt_group_heap, "%p, %p, %lu, %d")
+ITT_STUBV(ITTAPI, void, heap_reallocate_end,   (__itt_heap_function h, void*  addr, void** new_addr, size_t new_size, int initialized), (ITT_FORMAT h, addr, new_addr, new_size, initialized), heap_reallocate_end,   __itt_group_heap, "%p, %p, %p, %lu, %d")
+ITT_STUBV(ITTAPI, void, heap_internal_access_begin, (void), (ITT_NO_PARAMS), heap_internal_access_begin, __itt_group_heap, "no args")
+ITT_STUBV(ITTAPI, void, heap_internal_access_end,   (void), (ITT_NO_PARAMS), heap_internal_access_end,   __itt_group_heap, "no args")
+ITT_STUBV(ITTAPI, void, heap_record_memory_growth_begin, (void), (ITT_NO_PARAMS), heap_record_memory_growth_begin, __itt_group_heap, "no args")
+ITT_STUBV(ITTAPI, void, heap_record_memory_growth_end,   (void), (ITT_NO_PARAMS), heap_record_memory_growth_end,   __itt_group_heap, "no args")
+ITT_STUBV(ITTAPI, void, heap_reset_detection, (unsigned int reset_mask),  (ITT_FORMAT reset_mask), heap_reset_detection, __itt_group_heap, "%u")
+ITT_STUBV(ITTAPI, void, heap_record,          (unsigned int record_mask), (ITT_FORMAT record_mask),  heap_record,        __itt_group_heap, "%u")
+
+ITT_STUBV(ITTAPI, void, id_create,  (const __itt_domain *domain, __itt_id id), (ITT_FORMAT domain, id), id_create,  __itt_group_structure, "%p, %lu")
+ITT_STUBV(ITTAPI, void, id_destroy, (const __itt_domain *domain, __itt_id id), (ITT_FORMAT domain, id), id_destroy, __itt_group_structure, "%p, %lu")
+
+ITT_STUB(ITTAPI, __itt_timestamp, get_timestamp, (void), (ITT_NO_PARAMS), get_timestamp,  __itt_group_structure, "no args")
+
+ITT_STUBV(ITTAPI, void, region_begin, (const __itt_domain *domain, __itt_id id, __itt_id parent, __itt_string_handle *name), (ITT_FORMAT domain, id, parent, name), region_begin, __itt_group_structure, "%p, %lu, %lu, %p")
+ITT_STUBV(ITTAPI, void, region_end,   (const __itt_domain *domain, __itt_id id),                                             (ITT_FORMAT domain, id),               region_end,   __itt_group_structure, "%p, %lu")
+
+#ifndef __ITT_INTERNAL_BODY
+ITT_STUBV(ITTAPI, void, frame_begin_v3,  (const __itt_domain *domain, __itt_id *id),                                             (ITT_FORMAT domain, id),             frame_begin_v3,  __itt_group_structure, "%p, %p")
+ITT_STUBV(ITTAPI, void, frame_end_v3,    (const __itt_domain *domain, __itt_id *id),                                             (ITT_FORMAT domain, id),             frame_end_v3,    __itt_group_structure, "%p, %p")
+ITT_STUBV(ITTAPI, void, frame_submit_v3, (const __itt_domain *domain, __itt_id *id, __itt_timestamp begin, __itt_timestamp end), (ITT_FORMAT domain, id, begin, end), frame_submit_v3, __itt_group_structure, "%p, %p, %lu, %lu")
+#endif /* __ITT_INTERNAL_BODY */
+
+ITT_STUBV(ITTAPI, void, task_group,   (const __itt_domain *domain, __itt_id id, __itt_id parent, __itt_string_handle *name), (ITT_FORMAT domain, id, parent, name), task_group,  __itt_group_structure, "%p, %lu, %lu, %p")
+
+ITT_STUBV(ITTAPI, void, task_begin,    (const __itt_domain *domain, __itt_id id, __itt_id parent, __itt_string_handle *name), (ITT_FORMAT domain, id, parent, name), task_begin,    __itt_group_structure, "%p, %lu, %lu, %p")
+ITT_STUBV(ITTAPI, void, task_begin_fn, (const __itt_domain *domain, __itt_id id, __itt_id parent, void* fn),                  (ITT_FORMAT domain, id, parent, fn),   task_begin_fn, __itt_group_structure, "%p, %lu, %lu, %p")
+ITT_STUBV(ITTAPI, void, task_end,      (const __itt_domain *domain),                                                          (ITT_FORMAT domain),                   task_end,      __itt_group_structure, "%p")
+
+ITT_STUBV(ITTAPI, void, counter_inc_v3,       (const __itt_domain *domain, __itt_string_handle *name),                           (ITT_FORMAT domain, name),        counter_inc_v3,       __itt_group_structure, "%p, %p")
+ITT_STUBV(ITTAPI, void, counter_inc_delta_v3, (const __itt_domain *domain, __itt_string_handle *name, unsigned long long value), (ITT_FORMAT domain, name, value), counter_inc_delta_v3, __itt_group_structure, "%p, %p, %lu")
+ITT_STUBV(ITTAPI, void, counter_dec_v3,       (const __itt_domain *domain, __itt_string_handle *name),                           (ITT_FORMAT domain, name),        counter_dec_v3,       __itt_group_structure, "%p, %p")
+ITT_STUBV(ITTAPI, void, counter_dec_delta_v3, (const __itt_domain *domain, __itt_string_handle *name, unsigned long long value), (ITT_FORMAT domain, name, value), counter_dec_delta_v3, __itt_group_structure, "%p, %p, %lu")
+
+ITT_STUBV(ITTAPI, void, marker, (const __itt_domain *domain, __itt_id id, __itt_string_handle *name, __itt_scope scope), (ITT_FORMAT domain, id, name, scope), marker, __itt_group_structure, "%p, %lu, %p, %d")
+
+ITT_STUBV(ITTAPI, void, metadata_add,      (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, __itt_metadata_type type, size_t count, void *data), (ITT_FORMAT domain, id, key, type, count, data), metadata_add, __itt_group_structure, "%p, %lu, %p, %d, %lu, %p")
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, metadata_str_addA, (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const char* data, size_t length),    (ITT_FORMAT domain, id, key, data, length), metadata_str_addA, __itt_group_structure, "%p, %lu, %p, %p, %lu")
+ITT_STUBV(ITTAPI, void, metadata_str_addW, (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const wchar_t* data, size_t length), (ITT_FORMAT domain, id, key, data, length), metadata_str_addW, __itt_group_structure, "%p, %lu, %p, %p, %lu")
+#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, metadata_str_add,  (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const char* data, size_t length),    (ITT_FORMAT domain, id, key, data, length), metadata_str_add,  __itt_group_structure, "%p, %lu, %p, %p, %lu")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+ITT_STUBV(ITTAPI, void, relation_add_to_current, (const __itt_domain *domain, __itt_relation relation, __itt_id tail),                (ITT_FORMAT domain, relation, tail),       relation_add_to_current, __itt_group_structure, "%p, %lu, %p")
+ITT_STUBV(ITTAPI, void, relation_add,            (const __itt_domain *domain, __itt_id head, __itt_relation relation, __itt_id tail), (ITT_FORMAT domain, head, relation, tail), relation_add,            __itt_group_structure, "%p, %p, %lu, %p")
+
+#ifndef __ITT_INTERNAL_BODY
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(LIBITTAPI, __itt_event, event_createA, (const char    *name, int namelen), (ITT_FORMAT name, namelen), event_createA, __itt_group_mark | __itt_group_legacy, "\"%s\", %d")
+ITT_STUB(LIBITTAPI, __itt_event, event_createW, (const wchar_t *name, int namelen), (ITT_FORMAT name, namelen), event_createW, __itt_group_mark | __itt_group_legacy, "\"%S\", %d")
+#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUB(LIBITTAPI, __itt_event, event_create,  (const char    *name, int namelen), (ITT_FORMAT name, namelen), event_create,  __itt_group_mark | __itt_group_legacy, "\"%s\", %d")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(LIBITTAPI, int,  event_start,          (__itt_event event),                (ITT_FORMAT event),         event_start,   __itt_group_mark | __itt_group_legacy, "%d")
+ITT_STUB(LIBITTAPI, int,  event_end,            (__itt_event event),                (ITT_FORMAT event),         event_end,     __itt_group_mark | __itt_group_legacy, "%d")
+#endif /* __ITT_INTERNAL_BODY */
+
+#ifndef __ITT_INTERNAL_BODY
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, sync_set_nameA, (void *addr, const char    *objtype, const char    *objname, int attribute), (ITT_FORMAT addr, objtype, objname, attribute), sync_set_nameA, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p, \"%s\", \"%s\", %x")
+ITT_STUBV(ITTAPI, void, sync_set_nameW, (void *addr, const wchar_t *objtype, const wchar_t *objname, int attribute), (ITT_FORMAT addr, objtype, objname, attribute), sync_set_nameW, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p, \"%S\", \"%S\", %x")
+#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, sync_set_name,  (void *addr, const char    *objtype, const char    *objname, int attribute), (ITT_FORMAT addr, objtype, objname, attribute), sync_set_name,  __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "p, \"%s\", \"%s\", %x")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(LIBITTAPI, int, notify_sync_nameA, (void *p, const char    *objtype, int typelen, const char    *objname, int namelen, int attribute), (ITT_FORMAT p, objtype, typelen, objname, namelen, attribute), notify_sync_nameA, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p, \"%s\", %d, \"%s\", %d, %x")
+ITT_STUB(LIBITTAPI, int, notify_sync_nameW, (void *p, const wchar_t *objtype, int typelen, const wchar_t *objname, int namelen, int attribute), (ITT_FORMAT p, objtype, typelen, objname, namelen, attribute), notify_sync_nameW, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p, \"%S\", %d, \"%S\", %d, %x")
+#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUB(LIBITTAPI, int, notify_sync_name,  (void *p, const char    *objtype, int typelen, const char    *objname, int namelen, int attribute), (ITT_FORMAT p, objtype, typelen, objname, namelen, attribute), notify_sync_name,  __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p, \"%s\", %d, \"%s\", %d, %x")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+ITT_STUBV(LIBITTAPI, void, notify_sync_prepare,   (void *p), (ITT_FORMAT p), notify_sync_prepare,   __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p")
+ITT_STUBV(LIBITTAPI, void, notify_sync_cancel,    (void *p), (ITT_FORMAT p), notify_sync_cancel,    __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p")
+ITT_STUBV(LIBITTAPI, void, notify_sync_acquired,  (void *p), (ITT_FORMAT p), notify_sync_acquired,  __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p")
+ITT_STUBV(LIBITTAPI, void, notify_sync_releasing, (void *p), (ITT_FORMAT p), notify_sync_releasing, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p")
+#endif /* __ITT_INTERNAL_BODY */
+
+ITT_STUBV(LIBITTAPI, void, memory_read,   (void *addr, size_t size), (ITT_FORMAT addr, size), memory_read,   __itt_group_legacy, "%p, %lu")
+ITT_STUBV(LIBITTAPI, void, memory_write,  (void *addr, size_t size), (ITT_FORMAT addr, size), memory_write,  __itt_group_legacy, "%p, %lu")
+ITT_STUBV(LIBITTAPI, void, memory_update, (void *addr, size_t size), (ITT_FORMAT addr, size), memory_update, __itt_group_legacy, "%p, %lu")
+
+ITT_STUB(LIBITTAPI, __itt_state_t,     state_get,    (void),                                    (ITT_NO_PARAMS),   state_get,    __itt_group_legacy, "no args")
+ITT_STUB(LIBITTAPI, __itt_state_t,     state_set,    (__itt_state_t s),                         (ITT_FORMAT s),    state_set,    __itt_group_legacy, "%d")
+ITT_STUB(LIBITTAPI, __itt_obj_state_t, obj_mode_set, (__itt_obj_prop_t p, __itt_obj_state_t s), (ITT_FORMAT p, s), obj_mode_set, __itt_group_legacy, "%d, %d")
+ITT_STUB(LIBITTAPI, __itt_thr_state_t, thr_mode_set, (__itt_thr_prop_t p, __itt_thr_state_t s), (ITT_FORMAT p, s), thr_mode_set, __itt_group_legacy, "%d, %d")
+
+#ifndef __ITT_INTERNAL_BODY
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_frame, frame_createA, (const char    *domain), (ITT_FORMAT domain), frame_createA, __itt_group_frame, "\"%s\"")
+ITT_STUB(ITTAPI, __itt_frame, frame_createW, (const wchar_t *domain), (ITT_FORMAT domain), frame_createW, __itt_group_frame, "\"%s\"")
+#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_frame, frame_create,  (const char    *domain), (ITT_FORMAT domain), frame_create,  __itt_group_frame, "\"%s\"")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_pt_region, pt_region_createA, (const char    *name), (ITT_FORMAT name), pt_region_createA, __itt_group_structure, "\"%s\"")
+ITT_STUB(ITTAPI, __itt_pt_region, pt_region_createW, (const wchar_t *name), (ITT_FORMAT name), pt_region_createW, __itt_group_structure, "\"%S\"")
+#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_pt_region, pt_region_create,  (const char    *name), (ITT_FORMAT name), pt_region_create,  __itt_group_structure, "\"%s\"")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* __ITT_INTERNAL_BODY */
+ITT_STUBV(ITTAPI, void, frame_begin,         (__itt_frame frame),     (ITT_FORMAT frame),  frame_begin,   __itt_group_frame, "%p")
+ITT_STUBV(ITTAPI, void, frame_end,           (__itt_frame frame),     (ITT_FORMAT frame),  frame_end,     __itt_group_frame, "%p")
+
+ITT_STUBV(ITTAPI, void, counter_destroy,      (__itt_counter id),                                                                                  (ITT_FORMAT id),        counter_destroy,   __itt_group_counter, "%p")
+ITT_STUBV(ITTAPI, void, counter_inc,          (__itt_counter id),                                                                                  (ITT_FORMAT id),        counter_inc,       __itt_group_counter, "%p")
+ITT_STUBV(ITTAPI, void, counter_inc_delta,    (__itt_counter id, unsigned long long value),                                                        (ITT_FORMAT id, value), counter_inc_delta, __itt_group_counter, "%p, %lu")
+ITT_STUBV(ITTAPI, void, counter_dec,          (__itt_counter id),                                                                                  (ITT_FORMAT id),        counter_dec,       __itt_group_counter, "%p")
+ITT_STUBV(ITTAPI, void, counter_dec_delta,    (__itt_counter id, unsigned long long value),                                                        (ITT_FORMAT id, value), counter_dec_delta, __itt_group_counter, "%p, %lu")
+ITT_STUBV(ITTAPI, void, counter_set_value,    (__itt_counter id, void *value_ptr),                                                                 (ITT_FORMAT id, value_ptr),                          counter_set_value,    __itt_group_counter, "%p, %p")
+ITT_STUBV(ITTAPI, void, counter_set_value_ex, (__itt_counter id, __itt_clock_domain *clock_domain, unsigned long long timestamp, void *value_ptr), (ITT_FORMAT id, clock_domain, timestamp, value_ptr), counter_set_value_ex, __itt_group_counter, "%p, %p, %llu, %p")
+
+#ifndef __ITT_INTERNAL_BODY
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_mark_type, mark_createA, (const char    *name), (ITT_FORMAT name), mark_createA, __itt_group_mark, "\"%s\"")
+ITT_STUB(ITTAPI, __itt_mark_type, mark_createW, (const wchar_t *name), (ITT_FORMAT name), mark_createW, __itt_group_mark, "\"%S\"")
+#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_mark_type, mark_create,  (const char    *name), (ITT_FORMAT name), mark_create,  __itt_group_mark, "\"%s\"")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* __ITT_INTERNAL_BODY */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, int,  markA,        (__itt_mark_type mt, const char    *parameter), (ITT_FORMAT mt, parameter), markA, __itt_group_mark, "%d, \"%s\"")
+ITT_STUB(ITTAPI, int,  markW,        (__itt_mark_type mt, const wchar_t *parameter), (ITT_FORMAT mt, parameter), markW, __itt_group_mark, "%d, \"%S\"")
+#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, int,  mark,         (__itt_mark_type mt, const char    *parameter), (ITT_FORMAT mt, parameter), mark,  __itt_group_mark, "%d, \"%s\"")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, int,  mark_off, (__itt_mark_type mt), (ITT_FORMAT mt), mark_off, __itt_group_mark, "%d")
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, int,  mark_globalA, (__itt_mark_type mt, const char    *parameter), (ITT_FORMAT mt, parameter), mark_globalA, __itt_group_mark, "%d, \"%s\"")
+ITT_STUB(ITTAPI, int,  mark_globalW, (__itt_mark_type mt, const wchar_t *parameter), (ITT_FORMAT mt, parameter), mark_globalW, __itt_group_mark, "%d, \"%S\"")
+#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, int,  mark_global,  (__itt_mark_type mt, const char    *parameter), (ITT_FORMAT mt, parameter), mark_global,  __itt_group_mark, "%d, \"%S\"")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, int,  mark_global_off, (__itt_mark_type mt),                        (ITT_FORMAT mt),            mark_global_off, __itt_group_mark, "%d")
+
+#ifndef __ITT_INTERNAL_BODY
+ITT_STUB(ITTAPI, __itt_caller, stack_caller_create, (void), (ITT_NO_PARAMS), stack_caller_create,  __itt_group_stitch, "no args")
+#endif /* __ITT_INTERNAL_BODY */
+ITT_STUBV(ITTAPI, void, stack_caller_destroy, (__itt_caller id), (ITT_FORMAT id), stack_caller_destroy, __itt_group_stitch, "%p")
+ITT_STUBV(ITTAPI, void, stack_callee_enter,   (__itt_caller id), (ITT_FORMAT id), stack_callee_enter,   __itt_group_stitch, "%p")
+ITT_STUBV(ITTAPI, void, stack_callee_leave,   (__itt_caller id), (ITT_FORMAT id), stack_callee_leave,   __itt_group_stitch, "%p")
+
+ITT_STUB(ITTAPI,  __itt_clock_domain*, clock_domain_create, (__itt_get_clock_info_fn fn, void* fn_data), (ITT_FORMAT fn, fn_data), clock_domain_create, __itt_group_structure, "%p, %p")
+ITT_STUBV(ITTAPI, void,                clock_domain_reset,  (void),                                      (ITT_NO_PARAMS),          clock_domain_reset,  __itt_group_structure, "no args")
+ITT_STUBV(ITTAPI, void, id_create_ex,  (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id), (ITT_FORMAT domain, clock_domain, timestamp, id), id_create_ex,  __itt_group_structure, "%p, %p, %lu, %lu")
+ITT_STUBV(ITTAPI, void, id_destroy_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id), (ITT_FORMAT domain, clock_domain, timestamp, id), id_destroy_ex, __itt_group_structure, "%p, %p, %lu, %lu")
+ITT_STUBV(ITTAPI, void, task_begin_ex,    (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_id parentid, __itt_string_handle *name), (ITT_FORMAT domain, clock_domain, timestamp, id, parentid, name), task_begin_ex, __itt_group_structure, "%p, %p, %lu, %lu, %lu, %p")
+ITT_STUBV(ITTAPI, void, task_begin_fn_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_id parentid, void* fn),                  (ITT_FORMAT domain, clock_domain, timestamp, id, parentid, fn), task_begin_fn_ex, __itt_group_structure, "%p, %p, %lu, %lu, %lu, %p")
+ITT_STUBV(ITTAPI, void, task_end_ex,      (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp),                                                            (ITT_FORMAT domain, clock_domain, timestamp), task_end_ex, __itt_group_structure, "%p, %p, %lu")
+ITT_STUBV(ITTAPI, void, task_begin_overlapped,       (const __itt_domain *domain, __itt_id id, __itt_id parent, __itt_string_handle *name),                                                                   (ITT_FORMAT domain, id, parent, name), task_begin_overlapped, __itt_group_structure, "%p, %lu, %lu, %p")
+ITT_STUBV(ITTAPI, void, task_begin_overlapped_ex,    (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_id parentid, __itt_string_handle *name), (ITT_FORMAT domain, clock_domain, timestamp, id, parentid, name), task_begin_overlapped_ex, __itt_group_structure, "%p, %p, %lu, %lu, %lu, %p")
+ITT_STUBV(ITTAPI, void, task_end_overlapped, (const __itt_domain *domain, __itt_id id),                                                                                                                       (ITT_FORMAT domain, id), task_end_overlapped, __itt_group_structure, "%p, %lu")
+ITT_STUBV(ITTAPI, void, task_end_overlapped_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id),                                                    (ITT_FORMAT domain, clock_domain, timestamp, id), task_end_overlapped_ex, __itt_group_structure, "%p, %p, %lu, %lu")
+ITT_STUBV(ITTAPI, void, marker_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_string_handle *name, __itt_scope scope), (ITT_FORMAT domain, clock_domain, timestamp, id, name, scope), marker_ex, __itt_group_structure, "%p, %p, %lu, %lu, %p, %d")
+ITT_STUBV(ITTAPI, void, metadata_add_with_scope, (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, __itt_metadata_type type, size_t count, void *data), (ITT_FORMAT domain, scope, key, type, count, data), metadata_add_with_scope, __itt_group_structure, "%p, %d, %p, %d, %lu, %p")
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, metadata_str_add_with_scopeA, (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const char *data, size_t length),    (ITT_FORMAT domain, scope, key, data, length), metadata_str_add_with_scopeA, __itt_group_structure, "%p, %d, %p, %p, %lu")
+ITT_STUBV(ITTAPI, void, metadata_str_add_with_scopeW, (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const wchar_t *data, size_t length), (ITT_FORMAT domain, scope, key, data, length), metadata_str_add_with_scopeW, __itt_group_structure, "%p, %d, %p, %p, %lu")
+#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, metadata_str_add_with_scope,  (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const char *data, size_t length),    (ITT_FORMAT domain, scope, key, data, length), metadata_str_add_with_scope,  __itt_group_structure, "%p, %d, %p, %p, %lu")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, relation_add_to_current_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_relation relation, __itt_id tail),                (ITT_FORMAT domain, clock_domain, timestamp, relation, tail),       relation_add_to_current_ex, __itt_group_structure, "%p, %p, %lu, %d, %lu")
+ITT_STUBV(ITTAPI, void, relation_add_ex,            (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id head, __itt_relation relation, __itt_id tail), (ITT_FORMAT domain, clock_domain, timestamp, head, relation, tail), relation_add_ex,            __itt_group_structure, "%p, %p, %lu, %lu, %d, %lu")
+ITT_STUB(ITTAPI,  __itt_track_group*, track_group_create, (__itt_string_handle* name, __itt_track_group_type track_group_type),                    (ITT_FORMAT name, track_group_type),        track_group_create, __itt_group_structure, "%p, %d")
+ITT_STUB(ITTAPI,  __itt_track*,       track_create,       (__itt_track_group* track_group,__itt_string_handle* name, __itt_track_type track_type), (ITT_FORMAT track_group, name, track_type), track_create,       __itt_group_structure, "%p, %p, %d")
+ITT_STUBV(ITTAPI, void,               set_track,          (__itt_track *track),                                                                    (ITT_FORMAT track),                         set_track,          __itt_group_structure, "%p")
+
+#ifndef __ITT_INTERNAL_BODY
+ITT_STUB(ITTAPI, const char*, api_version, (void), (ITT_NO_PARAMS), api_version, __itt_group_all & ~__itt_group_legacy, "no args")
+#endif /* __ITT_INTERNAL_BODY */
+
+#ifndef __ITT_INTERNAL_BODY
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, int, av_saveA, (void *data, int rank, const int *dimensions, int type, const char *filePath, int columnOrder), (ITT_FORMAT data, rank, dimensions, type, filePath, columnOrder), av_saveA, __itt_group_arrays, "%p, %d, %p, %d, \"%s\", %d")
+ITT_STUB(ITTAPI, int, av_saveW, (void *data, int rank, const int *dimensions, int type, const wchar_t *filePath, int columnOrder), (ITT_FORMAT data, rank, dimensions, type, filePath, columnOrder), av_saveW, __itt_group_arrays, "%p, %d, %p, %d, \"%S\", %d")
+#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, int, av_save,  (void *data, int rank, const int *dimensions, int type, const char *filePath, int columnOrder), (ITT_FORMAT data, rank, dimensions, type, filePath, columnOrder), av_save,  __itt_group_arrays, "%p, %d, %p, %d, \"%s\", %d")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* __ITT_INTERNAL_BODY */
+
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, module_loadA, (void *start_addr, void* end_addr, const char *path), (ITT_FORMAT start_addr, end_addr, path), module_loadA, __itt_group_module, "%p, %p, %p")
+ITT_STUBV(ITTAPI, void, module_loadW, (void *start_addr, void* end_addr, const wchar_t *path), (ITT_FORMAT start_addr, end_addr, path), module_loadW, __itt_group_module, "%p, %p, %p")
+#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, module_load, (void *start_addr, void *end_addr, const char *path), (ITT_FORMAT start_addr, end_addr, path), module_load, __itt_group_module, "%p, %p, %p")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, module_unload, (void *start_addr), (ITT_FORMAT start_addr), module_unload, __itt_group_module, "%p")
+
+ITT_STUBV(ITTAPI, void, histogram_submit, (__itt_histogram* hist, size_t length, void* x_data, void* y_data), (ITT_FORMAT hist, length, x_data, y_data), histogram_submit, __itt_group_structure, "%p, %lu, %p, %p")
+
+#endif /* __ITT_INTERNAL_INIT */

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/common/ittnotify/ittnotify_types.h

@@ -0,0 +1,65 @@
+/*
+  Copyright (C) 2005-2019 Intel Corporation
+
+  SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause
+*/
+
+#ifndef _ITTNOTIFY_TYPES_H_
+#define _ITTNOTIFY_TYPES_H_
+
+typedef enum ___itt_group_id
+{
+    __itt_group_none      		= 0,
+    __itt_group_legacy    		= 1<<0,
+    __itt_group_control   		= 1<<1,
+    __itt_group_thread    		= 1<<2,
+    __itt_group_mark      		= 1<<3,
+    __itt_group_sync      		= 1<<4,
+    __itt_group_fsync     		= 1<<5,
+    __itt_group_jit       		= 1<<6,
+    __itt_group_model     		= 1<<7,
+    __itt_group_splitter_min 	= 1<<7,
+    __itt_group_counter   		= 1<<8,
+    __itt_group_frame     		= 1<<9,
+    __itt_group_stitch    		= 1<<10,
+    __itt_group_heap      		= 1<<11,
+    __itt_group_splitter_max 	= 1<<12,
+    __itt_group_structure 		= 1<<12,
+    __itt_group_suppress 		= 1<<13,
+    __itt_group_arrays    		= 1<<14,
+    __itt_group_module    		= 1<<15,
+    __itt_group_all       		= -1
+} __itt_group_id;
+
+#pragma pack(push, 8)
+
+typedef struct ___itt_group_list
+{
+    __itt_group_id id;
+    const char*    name;
+} __itt_group_list;
+
+#pragma pack(pop)
+
+#define ITT_GROUP_LIST(varname) \
+    static __itt_group_list varname[] = {       \
+        { __itt_group_all,       "all"       }, \
+        { __itt_group_control,   "control"   }, \
+        { __itt_group_thread,    "thread"    }, \
+        { __itt_group_mark,      "mark"      }, \
+        { __itt_group_sync,      "sync"      }, \
+        { __itt_group_fsync,     "fsync"     }, \
+        { __itt_group_jit,       "jit"       }, \
+        { __itt_group_model,     "model"     }, \
+        { __itt_group_counter,   "counter"   }, \
+        { __itt_group_frame,     "frame"     }, \
+        { __itt_group_stitch,    "stitch"    }, \
+        { __itt_group_heap,      "heap"      }, \
+        { __itt_group_structure, "structure" }, \
+        { __itt_group_suppress,  "suppress"  }, \
+        { __itt_group_arrays,    "arrays"    }, \
+		{ __itt_group_module,    "module"    }, \
+        { __itt_group_none,      NULL        }  \
+    }
+
+#endif /* _ITTNOTIFY_TYPES_H_ */

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/common/ittnotify/jitprofiling.h

@@ -0,0 +1,642 @@
+/*
+  Copyright (C) 2005-2019 Intel Corporation
+
+  SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause
+*/
+
+#ifndef __JITPROFILING_H__
+#define __JITPROFILING_H__
+
+/**
+ * @brief JIT Profiling APIs
+ *
+ * The JIT Profiling API is used to report information about just-in-time
+ * generated code that can be used by performance tools. The user inserts
+ * calls in the code generator to report information before JIT-compiled
+ * code goes to execution. This information is collected at runtime and used
+ * by tools like Intel(R) VTune(TM) Amplifier to display performance metrics
+ * associated with JIT-compiled code.
+ *
+ * These APIs can be used to\n
+ * - **Profile trace-based and method-based JIT-compiled
+ * code**. Some examples of environments that you can profile with these APIs:
+ * dynamic JIT compilation of JavaScript code traces, JIT execution in OpenCL(TM)
+ * software technology, Java/.NET managed execution environments, and custom
+ * ISV JIT engines.
+ * @code
+ * #include <jitprofiling.h>
+ *
+ * if (iJIT_IsProfilingActive != iJIT_SAMPLING_ON) {
+ *     return;
+ * }
+ *
+ * iJIT_Method_Load jmethod = {0};
+ * jmethod.method_id = iJIT_GetNewMethodID();
+ * jmethod.method_name = "method_name";
+ * jmethod.class_file_name = "class_name";
+ * jmethod.source_file_name = "source_file_name";
+ * jmethod.method_load_address = code_addr;
+ * jmethod.method_size = code_size;
+ *
+ * iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, (void*)&jmethod);
+ * iJIT_NotifyEvent(iJVM_EVENT_TYPE_SHUTDOWN, NULL);
+ * @endcode
+ *
+ *  * Expected behavior:
+ *    * If any iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED event overwrites an
+ *      already reported method, then such a method becomes invalid and its
+ *      memory region is treated as unloaded. VTune Amplifier displays the metrics
+ *      collected by the method until it is overwritten.
+ *    * If supplied line number information contains multiple source lines for
+ *      the same assembly instruction (code location), then VTune Amplifier picks up
+ *      the first line number.
+ *    * Dynamically generated code can be associated with a module name.
+ *      Use the iJIT_Method_Load_V2 structure.\n
+ *      Clarification of some cases:
+ *        * If you register a function with the same method ID multiple times,
+ *          specifying different module names, then the VTune Amplifier picks up
+ *          the module name registered first. If you want to distinguish the same
+ *          function between different JIT engines, supply different method IDs for
+ *          each function. Other symbolic information (for example, source file)
+ *          can be identical.
+ *
+ * - **Analyze split functions** (multiple joint or disjoint code regions
+ * belonging to the same function) **including re-JIT**
+ * with potential overlapping of code regions in time, which is common in
+ * resource-limited environments.
+ * @code
+ * #include <jitprofiling.h>
+ *
+ * unsigned int method_id = iJIT_GetNewMethodID();
+ *
+ * iJIT_Method_Load a = {0};
+ * a.method_id = method_id;
+ * a.method_load_address = 0x100;
+ * a.method_size = 0x20;
+ *
+ * iJIT_Method_Load b = {0};
+ * b.method_id = method_id;
+ * b.method_load_address = 0x200;
+ * b.method_size = 0x30;
+ *
+ * iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, (void*)&a);
+ * iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, (void*)&b);
+ * @endcode
+ *
+ *  * Expected behaviour:
+ *      * If a iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED event overwrites an
+ *        already reported method, then such a method becomes invalid and
+ *        its memory region is treated as unloaded.
+ *      * All code regions reported with the same method ID are considered as
+ *        belonging to the same method. Symbolic information (method name,
+ *        source file name) will be taken from the first notification, and all
+ *        subsequent notifications with the same method ID will be processed
+ *        only for line number table information. So, the VTune Amplifier will map
+ *        samples to a source line using the line number table from the current
+ *        notification while taking the source file name from the very first one.\n
+ *        Clarification of some cases:\n
+ *          * If you register a second code region with a different source file
+ *          name and the same method ID, then this information will be saved and
+ *          will not be considered as an extension of the first code region, but
+ *          VTune Amplifier will use the source file of the first code region and map
+ *          performance metrics incorrectly.
+ *          * If you register a second code region with the same source file as
+ *          for the first region and the same method ID, then the source file will be
+ *          discarded but VTune Amplifier will map metrics to the source file correctly.
+ *          * If you register a second code region with a null source file and
+ *          the same method ID, then provided line number info will be associated
+ *          with the source file of the first code region.
+ *
+ * - **Explore inline functions** including multi-level hierarchy of
+ * nested inline methods which shows how performance metrics are distributed through them.
+ * @code
+ * #include <jitprofiling.h>
+ *
+ *  //                                    method_id   parent_id
+ *  //   [-- c --]                          3000        2000
+ *  //                  [---- d -----]      2001        1000
+ *  //  [---- b ----]                       2000        1000
+ *  // [------------ a ----------------]    1000         n/a
+ *
+ * iJIT_Method_Load a = {0};
+ * a.method_id = 1000;
+ *
+ * iJIT_Method_Inline_Load b = {0};
+ * b.method_id = 2000;
+ * b.parent_method_id = 1000;
+ *
+ * iJIT_Method_Inline_Load c = {0};
+ * c.method_id = 3000;
+ * c.parent_method_id = 2000;
+ *
+ * iJIT_Method_Inline_Load d = {0};
+ * d.method_id = 2001;
+ * d.parent_method_id = 1000;
+ *
+ * iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, (void*)&a);
+ * iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED, (void*)&b);
+ * iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED, (void*)&c);
+ * iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED, (void*)&d);
+ * @endcode
+ *
+ *  * Requirements:
+ *      * Each inline (iJIT_Method_Inline_Load) method should be associated
+ *        with two method IDs: one for itself; one for its immediate parent.
+ *      * Address regions of inline methods of the same parent method cannot
+ *        overlap each other.
+ *      * Execution of the parent method must not be started until it and all
+ *        its inline methods are reported.
+ *  * Expected behaviour:
+ *      * In case of nested inline methods an order of
+ *        iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED events is not important.
+ *      * If any event overwrites either inline method or top parent method,
+ *        then the parent, including inline methods, becomes invalid and its memory
+ *        region is treated as unloaded.
+ *
+ * **Life time of allocated data**\n
+ * The client sends an event notification to the agent with event-specific
+ * data, which is a structure. The pointers in the structure refer to memory
+ * allocated by the client, which responsible for releasing it. The pointers are
+ * used by the iJIT_NotifyEvent method to copy client's data in a trace file,
+ * and they are not used after the iJIT_NotifyEvent method returns.
+ */
+
+/**
+ * @defgroup jitapi JIT Profiling
+ * @ingroup internal
+ * @{
+ */
+
+/**
+ * @brief Enumerator for the types of notifications
+ */
+typedef enum iJIT_jvm_event
+{
+    iJVM_EVENT_TYPE_SHUTDOWN = 2,               /**<\brief Send this to shutdown the agent.
+                                                 * Use NULL for event data. */
+
+    iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED = 13,  /**<\brief Send when dynamic code is
+                                                 * JIT compiled and loaded into
+                                                 * memory by the JIT engine, but
+                                                 * before the code is executed.
+                                                 * Use iJIT_Method_Load as event
+                                                 * data. */
+/** @cond exclude_from_documentation */
+    iJVM_EVENT_TYPE_METHOD_UNLOAD_START,    /**<\brief Send when compiled dynamic
+                                             * code is being unloaded from memory.
+                                             * Use iJIT_Method_Load as event data.*/
+/** @endcond */
+
+    iJVM_EVENT_TYPE_METHOD_UPDATE,   /**<\brief Send to provide new content for
+                                      * a previously reported dynamic code.
+                                      * The previous content will be invalidated
+                                      * starting from the time of the notification.
+                                      * Use iJIT_Method_Load as event data but
+                                      * required fields are following:
+                                      * - method_id    identify the code to update.
+                                      * - method_load_address    specify start address
+                                      *                          within identified code range
+                                      *                          where update should be started.
+                                      * - method_size            specify length of updated code
+                                      *                          range. */
+
+
+    iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED, /**<\brief Send when an inline dynamic
+                                                  * code is JIT compiled and loaded
+                                                  * into memory by the JIT engine,
+                                                  * but before the parent code region
+                                                  * starts executing.
+                                                  * Use iJIT_Method_Inline_Load as event data.*/
+
+/** @cond exclude_from_documentation */
+    iJVM_EVENT_TYPE_METHOD_UPDATE_V2,
+/** @endcond */
+
+    iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED_V2 = 21, /**<\brief Send when a dynamic code is
+                                                   * JIT compiled and loaded into
+                                                   * memory by the JIT engine, but
+                                                   * before the code is executed.
+                                                   * Use iJIT_Method_Load_V2 as event data. */
+
+    iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED_V3       /**<\brief Send when a dynamic code is
+                                                   * JIT compiled and loaded into
+                                                   * memory by the JIT engine, but
+                                                   * before the code is executed.
+                                                   * Use iJIT_Method_Load_V3 as event data. */
+} iJIT_JVM_EVENT;
+
+/**
+ * @brief Enumerator for the agent's mode
+ */
+typedef enum _iJIT_IsProfilingActiveFlags
+{
+    iJIT_NOTHING_RUNNING           = 0x0000,    /**<\brief The agent is not running;
+                                                 * iJIT_NotifyEvent calls will
+                                                 * not be processed. */
+    iJIT_SAMPLING_ON               = 0x0001,    /**<\brief The agent is running and
+                                                 * ready to process notifications. */
+} iJIT_IsProfilingActiveFlags;
+
+/**
+ * @brief Description of a single entry in the line number information of a code region.
+ * @details A table of line number entries gives information about how the reported code region
+ * is mapped to source file.
+ * Intel(R) VTune(TM) Amplifier uses line number information to attribute
+ * the samples (virtual address) to a line number. \n
+ * It is acceptable to report different code addresses for the same source line:
+ * @code
+ *   Offset LineNumber
+ *      1       2
+ *      12      4
+ *      15      2
+ *      18      1
+ *      21      30
+ *
+ *  VTune Amplifier constructs the following table using the client data
+ *
+ *   Code subrange  Line number
+ *      0-1             2
+ *      1-12            4
+ *      12-15           2
+ *      15-18           1
+ *      18-21           30
+ * @endcode
+ */
+typedef struct _LineNumberInfo
+{
+    unsigned int Offset;     /**<\brief Offset from the begining of the code region. */
+    unsigned int LineNumber; /**<\brief Matching source line number offset (from beginning of source file). */
+
+} *pLineNumberInfo, LineNumberInfo;
+
+/**
+ * @brief Enumerator for the code architecture.
+ */
+typedef enum _iJIT_CodeArchitecture
+{
+    iJIT_CA_NATIVE = 0, /**<\brief Native to the process architecture that is calling it. */
+
+    iJIT_CA_32,         /**<\brief 32-bit machine code. */
+
+    iJIT_CA_64          /**<\brief 64-bit machine code. */
+
+} iJIT_CodeArchitecture;
+
+#pragma pack(push, 8)
+
+/**
+ * @brief Description of a JIT-compiled method
+ * @details When you use the iJIT_Method_Load structure to describe
+ *  the JIT compiled method, use iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED
+ *  as an event type to report it.
+ */
+typedef struct _iJIT_Method_Load
+{
+    unsigned int method_id; /**<\brief Unique method ID. Cannot be 0.
+                             *  You must either use the API function
+                             *  iJIT_GetNewMethodID to get a valid and unique
+                             *  method ID, or else manage ID uniqueness
+                             *  and correct range by yourself.\n
+                             *  You must use the same method ID for all code
+                             *  regions of the same method, otherwise different
+                             *  method IDs specify different methods. */
+
+    char* method_name; /**<\brief The name of the method. It can be optionally
+                        *  prefixed with its class name and appended with
+                        *  its complete signature. Can't be NULL. */
+
+    void* method_load_address; /**<\brief The start virtual address of the method code
+                                *  region. If NULL, data provided with
+                                *  event are not accepted. */
+
+    unsigned int method_size; /**<\brief The code size of the method in memory.
+                               *  If 0, then data provided with the event are not
+                               *  accepted. */
+
+    unsigned int line_number_size; /**<\brief The number of entries in the line number
+                                    *  table.0 if none. */
+
+    pLineNumberInfo line_number_table; /**<\brief Pointer to the line numbers info
+                                        *  array. Can be NULL if
+                                        *  line_number_size is 0. See
+                                        *  LineNumberInfo Structure for a
+                                        *  description of a single entry in
+                                        *  the line number info array */
+
+    unsigned int class_id; /**<\brief This field is obsolete. */
+
+    char* class_file_name; /**<\brief Class name. Can be NULL.*/
+
+    char* source_file_name; /**<\brief Source file name. Can be NULL.*/
+
+} *piJIT_Method_Load, iJIT_Method_Load;
+
+/**
+ * @brief Description of a JIT-compiled method
+ * @details When you use the iJIT_Method_Load_V2 structure to describe
+ *  the JIT compiled method, use iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED_V2
+ *  as an event type to report it.
+ */
+typedef struct _iJIT_Method_Load_V2
+{
+    unsigned int method_id; /**<\brief Unique method ID. Cannot be 0.
+                             *  You must either use the API function
+                             *  iJIT_GetNewMethodID to get a valid and unique
+                             *  method ID, or else manage ID uniqueness
+                             *  and correct range by yourself.\n
+                             *  You must use the same method ID for all code
+                             *  regions of the same method, otherwise different
+                             *  method IDs specify different methods. */
+
+    char* method_name; /**<\brief The name of the method. It can be optionally
+                        *  prefixed with its class name and appended with
+                        *  its complete signature. Can't be  NULL. */
+
+    void* method_load_address; /**<\brief The start virtual address of the method code
+                                *  region. If NULL, then data provided with the
+                                *  event are not accepted. */
+
+    unsigned int method_size; /**<\brief The code size of the method in memory.
+                               *  If 0, then data provided with the event are not
+                               *  accepted. */
+
+    unsigned int line_number_size; /**<\brief The number of entries in the line number
+                                    *  table. 0 if none. */
+
+    pLineNumberInfo line_number_table; /**<\brief Pointer to the line numbers info
+                                        *  array. Can be NULL if
+                                        *  line_number_size is 0. See
+                                        *  LineNumberInfo Structure for a
+                                        *  description of a single entry in
+                                        *  the line number info array. */
+
+    char* class_file_name; /**<\brief Class name. Can be NULL. */
+
+    char* source_file_name; /**<\brief Source file name. Can be NULL. */
+
+    char* module_name; /**<\brief Module name. Can be NULL.
+                           The module name can be useful for distinguishing among
+                           different JIT engines. VTune Amplifier will display
+                           reported methods grouped by specific module. */
+
+} *piJIT_Method_Load_V2, iJIT_Method_Load_V2;
+
+/**
+ * @brief Description of a JIT-compiled method
+ * @details The iJIT_Method_Load_V3 structure is the same as iJIT_Method_Load_V2
+ *  with a newly introduced 'arch' field that specifies architecture of the code region.
+ *  When you use the iJIT_Method_Load_V3 structure to describe
+ *  the JIT compiled method, use iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED_V3
+ *  as an event type to report it.
+ */
+typedef struct _iJIT_Method_Load_V3
+{
+    unsigned int method_id; /**<\brief Unique method ID. Cannot be 0.
+                             *  You must either use the API function
+                             *  iJIT_GetNewMethodID to get a valid and unique
+                             *  method ID, or manage ID uniqueness
+                             *  and correct range by yourself.\n
+                             *  You must use the same method ID for all code
+                             *  regions of the same method, otherwise they are
+                             *  treated as regions of different methods. */
+
+    char* method_name; /**<\brief The name of the method. It can be optionally
+                        *  prefixed with its class name and appended with
+                        *  its complete signature. Cannot be  NULL. */
+
+    void* method_load_address; /**<\brief The start virtual address of the method code
+                                *  region. If NULL, then data provided with the
+                                *  event are not accepted. */
+
+    unsigned int method_size; /**<\brief The code size of the method in memory.
+                               *  If 0, then data provided with the event are not
+                               *  accepted. */
+
+    unsigned int line_number_size; /**<\brief The number of entries in the line number
+                                    *  table. 0 if none. */
+
+    pLineNumberInfo line_number_table; /**<\brief Pointer to the line numbers info
+                                        *  array. Can be NULL if
+                                        *  line_number_size is 0. See
+                                        *  LineNumberInfo Structure for a
+                                        *  description of a single entry in
+                                        *  the line number info array. */
+
+    char* class_file_name; /**<\brief Class name. Can be NULL. */
+
+    char* source_file_name; /**<\brief Source file name. Can be NULL. */
+
+    char* module_name; /**<\brief Module name. Can be NULL.
+                        *  The module name can be useful for distinguishing among
+                        *  different JIT engines. VTune Amplifier will display
+                        *  reported methods grouped by specific module. */
+
+    iJIT_CodeArchitecture module_arch; /**<\brief Architecture of the method's code region.
+                                        *  By default, it is the same as the process
+                                        *  architecture that is calling it.
+                                        *  For example, you can use it if your 32-bit JIT
+                                        *  engine generates 64-bit code.
+                                        *
+                                        *  If JIT engine reports both 32-bit and 64-bit types
+                                        *  of methods then VTune Amplifier splits the methods
+                                        *  with the same module name but with different
+                                        *  architectures in two different modules. VTune Amplifier
+                                        *  modifies the original name provided with a 64-bit method
+                                        *  version by ending it with '(64)' */
+
+} *piJIT_Method_Load_V3, iJIT_Method_Load_V3;
+
+/**
+ * @brief Description of an inline JIT-compiled method
+ * @details When you use the_iJIT_Method_Inline_Load structure to describe
+ *  the JIT compiled method, use iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED
+ *  as an event type to report it.
+ */
+typedef struct _iJIT_Method_Inline_Load
+{
+    unsigned int method_id; /**<\brief Unique method ID. Cannot be 0.
+                             *  You must either use the API function
+                             *  iJIT_GetNewMethodID to get a valid and unique
+                             *  method ID, or else manage ID uniqueness
+                             *  and correct range by yourself. */
+
+    unsigned int parent_method_id; /**<\brief Unique immediate parent's method ID.
+                                    *  Cannot be 0.
+                                    *  You must either use the API function
+                                    *  iJIT_GetNewMethodID to get a valid and unique
+                                    *  method ID, or else manage ID uniqueness
+                                    *  and correct range by yourself. */
+
+    char* method_name; /**<\brief The name of the method. It can be optionally
+                        *  prefixed with its class name and appended with
+                        *  its complete signature. Can't be NULL. */
+
+    void* method_load_address;  /** <\brief The virtual address on which the method
+                                 *  is inlined. If NULL, then data provided with
+                                 *  the event are not accepted. */
+
+    unsigned int method_size; /**<\brief The code size of the method in memory.
+                               *  If 0, then data provided with the event are not
+                               *  accepted. */
+
+    unsigned int line_number_size; /**<\brief The number of entries in the line number
+                                    *  table. 0 if none. */
+
+    pLineNumberInfo line_number_table; /**<\brief Pointer to the line numbers info
+                                        *  array. Can be NULL if
+                                        *  line_number_size is 0. See
+                                        *  LineNumberInfo Structure for a
+                                        *  description of a single entry in
+                                        *  the line number info array */
+
+    char* class_file_name; /**<\brief Class name. Can be NULL.*/
+
+    char* source_file_name; /**<\brief Source file name. Can be NULL.*/
+
+} *piJIT_Method_Inline_Load, iJIT_Method_Inline_Load;
+
+/** @cond exclude_from_documentation */
+/**
+ * @brief Description of a segment type
+ * @details Use the segment type to specify a type of data supplied
+ * with the iJVM_EVENT_TYPE_METHOD_UPDATE_V2 event to be applied to
+ * a certain code trace.
+ */
+typedef enum _iJIT_SegmentType
+{
+    iJIT_CT_UNKNOWN = 0,
+
+    iJIT_CT_CODE,           /**<\brief Executable code. */
+
+    iJIT_CT_DATA,           /**<\brief Data (not executable code).
+                             * VTune Amplifier uses the format string
+                             * (see iJIT_Method_Update) to represent
+                             * this data in the VTune Amplifier GUI */
+
+    iJIT_CT_KEEP,           /**<\brief Use the previous markup for the trace.
+                             * Can be used for the following
+                             * iJVM_EVENT_TYPE_METHOD_UPDATE_V2 events,
+                             * if the type of the previously reported segment
+                             * type is the same. */
+    iJIT_CT_EOF
+} iJIT_SegmentType;
+
+/**
+ * @brief Description of a dynamic update of the content within JIT-compiled method
+ * @details The JIT engine may generate the methods that are updated at runtime
+ * partially by mixed (data + executable code) content. When you use the iJIT_Method_Update
+ * structure to describe the update of the content within a JIT-compiled method,
+ * use iJVM_EVENT_TYPE_METHOD_UPDATE_V2 as an event type to report it.
+ *
+ * On the first Update event, VTune Amplifier copies the original code range reported by
+ * the iJVM_EVENT_TYPE_METHOD_LOAD event, then modifies it with the supplied bytes and
+ * adds the modified range to the original method. For next update events, VTune Amplifier
+ * does the same but it uses the latest modified version of a code region for update.
+ * Eventually, VTune Amplifier GUI displays multiple code ranges for the method reported by
+ * the iJVM_EVENT_TYPE_METHOD_LOAD event.
+ * Notes:
+ * - Multiple update events with different types for the same trace are allowed
+ *   but they must be reported for the same code ranges.
+ *   Example,
+ * @code
+ *                      [-- data---]        Allowed
+ *          [-- code --]                    Allowed
+ *        [code]                            Ignored
+ *                      [-- data---]        Allowed
+ *          [-- code --]                    Allowed
+ *      [------------ trace ---------]
+ * @endcode
+ * - The types of previously reported events can be changed but they must be reported
+ *   for the same code ranges.
+ *   Example,
+ * @code
+ *          [-- data---]                    Allowed
+ *          [-- code --]                    Allowed
+ *          [-- data---]                    Allowed
+ *          [-- code --]                    Allowed
+ *      [------------ trace ---------]
+ * @endcode
+ */
+
+typedef struct _iJIT_Method_Update
+{
+    void* load_address;         /**<\brief Start address of the update within a method */
+
+    unsigned int size;          /**<\brief The update size */
+
+    iJIT_SegmentType type;      /**<\brief Type of the update */
+
+    const char* data_format;    /**<\brief C string that contains a format string
+                                 * that follows the same specifications as format in printf.
+                                 * The format string is used for iJIT_CT_CODE only
+                                 * and cannot be NULL.
+                                 * Format can be changed on the fly. */
+} *piJIT_Method_Update, iJIT_Method_Update;
+
+/** @endcond */
+
+#pragma pack(pop)
+
+/** @cond exclude_from_documentation */
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#ifndef JITAPI_CDECL
+#  if defined WIN32 || defined _WIN32
+#    define JITAPI_CDECL __cdecl
+#  else /* defined WIN32 || defined _WIN32 */
+#    if defined _M_IX86 || defined __i386__
+#      define JITAPI_CDECL __attribute__ ((cdecl))
+#    else  /* _M_IX86 || __i386__ */
+#      define JITAPI_CDECL /* actual only on x86_64 platform */
+#    endif /* _M_IX86 || __i386__ */
+#  endif /* defined WIN32 || defined _WIN32 */
+#endif /* JITAPI_CDECL */
+
+#define JITAPI JITAPI_CDECL
+/** @endcond */
+
+/**
+ * @brief Generates a new unique method ID.
+ *
+ * You must use this API to obtain unique and valid method IDs for methods or
+ * traces reported to the agent if you don't have your own mechanism to generate
+ * unique method IDs.
+ *
+ * @return a new unique method ID. When out of unique method IDs, this API
+ * returns 0, which is not an accepted value.
+ */
+unsigned int JITAPI iJIT_GetNewMethodID(void);
+
+/**
+ * @brief Returns the current mode of the agent.
+ *
+ * @return iJIT_SAMPLING_ON, indicating that agent is running, or
+ * iJIT_NOTHING_RUNNING if no agent is running.
+ */
+iJIT_IsProfilingActiveFlags JITAPI iJIT_IsProfilingActive(void);
+
+/**
+ * @brief Reports infomation about JIT-compiled code to the agent.
+ *
+ * The reported information is used to attribute samples obtained from any
+ * Intel(R) VTune(TM) Amplifier collector. This API needs to be called
+ * after JIT compilation and before the first entry into the JIT-compiled
+ * code.
+ *
+ * @param[in] event_type - type of the data sent to the agent
+ * @param[in] EventSpecificData - pointer to event-specific data
+ * 
+ * @returns 1 on success, otherwise 0.
+ */
+int JITAPI iJIT_NotifyEvent(iJIT_JVM_EVENT event_type, void *EventSpecificData);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+/** @endcond */
+
+/** @} jitapi group */
+
+#endif /* __JITPROFILING_H__ */

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/common/ittnotify/legacy/ittnotify.h

@@ -0,0 +1,992 @@
+/*
+  Copyright (C) 2005-2019 Intel Corporation
+
+  SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause
+*/
+#ifndef _LEGACY_ITTNOTIFY_H_
+#define _LEGACY_ITTNOTIFY_H_
+
+/**
+ * @file
+ * @brief Legacy User API functions and types
+ */
+
+/** @cond exclude_from_documentation */
+#ifndef ITT_OS_WIN
+#  define ITT_OS_WIN   1
+#endif /* ITT_OS_WIN */
+
+#ifndef ITT_OS_LINUX
+#  define ITT_OS_LINUX 2
+#endif /* ITT_OS_LINUX */
+
+#ifndef ITT_OS_MAC
+#  define ITT_OS_MAC   3
+#endif /* ITT_OS_MAC */
+
+#ifndef ITT_OS_FREEBSD
+#  define ITT_OS_FREEBSD   4
+#endif /* ITT_OS_FREEBSD */
+
+#ifndef ITT_OS
+#  if defined WIN32 || defined _WIN32
+#    define ITT_OS ITT_OS_WIN
+#  elif defined( __APPLE__ ) && defined( __MACH__ )
+#    define ITT_OS ITT_OS_MAC
+#  elif defined( __FreeBSD__ )
+#    define ITT_OS ITT_OS_FREEBSD
+#  else
+#    define ITT_OS ITT_OS_LINUX
+#  endif
+#endif /* ITT_OS */
+
+#ifndef ITT_PLATFORM_WIN
+#  define ITT_PLATFORM_WIN 1
+#endif /* ITT_PLATFORM_WIN */
+
+#ifndef ITT_PLATFORM_POSIX
+#  define ITT_PLATFORM_POSIX 2
+#endif /* ITT_PLATFORM_POSIX */
+
+#ifndef ITT_PLATFORM_MAC
+#  define ITT_PLATFORM_MAC 3
+#endif /* ITT_PLATFORM_MAC */
+
+#ifndef ITT_PLATFORM_FREEBSD
+#  define ITT_PLATFORM_FREEBSD 4
+#endif /* ITT_PLATFORM_FREEBSD */
+
+#ifndef ITT_PLATFORM
+#  if ITT_OS==ITT_OS_WIN
+#    define ITT_PLATFORM ITT_PLATFORM_WIN
+#  elif ITT_OS==ITT_OS_MAC
+#    define ITT_PLATFORM ITT_PLATFORM_MAC
+#  elif ITT_OS==ITT_OS_FREEBSD
+#    define ITT_PLATFORM ITT_PLATFORM_FREEBSD
+#  else
+#    define ITT_PLATFORM ITT_PLATFORM_POSIX
+#  endif
+#endif /* ITT_PLATFORM */
+
+#if defined(_UNICODE) && !defined(UNICODE)
+#define UNICODE
+#endif
+
+#include <stddef.h>
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#include <tchar.h>
+#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#include <stdint.h>
+#if defined(UNICODE) || defined(_UNICODE)
+#include <wchar.h>
+#endif /* UNICODE || _UNICODE */
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+#ifndef ITTAPI_CDECL
+#  if ITT_PLATFORM==ITT_PLATFORM_WIN
+#    define ITTAPI_CDECL __cdecl
+#  else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#    if defined _M_IX86 || defined __i386__
+#      define ITTAPI_CDECL __attribute__ ((cdecl))
+#    else  /* _M_IX86 || __i386__ */
+#      define ITTAPI_CDECL /* actual only on x86 platform */
+#    endif /* _M_IX86 || __i386__ */
+#  endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* ITTAPI_CDECL */
+
+#ifndef STDCALL
+#  if ITT_PLATFORM==ITT_PLATFORM_WIN
+#    define STDCALL __stdcall
+#  else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#    if defined _M_IX86 || defined __i386__
+#      define STDCALL __attribute__ ((stdcall))
+#    else  /* _M_IX86 || __i386__ */
+#      define STDCALL /* supported only on x86 platform */
+#    endif /* _M_IX86 || __i386__ */
+#  endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* STDCALL */
+
+#define ITTAPI    ITTAPI_CDECL
+#define LIBITTAPI ITTAPI_CDECL
+
+/* TODO: Temporary for compatibility! */
+#define ITTAPI_CALL    ITTAPI_CDECL
+#define LIBITTAPI_CALL ITTAPI_CDECL
+
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+/* use __forceinline (VC++ specific) */
+#if defined(__MINGW32__) && !defined(__cplusplus)
+#define ITT_INLINE           static __inline__ __attribute__((__always_inline__,__gnu_inline__))
+#else
+#define ITT_INLINE           static __forceinline
+#endif /* __MINGW32__ */
+
+#define ITT_INLINE_ATTRIBUTE /* nothing */
+#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+/*
+ * Generally, functions are not inlined unless optimization is specified.
+ * For functions declared inline, this attribute inlines the function even
+ * if no optimization level was specified.
+ */
+#ifdef __STRICT_ANSI__
+#define ITT_INLINE           static
+#define ITT_INLINE_ATTRIBUTE __attribute__((unused))
+#else  /* __STRICT_ANSI__ */
+#define ITT_INLINE           static inline
+#define ITT_INLINE_ATTRIBUTE __attribute__((always_inline, unused))
+#endif /* __STRICT_ANSI__ */
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+/** @endcond */
+
+/** @cond exclude_from_documentation */
+/* Helper macro for joining tokens */
+#define ITT_JOIN_AUX(p,n) p##n
+#define ITT_JOIN(p,n)     ITT_JOIN_AUX(p,n)
+
+#ifdef ITT_MAJOR
+#undef ITT_MAJOR
+#endif
+#ifdef ITT_MINOR
+#undef ITT_MINOR
+#endif
+#define ITT_MAJOR     3
+#define ITT_MINOR     0
+
+/* Standard versioning of a token with major and minor version numbers */
+#define ITT_VERSIONIZE(x)    \
+    ITT_JOIN(x,              \
+    ITT_JOIN(_,              \
+    ITT_JOIN(ITT_MAJOR,      \
+    ITT_JOIN(_, ITT_MINOR))))
+
+#ifndef INTEL_ITTNOTIFY_PREFIX
+#  define INTEL_ITTNOTIFY_PREFIX __itt_
+#endif /* INTEL_ITTNOTIFY_PREFIX */
+#ifndef INTEL_ITTNOTIFY_POSTFIX
+#  define INTEL_ITTNOTIFY_POSTFIX _ptr_
+#endif /* INTEL_ITTNOTIFY_POSTFIX */
+
+#define ITTNOTIFY_NAME_AUX(n) ITT_JOIN(INTEL_ITTNOTIFY_PREFIX,n)
+#define ITTNOTIFY_NAME(n)     ITT_VERSIONIZE(ITTNOTIFY_NAME_AUX(ITT_JOIN(n,INTEL_ITTNOTIFY_POSTFIX)))
+
+#define ITTNOTIFY_VOID(n) (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)
+#define ITTNOTIFY_DATA(n) (!ITTNOTIFY_NAME(n)) ?       0 : ITTNOTIFY_NAME(n)
+
+#define ITTNOTIFY_VOID_D0(n,d)       (d == NULL) ? (void)0 : (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d)
+#define ITTNOTIFY_VOID_D1(n,d,x)     (d == NULL) ? (void)0 : (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x)
+#define ITTNOTIFY_VOID_D2(n,d,x,y)   (d == NULL) ? (void)0 : (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y)
+#define ITTNOTIFY_VOID_D3(n,d,x,y,z) (d == NULL) ? (void)0 : (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z)
+#define ITTNOTIFY_VOID_D4(n,d,x,y,z,a)     (d == NULL) ? (void)0 : (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z,a)
+#define ITTNOTIFY_VOID_D5(n,d,x,y,z,a,b)   (d == NULL) ? (void)0 : (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b)
+#define ITTNOTIFY_VOID_D6(n,d,x,y,z,a,b,c) (d == NULL) ? (void)0 : (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b,c)
+#define ITTNOTIFY_DATA_D0(n,d)       (d == NULL) ? 0 : (!(d)->flags) ?       0 : (!ITTNOTIFY_NAME(n)) ?       0 : ITTNOTIFY_NAME(n)(d)
+#define ITTNOTIFY_DATA_D1(n,d,x)     (d == NULL) ? 0 : (!(d)->flags) ?       0 : (!ITTNOTIFY_NAME(n)) ?       0 : ITTNOTIFY_NAME(n)(d,x)
+#define ITTNOTIFY_DATA_D2(n,d,x,y)   (d == NULL) ? 0 : (!(d)->flags) ?       0 : (!ITTNOTIFY_NAME(n)) ?       0 : ITTNOTIFY_NAME(n)(d,x,y)
+#define ITTNOTIFY_DATA_D3(n,d,x,y,z) (d == NULL) ? 0 : (!(d)->flags) ?       0 : (!ITTNOTIFY_NAME(n)) ?       0 : ITTNOTIFY_NAME(n)(d,x,y,z)
+#define ITTNOTIFY_DATA_D4(n,d,x,y,z,a)     (d == NULL) ? 0 : (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ?       0 : ITTNOTIFY_NAME(n)(d,x,y,z,a)
+#define ITTNOTIFY_DATA_D5(n,d,x,y,z,a,b)   (d == NULL) ? 0 : (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ?       0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b)
+#define ITTNOTIFY_DATA_D6(n,d,x,y,z,a,b,c) (d == NULL) ? 0 : (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ?       0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b,c)
+
+#ifdef ITT_STUB
+#undef ITT_STUB
+#endif
+#ifdef ITT_STUBV
+#undef ITT_STUBV
+#endif
+#define ITT_STUBV(api,type,name,args)                             \
+    typedef type (api* ITT_JOIN(ITTNOTIFY_NAME(name),_t)) args;   \
+    extern ITT_JOIN(ITTNOTIFY_NAME(name),_t) ITTNOTIFY_NAME(name);
+#define ITT_STUB ITT_STUBV
+/** @endcond */
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/**
+ * @defgroup legacy Legacy API
+ * @{
+ * @}
+ */
+
+/**
+ * @defgroup legacy_control Collection Control
+ * @ingroup legacy
+ * General behavior: application continues to run, but no profiling information is being collected
+ *
+ * Pausing occurs not only for the current thread but for all process as well as spawned processes
+ * - Intel(R) Parallel Inspector and Intel(R) Inspector XE:
+ *   - Does not analyze or report errors that involve memory access.
+ *   - Other errors are reported as usual. Pausing data collection in
+ *     Intel(R) Parallel Inspector and Intel(R) Inspector XE
+ *     only pauses tracing and analyzing memory access.
+ *     It does not pause tracing or analyzing threading APIs.
+ *   .
+ * - Intel(R) Parallel Amplifier and Intel(R) VTune(TM) Amplifier XE:
+ *   - Does continue to record when new threads are started.
+ *   .
+ * - Other effects:
+ *   - Possible reduction of runtime overhead.
+ *   .
+ * @{
+ */
+#ifndef _ITTNOTIFY_H_
+/** @brief Pause collection */
+void ITTAPI __itt_pause(void);
+/** @brief Resume collection */
+void ITTAPI __itt_resume(void);
+/** @brief Detach collection */
+void ITTAPI __itt_detach(void);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, pause,   (void))
+ITT_STUBV(ITTAPI, void, resume,  (void))
+ITT_STUBV(ITTAPI, void, detach,  (void))
+#define __itt_pause      ITTNOTIFY_VOID(pause)
+#define __itt_pause_ptr  ITTNOTIFY_NAME(pause)
+#define __itt_resume     ITTNOTIFY_VOID(resume)
+#define __itt_resume_ptr ITTNOTIFY_NAME(resume)
+#define __itt_detach     ITTNOTIFY_VOID(detach)
+#define __itt_detach_ptr ITTNOTIFY_NAME(detach)
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_pause()
+#define __itt_pause_ptr  0
+#define __itt_resume()
+#define __itt_resume_ptr 0
+#define __itt_detach()
+#define __itt_detach_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#define __itt_pause_ptr  0
+#define __itt_resume_ptr 0
+#define __itt_detach_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+#endif /* _ITTNOTIFY_H_ */
+/** @} legacy_control group */
+
+/**
+ * @defgroup legacy_threads Threads
+ * @ingroup legacy
+ * Threads group
+ * @warning Legacy API
+ * @{
+ */
+/**
+ * @deprecated Legacy API
+ * @brief Set name to be associated with thread in analysis GUI.
+ * @return __itt_err upon failure (name or namelen being null,name and namelen mismatched)
+ */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+int LIBITTAPI __itt_thr_name_setA(const char    *name, int namelen);
+int LIBITTAPI __itt_thr_name_setW(const wchar_t *name, int namelen);
+#if defined(UNICODE) || defined(_UNICODE)
+#  define __itt_thr_name_set     __itt_thr_name_setW
+#  define __itt_thr_name_set_ptr __itt_thr_name_setW_ptr
+#else
+#  define __itt_thr_name_set     __itt_thr_name_setA
+#  define __itt_thr_name_set_ptr __itt_thr_name_setA_ptr
+#endif /* UNICODE */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+int LIBITTAPI __itt_thr_name_set(const char *name, int namelen);
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(LIBITTAPI, int, thr_name_setA, (const char    *name, int namelen))
+ITT_STUB(LIBITTAPI, int, thr_name_setW, (const wchar_t *name, int namelen))
+#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(LIBITTAPI, int, thr_name_set,  (const char    *name, int namelen))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_thr_name_setA     ITTNOTIFY_DATA(thr_name_setA)
+#define __itt_thr_name_setA_ptr ITTNOTIFY_NAME(thr_name_setA)
+#define __itt_thr_name_setW     ITTNOTIFY_DATA(thr_name_setW)
+#define __itt_thr_name_setW_ptr ITTNOTIFY_NAME(thr_name_setW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_thr_name_set     ITTNOTIFY_DATA(thr_name_set)
+#define __itt_thr_name_set_ptr ITTNOTIFY_NAME(thr_name_set)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_thr_name_setA(name, namelen)
+#define __itt_thr_name_setA_ptr 0
+#define __itt_thr_name_setW(name, namelen)
+#define __itt_thr_name_setW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_thr_name_set(name, namelen)
+#define __itt_thr_name_set_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_thr_name_setA_ptr 0
+#define __itt_thr_name_setW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_thr_name_set_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @deprecated Legacy API
+ * @brief Mark current thread as ignored from this point on, for the duration of its existence.
+ */
+void LIBITTAPI __itt_thr_ignore(void);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(LIBITTAPI, void, thr_ignore, (void))
+#define __itt_thr_ignore     ITTNOTIFY_VOID(thr_ignore)
+#define __itt_thr_ignore_ptr ITTNOTIFY_NAME(thr_ignore)
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_thr_ignore()
+#define __itt_thr_ignore_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#define __itt_thr_ignore_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/** @} legacy_threads group */
+
+/**
+ * @defgroup legacy_sync Synchronization
+ * @ingroup legacy
+ * Synchronization group
+ * @warning Legacy API
+ * @{
+ */
+/**
+ * @hideinitializer
+ * @brief possible value of attribute argument for sync object type
+ */
+#define __itt_attr_barrier 1
+
+/**
+ * @hideinitializer
+ * @brief possible value of attribute argument for sync object type
+ */
+#define __itt_attr_mutex   2
+
+/**
+ * @deprecated Legacy API
+ * @brief Assign a name to a sync object using char or Unicode string
+ * @param[in] addr    - pointer to the sync object. You should use a real pointer to your object
+ *                      to make sure that the values don't clash with other object addresses
+ * @param[in] objtype - null-terminated object type string. If NULL is passed, the object will
+ *                      be assumed to be of generic "User Synchronization" type
+ * @param[in] objname - null-terminated object name string. If NULL, no name will be assigned
+ *                      to the object -- you can use the __itt_sync_rename call later to assign
+ *                      the name
+ * @param[in] attribute - one of [#__itt_attr_barrier, #__itt_attr_mutex] values which defines the
+ *                      exact semantics of how prepare/acquired/releasing calls work.
+ */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+void ITTAPI __itt_sync_set_nameA(void *addr, const char    *objtype, const char    *objname, int attribute);
+void ITTAPI __itt_sync_set_nameW(void *addr, const wchar_t *objtype, const wchar_t *objname, int attribute);
+#if defined(UNICODE) || defined(_UNICODE)
+#  define __itt_sync_set_name     __itt_sync_set_nameW
+#  define __itt_sync_set_name_ptr __itt_sync_set_nameW_ptr
+#else /* UNICODE */
+#  define __itt_sync_set_name     __itt_sync_set_nameA
+#  define __itt_sync_set_name_ptr __itt_sync_set_nameA_ptr
+#endif /* UNICODE */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+void ITTAPI __itt_sync_set_name(void *addr, const char* objtype, const char* objname, int attribute);
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, sync_set_nameA, (void *addr, const char    *objtype, const char    *objname, int attribute))
+ITT_STUBV(ITTAPI, void, sync_set_nameW, (void *addr, const wchar_t *objtype, const wchar_t *objname, int attribute))
+#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, sync_set_name,  (void *addr, const char    *objtype, const char    *objname, int attribute))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_sync_set_nameA     ITTNOTIFY_VOID(sync_set_nameA)
+#define __itt_sync_set_nameA_ptr ITTNOTIFY_NAME(sync_set_nameA)
+#define __itt_sync_set_nameW     ITTNOTIFY_VOID(sync_set_nameW)
+#define __itt_sync_set_nameW_ptr ITTNOTIFY_NAME(sync_set_nameW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_sync_set_name     ITTNOTIFY_VOID(sync_set_name)
+#define __itt_sync_set_name_ptr ITTNOTIFY_NAME(sync_set_name)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_sync_set_nameA(addr, objtype, objname, attribute)
+#define __itt_sync_set_nameA_ptr 0
+#define __itt_sync_set_nameW(addr, objtype, objname, attribute)
+#define __itt_sync_set_nameW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_sync_set_name(addr, objtype, objname, attribute)
+#define __itt_sync_set_name_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_sync_set_nameA_ptr 0
+#define __itt_sync_set_nameW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_sync_set_name_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @deprecated Legacy API
+ * @brief Assign a name and type to a sync object using char or Unicode string
+ * @param[in] addr -      pointer to the sync object. You should use a real pointer to your object
+ *                        to make sure that the values don't clash with other object addresses
+ * @param[in] objtype -   null-terminated object type string. If NULL is passed, the object will
+ *                        be assumed to be of generic "User Synchronization" type
+ * @param[in] objname -   null-terminated object name string. If NULL, no name will be assigned
+ *                        to the object -- you can use the __itt_sync_rename call later to assign
+ *                        the name
+ * @param[in] typelen, namelen -   a length of string for appropriate objtype and objname parameter
+ * @param[in] attribute - one of [#__itt_attr_barrier, #__itt_attr_mutex] values which defines the
+ *                        exact semantics of how prepare/acquired/releasing calls work.
+ * @return __itt_err upon failure (name or namelen being null,name and namelen mismatched)
+ */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+int LIBITTAPI __itt_notify_sync_nameA(void *addr, const char    *objtype, int typelen, const char    *objname, int namelen, int attribute);
+int LIBITTAPI __itt_notify_sync_nameW(void *addr, const wchar_t *objtype, int typelen, const wchar_t *objname, int namelen, int attribute);
+#if defined(UNICODE) || defined(_UNICODE)
+#  define __itt_notify_sync_name __itt_notify_sync_nameW
+#else
+#  define __itt_notify_sync_name __itt_notify_sync_nameA
+#endif
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+int LIBITTAPI __itt_notify_sync_name(void *addr, const char *objtype, int typelen, const char *objname, int namelen, int attribute);
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(LIBITTAPI, int, notify_sync_nameA, (void *addr, const char    *objtype, int typelen, const char    *objname, int namelen, int attribute))
+ITT_STUB(LIBITTAPI, int, notify_sync_nameW, (void *addr, const wchar_t *objtype, int typelen, const wchar_t *objname, int namelen, int attribute))
+#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(LIBITTAPI, int, notify_sync_name,  (void *addr, const char    *objtype, int typelen, const char    *objname, int namelen, int attribute))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_notify_sync_nameA     ITTNOTIFY_DATA(notify_sync_nameA)
+#define __itt_notify_sync_nameA_ptr ITTNOTIFY_NAME(notify_sync_nameA)
+#define __itt_notify_sync_nameW     ITTNOTIFY_DATA(notify_sync_nameW)
+#define __itt_notify_sync_nameW_ptr ITTNOTIFY_NAME(notify_sync_nameW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_notify_sync_name     ITTNOTIFY_DATA(notify_sync_name)
+#define __itt_notify_sync_name_ptr ITTNOTIFY_NAME(notify_sync_name)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_notify_sync_nameA(addr, objtype, typelen, objname, namelen, attribute)
+#define __itt_notify_sync_nameA_ptr 0
+#define __itt_notify_sync_nameW(addr, objtype, typelen, objname, namelen, attribute)
+#define __itt_notify_sync_nameW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_notify_sync_name(addr, objtype, typelen, objname, namelen, attribute)
+#define __itt_notify_sync_name_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_notify_sync_nameA_ptr 0
+#define __itt_notify_sync_nameW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_notify_sync_name_ptr 0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @deprecated Legacy API
+ * @brief Enter spin loop on user-defined sync object
+ */
+void LIBITTAPI __itt_notify_sync_prepare(void* addr);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(LIBITTAPI, void, notify_sync_prepare, (void *addr))
+#define __itt_notify_sync_prepare     ITTNOTIFY_VOID(notify_sync_prepare)
+#define __itt_notify_sync_prepare_ptr ITTNOTIFY_NAME(notify_sync_prepare)
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_notify_sync_prepare(addr)
+#define __itt_notify_sync_prepare_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#define __itt_notify_sync_prepare_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @deprecated Legacy API
+ * @brief Quit spin loop without acquiring spin object
+ */
+void LIBITTAPI __itt_notify_sync_cancel(void *addr);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(LIBITTAPI, void, notify_sync_cancel, (void *addr))
+#define __itt_notify_sync_cancel     ITTNOTIFY_VOID(notify_sync_cancel)
+#define __itt_notify_sync_cancel_ptr ITTNOTIFY_NAME(notify_sync_cancel)
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_notify_sync_cancel(addr)
+#define __itt_notify_sync_cancel_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#define __itt_notify_sync_cancel_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @deprecated Legacy API
+ * @brief Successful spin loop completion (sync object acquired)
+ */
+void LIBITTAPI __itt_notify_sync_acquired(void *addr);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(LIBITTAPI, void, notify_sync_acquired, (void *addr))
+#define __itt_notify_sync_acquired     ITTNOTIFY_VOID(notify_sync_acquired)
+#define __itt_notify_sync_acquired_ptr ITTNOTIFY_NAME(notify_sync_acquired)
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_notify_sync_acquired(addr)
+#define __itt_notify_sync_acquired_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#define __itt_notify_sync_acquired_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @deprecated Legacy API
+ * @brief Start sync object releasing code. Is called before the lock release call.
+ */
+void LIBITTAPI __itt_notify_sync_releasing(void* addr);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(LIBITTAPI, void, notify_sync_releasing, (void *addr))
+#define __itt_notify_sync_releasing     ITTNOTIFY_VOID(notify_sync_releasing)
+#define __itt_notify_sync_releasing_ptr ITTNOTIFY_NAME(notify_sync_releasing)
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_notify_sync_releasing(addr)
+#define __itt_notify_sync_releasing_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#define __itt_notify_sync_releasing_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/** @} legacy_sync group */
+
+#ifndef _ITTNOTIFY_H_
+/**
+ * @defgroup legacy_events Events
+ * @ingroup legacy
+ * Events group
+ * @{
+ */
+
+/** @brief user event type */
+typedef int __itt_event;
+
+/**
+ * @brief Create an event notification
+ * @note name or namelen being null/name and namelen not matching, user event feature not enabled
+ * @return non-zero event identifier upon success and __itt_err otherwise
+ */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+__itt_event LIBITTAPI __itt_event_createA(const char    *name, int namelen);
+__itt_event LIBITTAPI __itt_event_createW(const wchar_t *name, int namelen);
+#if defined(UNICODE) || defined(_UNICODE)
+#  define __itt_event_create     __itt_event_createW
+#  define __itt_event_create_ptr __itt_event_createW_ptr
+#else
+#  define __itt_event_create     __itt_event_createA
+#  define __itt_event_create_ptr __itt_event_createA_ptr
+#endif /* UNICODE */
+#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+__itt_event LIBITTAPI __itt_event_create(const char *name, int namelen);
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(LIBITTAPI, __itt_event, event_createA, (const char    *name, int namelen))
+ITT_STUB(LIBITTAPI, __itt_event, event_createW, (const wchar_t *name, int namelen))
+#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(LIBITTAPI, __itt_event, event_create,  (const char *name, int namelen))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_event_createA     ITTNOTIFY_DATA(event_createA)
+#define __itt_event_createA_ptr ITTNOTIFY_NAME(event_createA)
+#define __itt_event_createW     ITTNOTIFY_DATA(event_createW)
+#define __itt_event_createW_ptr ITTNOTIFY_NAME(event_createW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_event_create      ITTNOTIFY_DATA(event_create)
+#define __itt_event_create_ptr  ITTNOTIFY_NAME(event_create)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_event_createA(name, namelen) (__itt_event)0
+#define __itt_event_createA_ptr 0
+#define __itt_event_createW(name, namelen) (__itt_event)0
+#define __itt_event_createW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_event_create(name, namelen)  (__itt_event)0
+#define __itt_event_create_ptr  0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_event_createA_ptr 0
+#define __itt_event_createW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_event_create_ptr  0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Record an event occurrence.
+ * @return __itt_err upon failure (invalid event id/user event feature not enabled)
+ */
+int LIBITTAPI __itt_event_start(__itt_event event);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUB(LIBITTAPI, int, event_start, (__itt_event event))
+#define __itt_event_start     ITTNOTIFY_DATA(event_start)
+#define __itt_event_start_ptr ITTNOTIFY_NAME(event_start)
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_event_start(event) (int)0
+#define __itt_event_start_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#define __itt_event_start_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @brief Record an event end occurrence.
+ * @note It is optional if events do not have durations.
+ * @return __itt_err upon failure (invalid event id/user event feature not enabled)
+ */
+int LIBITTAPI __itt_event_end(__itt_event event);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUB(LIBITTAPI, int, event_end, (__itt_event event))
+#define __itt_event_end     ITTNOTIFY_DATA(event_end)
+#define __itt_event_end_ptr ITTNOTIFY_NAME(event_end)
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_event_end(event) (int)0
+#define __itt_event_end_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#define __itt_event_end_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/** @} legacy_events group */
+#endif /* _ITTNOTIFY_H_ */
+
+/**
+ * @defgroup legacy_memory Memory Accesses
+ * @ingroup legacy
+ */
+
+/**
+ * @deprecated Legacy API
+ * @brief Inform the tool of memory accesses on reading
+ */
+void LIBITTAPI __itt_memory_read(void *addr, size_t size);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(LIBITTAPI, void, memory_read, (void *addr, size_t size))
+#define __itt_memory_read     ITTNOTIFY_VOID(memory_read)
+#define __itt_memory_read_ptr ITTNOTIFY_NAME(memory_read)
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_memory_read(addr, size)
+#define __itt_memory_read_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#define __itt_memory_read_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @deprecated Legacy API
+ * @brief Inform the tool of memory accesses on writing
+ */
+void LIBITTAPI __itt_memory_write(void *addr, size_t size);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(LIBITTAPI, void, memory_write, (void *addr, size_t size))
+#define __itt_memory_write     ITTNOTIFY_VOID(memory_write)
+#define __itt_memory_write_ptr ITTNOTIFY_NAME(memory_write)
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_memory_write(addr, size)
+#define __itt_memory_write_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#define __itt_memory_write_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @deprecated Legacy API
+ * @brief Inform the tool of memory accesses on updating
+ */
+void LIBITTAPI __itt_memory_update(void *address, size_t size);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(LIBITTAPI, void, memory_update, (void *addr, size_t size))
+#define __itt_memory_update     ITTNOTIFY_VOID(memory_update)
+#define __itt_memory_update_ptr ITTNOTIFY_NAME(memory_update)
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_memory_update(addr, size)
+#define __itt_memory_update_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#define __itt_memory_update_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/** @} legacy_memory group */
+
+/**
+ * @defgroup legacy_state Thread and Object States
+ * @ingroup legacy
+ */
+
+/** @brief state type */
+typedef int __itt_state_t;
+
+/** @cond exclude_from_documentation */
+typedef enum __itt_obj_state {
+    __itt_obj_state_err = 0,
+    __itt_obj_state_clr = 1,
+    __itt_obj_state_set = 2,
+    __itt_obj_state_use = 3
+} __itt_obj_state_t;
+
+typedef enum __itt_thr_state {
+    __itt_thr_state_err = 0,
+    __itt_thr_state_clr = 1,
+    __itt_thr_state_set = 2
+} __itt_thr_state_t;
+
+typedef enum __itt_obj_prop {
+    __itt_obj_prop_watch    = 1,
+    __itt_obj_prop_ignore   = 2,
+    __itt_obj_prop_sharable = 3
+} __itt_obj_prop_t;
+
+typedef enum __itt_thr_prop {
+    __itt_thr_prop_quiet = 1
+} __itt_thr_prop_t;
+/** @endcond */
+
+/**
+ * @deprecated Legacy API
+ * @brief managing thread and object states
+ */
+__itt_state_t LIBITTAPI __itt_state_get(void);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUB(ITTAPI, __itt_state_t, state_get, (void))
+#define __itt_state_get     ITTNOTIFY_DATA(state_get)
+#define __itt_state_get_ptr ITTNOTIFY_NAME(state_get)
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_state_get(void) (__itt_state_t)0
+#define __itt_state_get_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#define __itt_state_get_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @deprecated Legacy API
+ * @brief managing thread and object states
+ */
+__itt_state_t LIBITTAPI __itt_state_set(__itt_state_t s);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUB(ITTAPI, __itt_state_t, state_set, (__itt_state_t s))
+#define __itt_state_set     ITTNOTIFY_DATA(state_set)
+#define __itt_state_set_ptr ITTNOTIFY_NAME(state_set)
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_state_set(s) (__itt_state_t)0
+#define __itt_state_set_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#define __itt_state_set_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @deprecated Legacy API
+ * @brief managing thread and object modes
+ */
+__itt_thr_state_t LIBITTAPI __itt_thr_mode_set(__itt_thr_prop_t p, __itt_thr_state_t s);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUB(ITTAPI, __itt_thr_state_t, thr_mode_set, (__itt_thr_prop_t p, __itt_thr_state_t s))
+#define __itt_thr_mode_set     ITTNOTIFY_DATA(thr_mode_set)
+#define __itt_thr_mode_set_ptr ITTNOTIFY_NAME(thr_mode_set)
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_thr_mode_set(p, s) (__itt_thr_state_t)0
+#define __itt_thr_mode_set_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#define __itt_thr_mode_set_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/**
+ * @deprecated Legacy API
+ * @brief managing thread and object modes
+ */
+__itt_obj_state_t LIBITTAPI __itt_obj_mode_set(__itt_obj_prop_t p, __itt_obj_state_t s);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUB(ITTAPI, __itt_obj_state_t, obj_mode_set, (__itt_obj_prop_t p, __itt_obj_state_t s))
+#define __itt_obj_mode_set     ITTNOTIFY_DATA(obj_mode_set)
+#define __itt_obj_mode_set_ptr ITTNOTIFY_NAME(obj_mode_set)
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_obj_mode_set(p, s) (__itt_obj_state_t)0
+#define __itt_obj_mode_set_ptr 0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#define __itt_obj_mode_set_ptr 0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/** @} legacy_state group */
+
+/**
+ * @defgroup frames Frames
+ * @ingroup legacy
+ * Frames group
+ * @{
+ */
+/**
+ * @brief opaque structure for frame identification
+ */
+typedef struct __itt_frame_t *__itt_frame;
+
+/**
+ * @brief Create a global frame with given domain
+ */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+__itt_frame ITTAPI __itt_frame_createA(const char    *domain);
+__itt_frame ITTAPI __itt_frame_createW(const wchar_t *domain);
+#if defined(UNICODE) || defined(_UNICODE)
+#  define __itt_frame_create     __itt_frame_createW
+#  define __itt_frame_create_ptr __itt_frame_createW_ptr
+#else /* UNICODE */
+#  define __itt_frame_create     __itt_frame_createA
+#  define __itt_frame_create_ptr __itt_frame_createA_ptr
+#endif /* UNICODE */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+__itt_frame ITTAPI __itt_frame_create(const char *domain);
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_frame, frame_createA, (const char    *domain))
+ITT_STUB(ITTAPI, __itt_frame, frame_createW, (const wchar_t *domain))
+#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_frame, frame_create,  (const char *domain))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_frame_createA     ITTNOTIFY_DATA(frame_createA)
+#define __itt_frame_createA_ptr ITTNOTIFY_NAME(frame_createA)
+#define __itt_frame_createW     ITTNOTIFY_DATA(frame_createW)
+#define __itt_frame_createW_ptr ITTNOTIFY_NAME(frame_createW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_frame_create     ITTNOTIFY_DATA(frame_create)
+#define __itt_frame_create_ptr ITTNOTIFY_NAME(frame_create)
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_frame_createA(domain)
+#define __itt_frame_createA_ptr 0
+#define __itt_frame_createW(domain)
+#define __itt_frame_createW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_frame_create(domain)
+#define __itt_frame_create_ptr  0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_frame_createA_ptr 0
+#define __itt_frame_createW_ptr 0
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_frame_create_ptr  0
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+
+/** @brief Record a frame begin occurrence. */
+void ITTAPI __itt_frame_begin(__itt_frame frame);
+/** @brief Record a frame end occurrence. */
+void ITTAPI __itt_frame_end  (__itt_frame frame);
+
+/** @cond exclude_from_documentation */
+#ifndef INTEL_NO_MACRO_BODY
+#ifndef INTEL_NO_ITTNOTIFY_API
+ITT_STUBV(ITTAPI, void, frame_begin, (__itt_frame frame))
+ITT_STUBV(ITTAPI, void, frame_end,   (__itt_frame frame))
+#define __itt_frame_begin     ITTNOTIFY_VOID(frame_begin)
+#define __itt_frame_begin_ptr ITTNOTIFY_NAME(frame_begin)
+#define __itt_frame_end       ITTNOTIFY_VOID(frame_end)
+#define __itt_frame_end_ptr   ITTNOTIFY_NAME(frame_end)
+#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_frame_begin(frame)
+#define __itt_frame_begin_ptr 0
+#define __itt_frame_end(frame)
+#define __itt_frame_end_ptr   0
+#endif /* INTEL_NO_ITTNOTIFY_API */
+#else  /* INTEL_NO_MACRO_BODY */
+#define __itt_frame_begin_ptr 0
+#define __itt_frame_end_ptr   0
+#endif /* INTEL_NO_MACRO_BODY */
+/** @endcond */
+/** @} frames group */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* _LEGACY_ITTNOTIFY_H_ */

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/common/kernel_cache.hpp

@@ -0,0 +1,139 @@
+/*******************************************************************************
+* Copyright 2023 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.
+*******************************************************************************/
+
+#ifndef COMMON_KERNEL_CACHE_HPP
+#define COMMON_KERNEL_CACHE_HPP
+
+#include <cstddef>
+#include <memory>
+#include <thread>
+
+#include "c_types_map.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace kernel_cache {
+
+struct key_impl_t {
+    key_impl_t() = default;
+    virtual ~key_impl_t() = default;
+
+    key_impl_t(const key_impl_t &) = delete;
+    key_impl_t &operator=(const key_impl_t &) = delete;
+
+    virtual bool compare(const key_impl_t *key_impl) const = 0;
+    virtual size_t hash() const = 0;
+};
+
+// Key
+struct key_t {
+    key_t(const std::shared_ptr<key_impl_t> &impl,
+            bool has_runtime_dependencies = false)
+        : impl_(impl)
+        , thread_id_(std::this_thread::get_id())
+        , has_runtime_dependencies_(has_runtime_dependencies) {}
+    key_t(std::shared_ptr<key_impl_t> &&impl,
+            bool has_runtime_dependencies = false)
+        : impl_(std::move(impl))
+        , thread_id_(std::this_thread::get_id())
+        , has_runtime_dependencies_(has_runtime_dependencies) {}
+    virtual ~key_t() = default;
+
+    bool operator==(const key_t &other) const {
+        return impl_->compare(other.impl_.get());
+    };
+    size_t hash() const { return impl_->hash(); };
+
+    const std::thread::id &thread_id() const { return thread_id_; }
+    bool has_runtime_dependencies() const { return has_runtime_dependencies_; }
+
+protected:
+    std::shared_ptr<key_impl_t> impl_;
+
+private:
+    // Thread ID is not used as part of the key, it's only used to get
+    // information about what thread inserted the key and the corresponding
+    // primitive to handle some multithreaded scenarios.
+    std::thread::id thread_id_;
+
+    // Used to correctly handle destruction on process termination. If there are
+    // runtime dependencies, attempts to destroy the cached object may fail.
+    bool has_runtime_dependencies_;
+};
+
+struct value_impl_t {
+    value_impl_t() = default;
+    virtual ~value_impl_t() = default;
+
+    value_impl_t(const value_impl_t &) = delete;
+    value_impl_t &operator=(const value_impl_t &) = delete;
+};
+
+struct value_t {
+    value_t() = default;
+    value_t(std::nullptr_t) : value_t() {};
+    value_t(const std::shared_ptr<value_impl_t> &impl) : impl_(impl) {}
+    value_t(std::shared_ptr<value_impl_t> &&impl) : impl_(std::move(impl)) {}
+    virtual ~value_t() = default;
+    const std::shared_ptr<value_impl_t> &impl() const { return impl_; }
+    std::shared_ptr<value_impl_t> &impl() { return impl_; }
+    std::shared_ptr<value_impl_t> release() {
+        std::shared_ptr<value_impl_t> ret = nullptr;
+        std::swap(ret, impl_);
+        return ret;
+    }
+    bool is_empty() const { return impl_ == nullptr; }
+
+private:
+    std::shared_ptr<value_impl_t> impl_;
+};
+
+struct iface_t {
+    struct cache_t;
+    struct result_t {
+        result_t() : status(status::success) {};
+        result_t(value_t p, status_t s) : value(std::move(p)), status(s) {}
+        bool is_empty() const { return value.is_empty(); }
+        value_t &get_value() { return value; }
+        value_t value;
+        status_t status;
+    };
+
+    using create_func_t = result_t (&)(void *);
+    using create_func_ptr_t = result_t (*)(void *);
+
+    iface_t(cache_t &cache) : cache_(cache) {};
+
+    ~iface_t() = default;
+
+    status_t set_capacity(int capacity);
+    int get_capacity() const;
+    int get_size() const;
+
+    result_t get_or_create(
+            const key_t &key, create_func_t create, void *create_context);
+
+private:
+    cache_t &cache_;
+};
+
+iface_t get();
+
+} // namespace kernel_cache
+} // namespace impl
+} // namespace dnnl
+
+#endif