Add files using upload-large-folder tool

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/cpu/aarch64/acl_gemm_convolution.hpp

@@ -0,0 +1,156 @@
+/*******************************************************************************
+* Copyright 2020-2023 Arm Ltd. and affiliates
+*
+* 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 CPU_AARCH64_ACL_GEMM_CONVOLUTION_HPP
+#define CPU_AARCH64_ACL_GEMM_CONVOLUTION_HPP
+
+#include "cpu/cpu_convolution_pd.hpp"
+
+#include "cpu/aarch64/acl_convolution_utils.hpp"
+#include "cpu/aarch64/acl_post_ops.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+namespace aarch64 {
+
+struct acl_resource_t : public resource_t {
+    acl_resource_t()
+        : acl_obj_(utils::make_unique<
+                acl_obj_t<arm_compute::NEGEMMConvolutionLayer>>()) {}
+
+    status_t configure(const acl_conv_conf_t &acp) {
+        if (!acl_obj_) return status::out_of_memory;
+
+        // Init Compute Library tensors based on info from descriptor
+        acl_obj_->src_tensor.allocator()->init(acp.src_tensor_info);
+        acl_obj_->wei_tensor.allocator()->init(acp.wei_tensor_info);
+        acl_obj_->dst_tensor.allocator()->init(acp.dst_tensor_info);
+        acl_obj_->bia_tensor.allocator()->init(acp.bia_tensor_info);
+
+        acl_obj_->conv.configure(&acl_obj_->src_tensor, &acl_obj_->wei_tensor,
+                acp.with_bias ? &acl_obj_->bia_tensor : nullptr,
+                &acl_obj_->dst_tensor, acp.padstride_info, acp.weights_info,
+                acp.dilation_info, acp.act_info, acp.fast_math);
+        return status::success;
+    }
+
+    acl_obj_t<arm_compute::NEGEMMConvolutionLayer> &get_acl_obj() const {
+        return *acl_obj_;
+    }
+
+    DNNL_DISALLOW_COPY_AND_ASSIGN(acl_resource_t);
+
+private:
+    std::unique_ptr<acl_obj_t<arm_compute::NEGEMMConvolutionLayer>> acl_obj_;
+
+}; // acl_resource_t
+
+template <data_type_t src_type, data_type_t wei_type = src_type,
+        data_type_t dst_type = src_type, data_type_t bia_type = dst_type>
+struct acl_gemm_convolution_fwd_t : public primitive_t {
+    struct pd_t : public cpu_convolution_fwd_pd_t {
+        pd_t(const convolution_desc_t *adesc, const primitive_attr_t *attr,
+                const typename pd_t::base_class *hint_fwd_pd)
+            : cpu_convolution_fwd_pd_t(adesc, attr, hint_fwd_pd), acp_() {}
+
+        DECLARE_COMMON_PD_T(
+                "gemm:acl", acl_gemm_convolution_fwd_t, USE_GLOBAL_SCRATCHPAD);
+
+        status_t init(engine_t *engine) {
+            using namespace data_type;
+            using smask_t = primitive_attr_t::skip_mask_t;
+
+            bool ok = is_fwd()
+                    && set_default_alg_kind(alg_kind::convolution_direct)
+                    && expect_data_types(
+                            src_type, wei_type, bia_type, dst_type, undef)
+                    && !has_zero_dim_memory()
+                    && attr()->has_default_values(smask_t::post_ops, dst_type)
+                    && output_scales_mask_ok() && zero_points_ok();
+            if (!ok) return status::unimplemented;
+
+            CHECK(acl_convolution_utils::init_conf_gemm(acp_, src_md_,
+                    weights_md_, dst_md_, bias_md_, *desc(), *attr()));
+
+            CHECK(post_ops.init(
+                    engine, attr_.post_ops_, dst_md_, acp_.act_info));
+            acp_.use_dst_acc = post_ops.has_sum();
+
+            return status::success;
+        }
+
+        acl_conv_conf_t acp_;
+
+        acl_post_ops_t post_ops;
+
+    protected:
+        bool output_scales_mask_ok() const {
+            using namespace data_type;
+            const auto &mask = attr()->output_scales_.mask_;
+            return IMPLICATION(!utils::one_of(src_type, s8, u8),
+                           attr()->output_scales_.has_default_values())
+                    // TODO: add support for per_channel quantization
+                    && mask == 0;
+        }
+
+        bool zero_points_ok() const {
+            using namespace data_type;
+            // TODO: add support for asymmetric quantization
+            return attr()->zero_points_.has_default_values();
+        }
+    };
+
+    acl_gemm_convolution_fwd_t(const pd_t *apd) : primitive_t(apd) {}
+
+    status_t create_resource(
+            engine_t *engine, resource_mapper_t &mapper) const override {
+        if (mapper.has_resource(this)) return status::success;
+
+        auto r = utils::make_unique<acl_resource_t>();
+        if (!r) return status::out_of_memory;
+
+        // Configure the resource based on information from primitive descriptor
+        CHECK(r->configure(pd()->acp_));
+        mapper.add(this, std::move(r));
+
+        CHECK(pd()->post_ops.create_resource(engine, mapper));
+
+        return status::success;
+    }
+
+    typedef typename prec_traits<src_type>::type src_data_t;
+    typedef typename prec_traits<wei_type>::type wei_data_t;
+    typedef typename prec_traits<dst_type>::type dst_data_t;
+    typedef typename prec_traits<bia_type>::type bia_data_t;
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_forward(ctx);
+    }
+
+private:
+    // To guard the const execute_forward(), the mutex must be 'mutable'
+    mutable std::mutex mtx;
+    status_t execute_forward(const exec_ctx_t &ctx) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+}; // acl_gemm_convolution_fwd_t
+
+} // namespace aarch64
+} // namespace cpu
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/cpu/binary_injector_utils.hpp

@@ -0,0 +1,75 @@
+/*******************************************************************************
+* 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 CPU_BINARY_INJECTOR_UTILS_HPP
+#define CPU_BINARY_INJECTOR_UTILS_HPP
+
+#include <tuple>
+#include <vector>
+
+#include "common/broadcast_strategy.hpp"
+#include "common/c_types_map.hpp"
+#include "common/primitive_attr.hpp"
+#include "common/primitive_exec_types.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+namespace binary_injector_utils {
+/*
+ * Extracts pointers to tensors passed by user as binary postops rhs (right-hand-side)
+ * arguments (arg1 from binary postop) from execution context. Those pointers are placed
+ * in vector in order of binary post-op appearance inside post_ops_t structure. Returned vector
+ * usually is passed to kernel during execution phase in runtime params.
+ * @param first_arg_idx_offset - offset for indexation of binary postop arguments
+ * (used for fusions with dw convolutions)
+ */
+std::vector<const void *> prepare_binary_args(const post_ops_t &post_ops,
+        const dnnl::impl::exec_ctx_t &ctx,
+        const unsigned first_arg_idx_offset = 0);
+
+bool bcast_strategy_present(
+        const std::vector<broadcasting_strategy_t> &post_ops_bcasts,
+        const broadcasting_strategy_t bcast_strategy);
+
+std::vector<broadcasting_strategy_t> extract_bcast_strategies(
+        const std::vector<dnnl_post_ops::entry_t> &post_ops,
+        const memory_desc_wrapper &dst_md);
+
+memory_desc_t get_src1_desc(
+        const post_ops_t::entry_t &post_op, const memory_desc_wrapper &dst_d);
+
+/*
+ * Returns a tuple of bools, which size is equal to number of bcast
+ * strategies passed in. Values at consecutive positions indicate existence of
+ * binary postop with a particular bcast strategy in post_ops vector.
+ */
+template <typename... Str>
+auto bcast_strategies_present_tup(
+        const std::vector<dnnl_post_ops::entry_t> &post_ops,
+        const memory_desc_wrapper &dst_md, Str... bcast_strategies)
+        -> decltype(std::make_tuple((bcast_strategies, false)...)) {
+    const auto post_ops_bcasts = extract_bcast_strategies(post_ops, dst_md);
+    return std::make_tuple(
+            bcast_strategy_present(post_ops_bcasts, bcast_strategies)...);
+}
+
+} // namespace binary_injector_utils
+} // namespace cpu
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/cpu/cpu_batch_normalization_pd.hpp

@@ -0,0 +1,41 @@
+/*******************************************************************************
+* Copyright 2016-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 CPU_CPU_BATCH_NORMALIZATION_PD_HPP
+#define CPU_CPU_BATCH_NORMALIZATION_PD_HPP
+
+#include "common/batch_normalization_pd.hpp"
+#include "cpu/cpu_engine.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct cpu_batch_normalization_fwd_pd_t : public batch_normalization_fwd_pd_t {
+    using batch_normalization_fwd_pd_t::batch_normalization_fwd_pd_t;
+};
+
+struct cpu_batch_normalization_bwd_pd_t : public batch_normalization_bwd_pd_t {
+    using batch_normalization_bwd_pd_t::batch_normalization_bwd_pd_t;
+};
+
+} // namespace cpu
+} // 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/cpu/cpu_batch_normalization_utils.hpp

@@ -0,0 +1,44 @@
+/*******************************************************************************
+* Copyright 2018-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 CPU_CPU_BATCH_NORMALIZATION_UTILS_HPP
+#define CPU_CPU_BATCH_NORMALIZATION_UTILS_HPP
+
+#include "common/batch_normalization_pd.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+namespace bnorm_utils {
+
+void cache_balance(size_t working_set_size, dim_t C_blks, dim_t N, int nthr,
+        dim_t &C_blks_per_iter, int64_t &iters);
+
+bool thread_balance(bool do_blocking, bool spatial_thr_allowed, bool is_nhwc,
+        int ithr, int nthr, dim_t N, dim_t C_blks, dim_t SP, int &C_ithr,
+        int &C_nthr, dim_t &C_blk_s, dim_t &C_blk_e, int &N_ithr, int &N_nthr,
+        dim_t &N_s, dim_t &N_e, int &S_ithr, int &S_nthr, dim_t &S_s,
+        dim_t &S_e);
+
+bool is_spatial_thr(const batch_normalization_pd_t *bdesc, bool is_nhwc,
+        int simd_w, int data_size);
+
+} // namespace bnorm_utils
+} // namespace cpu
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/cpu/cpu_binary_pd.hpp

@@ -0,0 +1,39 @@
+/*******************************************************************************
+* 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 CPU_CPU_BINARY_PD_HPP
+#define CPU_CPU_BINARY_PD_HPP
+
+#include "common/binary_pd.hpp"
+#include "common/c_types_map.hpp"
+#include "common/type_helpers.hpp"
+#include "common/utils.hpp"
+#include "cpu/cpu_engine.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct cpu_binary_pd_t : public binary_pd_t {
+    using binary_pd_t::binary_pd_t;
+};
+} // namespace cpu
+} // namespace impl
+} // namespace dnnl
+
+#endif
+
+// vim: et ts=4 sw=4 cindent cino^=l0,\:0,N-s

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/cpu/cpu_concat_pd.hpp

@@ -0,0 +1,42 @@
+/*******************************************************************************
+* Copyright 2016-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 CPU_CPU_CONCAT_PD_HPP
+#define CPU_CPU_CONCAT_PD_HPP
+
+#include <assert.h>
+
+#include "common/c_types_map.hpp"
+#include "common/concat_pd.hpp"
+#include "common/type_helpers.hpp"
+#include "common/utils.hpp"
+#include "cpu/cpu_engine.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct cpu_concat_pd_t : public concat_pd_t {
+    using concat_pd_t::concat_pd_t;
+};
+
+} // namespace cpu
+} // 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/cpu/cpu_convolution_pd.hpp

@@ -0,0 +1,83 @@
+/*******************************************************************************
+* Copyright 2016-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 CPU_CPU_CONVOLUTION_PD_HPP
+#define CPU_CPU_CONVOLUTION_PD_HPP
+
+#include <assert.h>
+
+#include "common/c_types_map.hpp"
+#include "common/convolution_pd.hpp"
+#include "common/type_helpers.hpp"
+#include "common/utils.hpp"
+#include "cpu/cpu_eltwise_pd.hpp"
+#include "cpu/cpu_engine.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct cpu_convolution_fwd_pd_t : public convolution_fwd_pd_t {
+    using convolution_fwd_pd_t::convolution_fwd_pd_t;
+
+    bool has_padded_dst() const {
+        memory_desc_wrapper dst_d(&dst_md_);
+        return OC() != dst_d.padded_dims()[1];
+    }
+
+    bool wants_padded_bias() const {
+        if (!with_bias()) return false;
+        return has_padded_dst();
+    }
+
+    bool wants_zero_pad_dst() const {
+        if (!has_padded_dst()) return false;
+        bool is_zero_preserved = true;
+        const auto &po = attr()->post_ops_;
+        for (int i = 0; i < po.len(); i++) {
+            const auto &entry = po.entry_[i];
+            if (entry.is_eltwise()) {
+                const auto &ee = entry.eltwise;
+                is_zero_preserved = is_zero_preserved
+                        && cpu_eltwise_fwd_pd_t::eltwise_preserves_zero(
+                                ee.alg, ee.alpha, ee.beta);
+            }
+        }
+        return !is_zero_preserved;
+    }
+};
+
+struct cpu_convolution_bwd_data_pd_t : public convolution_bwd_data_pd_t {
+    using convolution_bwd_data_pd_t::convolution_bwd_data_pd_t;
+};
+
+struct cpu_convolution_bwd_weights_pd_t : public convolution_bwd_weights_pd_t {
+    using convolution_bwd_weights_pd_t::convolution_bwd_weights_pd_t;
+
+    bool wants_padded_bias() const {
+        if (!with_bias()) return false;
+        memory_desc_wrapper diff_dst_d(&diff_dst_md_);
+        return OC() != diff_dst_d.padded_dims()[1];
+    }
+};
+
+} // namespace cpu
+} // 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/cpu/cpu_deconvolution_pd.hpp

@@ -0,0 +1,48 @@
+/*******************************************************************************
+* Copyright 2018-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 CPU_CPU_DECONVOLUTION_PD_HPP
+#define CPU_CPU_DECONVOLUTION_PD_HPP
+
+#include <assert.h>
+
+#include "common/deconvolution_pd.hpp"
+#include "cpu/cpu_engine.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct cpu_deconvolution_fwd_pd_t : public deconvolution_fwd_pd_t {
+    using deconvolution_fwd_pd_t::deconvolution_fwd_pd_t;
+};
+
+struct cpu_deconvolution_bwd_data_pd_t : public deconvolution_bwd_data_pd_t {
+    using deconvolution_bwd_data_pd_t::deconvolution_bwd_data_pd_t;
+};
+
+struct cpu_deconvolution_bwd_weights_pd_t
+    : public deconvolution_bwd_weights_pd_t {
+    using deconvolution_bwd_weights_pd_t::deconvolution_bwd_weights_pd_t;
+};
+
+} // namespace cpu
+} // 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/cpu/cpu_eltwise_pd.hpp

@@ -0,0 +1,46 @@
+/*******************************************************************************
+* Copyright 2016-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 CPU_CPU_ELTWISE_PD_HPP
+#define CPU_CPU_ELTWISE_PD_HPP
+
+#include <assert.h>
+
+#include "common/c_types_map.hpp"
+#include "common/eltwise_pd.hpp"
+#include "common/type_helpers.hpp"
+#include "common/utils.hpp"
+#include "cpu/cpu_engine.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct cpu_eltwise_fwd_pd_t : public eltwise_fwd_pd_t {
+    using eltwise_fwd_pd_t::eltwise_fwd_pd_t;
+};
+
+struct cpu_eltwise_bwd_pd_t : public eltwise_bwd_pd_t {
+    using eltwise_bwd_pd_t::eltwise_bwd_pd_t;
+};
+
+} // namespace cpu
+} // 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/cpu/cpu_engine.hpp

@@ -0,0 +1,183 @@
+/*******************************************************************************
+* Copyright 2016-2023 Intel Corporation
+* Copyright 2020-2023 Arm Ltd. and affiliates
+*
+* 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 CPU_CPU_ENGINE_HPP
+#define CPU_CPU_ENGINE_HPP
+
+#include <assert.h>
+
+#include "oneapi/dnnl/dnnl.h"
+
+#include "common/c_types_map.hpp"
+#include "common/engine.hpp"
+#include "common/engine_id.hpp"
+#include "common/impl_list_item.hpp"
+
+#include "cpu/platform.hpp"
+
+#if DNNL_AARCH64 && DNNL_AARCH64_USE_ACL
+#include "cpu/aarch64/acl_thread.hpp"
+#endif
+
+#define CPU_INSTANCE(...) \
+    impl_list_item_t( \
+            impl_list_item_t::type_deduction_helper_t<__VA_ARGS__::pd_t>()),
+#define CPU_INSTANCE_X64(...) DNNL_X64_ONLY(CPU_INSTANCE(__VA_ARGS__))
+#define CPU_INSTANCE_SSE41(...) REG_SSE41_ISA(CPU_INSTANCE(__VA_ARGS__))
+#define CPU_INSTANCE_AVX2(...) REG_AVX2_ISA(CPU_INSTANCE(__VA_ARGS__))
+#define CPU_INSTANCE_AVX512(...) REG_AVX512_ISA(CPU_INSTANCE(__VA_ARGS__))
+#define CPU_INSTANCE_AMX(...) REG_AMX_ISA(CPU_INSTANCE(__VA_ARGS__))
+#define CPU_INSTANCE_AARCH64(...) DNNL_AARCH64_ONLY(CPU_INSTANCE(__VA_ARGS__))
+#define CPU_INSTANCE_AARCH64_ACL(...) \
+    DNNL_AARCH64_ACL_ONLY(CPU_INSTANCE(__VA_ARGS__))
+#define CPU_INSTANCE_RV64GCV(...) DNNL_RV64GCV_ONLY(CPU_INSTANCE(__VA_ARGS__))
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+#define DECLARE_IMPL_LIST(kind) \
+    const impl_list_item_t *get_##kind##_impl_list(const kind##_desc_t *desc);
+
+DECLARE_IMPL_LIST(batch_normalization);
+DECLARE_IMPL_LIST(binary);
+DECLARE_IMPL_LIST(convolution);
+DECLARE_IMPL_LIST(deconvolution);
+DECLARE_IMPL_LIST(eltwise);
+DECLARE_IMPL_LIST(group_normalization);
+DECLARE_IMPL_LIST(inner_product);
+DECLARE_IMPL_LIST(layer_normalization);
+DECLARE_IMPL_LIST(lrn);
+DECLARE_IMPL_LIST(matmul);
+DECLARE_IMPL_LIST(pooling);
+DECLARE_IMPL_LIST(prelu);
+DECLARE_IMPL_LIST(reduction);
+DECLARE_IMPL_LIST(resampling);
+DECLARE_IMPL_LIST(rnn);
+DECLARE_IMPL_LIST(shuffle);
+DECLARE_IMPL_LIST(softmax);
+
+#undef DECLARE_IMPL_LIST
+
+class cpu_engine_impl_list_t {
+public:
+    static const impl_list_item_t *get_concat_implementation_list();
+    static const impl_list_item_t *get_reorder_implementation_list(
+            const memory_desc_t *src_md, const memory_desc_t *dst_md);
+    static const impl_list_item_t *get_sum_implementation_list();
+
+    static const impl_list_item_t *get_implementation_list(
+            const op_desc_t *desc) {
+        static const impl_list_item_t empty_list[] = {nullptr};
+
+// clang-format off
+#define CASE(kind) \
+    case primitive_kind::kind: \
+        return get_##kind##_impl_list((const kind##_desc_t *)desc);
+        switch (desc->kind) {
+            CASE(batch_normalization);
+            CASE(binary);
+            CASE(convolution);
+            CASE(deconvolution);
+            CASE(eltwise);
+            CASE(group_normalization);
+            CASE(inner_product);
+            CASE(layer_normalization);
+            CASE(lrn);
+            CASE(matmul);
+            CASE(pooling);
+            CASE(prelu);
+            CASE(reduction);
+            CASE(resampling);
+            CASE(rnn);
+            CASE(shuffle);
+            CASE(softmax);
+            default: assert(!"unknown primitive kind"); return empty_list;
+        }
+#undef CASE
+    }
+    // clang-format on
+};
+
+class cpu_engine_t : public engine_t {
+public:
+    cpu_engine_t() : engine_t(engine_kind::cpu, get_cpu_native_runtime(), 0) {}
+
+    /* implementation part */
+
+    status_t create_memory_storage(memory_storage_t **storage, unsigned flags,
+            size_t size, void *handle) override;
+
+    status_t create_stream(stream_t **stream, unsigned flags) override;
+
+#if DNNL_CPU_RUNTIME == DNNL_RUNTIME_THREADPOOL
+    status_t create_stream(stream_t **stream,
+            dnnl::threadpool_interop::threadpool_iface *threadpool) override;
+#endif
+
+    const impl_list_item_t *get_concat_implementation_list() const override {
+        return cpu_engine_impl_list_t::get_concat_implementation_list();
+    }
+
+    const impl_list_item_t *get_reorder_implementation_list(
+            const memory_desc_t *src_md,
+            const memory_desc_t *dst_md) const override {
+        return cpu_engine_impl_list_t::get_reorder_implementation_list(
+                src_md, dst_md);
+    }
+    const impl_list_item_t *get_sum_implementation_list() const override {
+        return cpu_engine_impl_list_t::get_sum_implementation_list();
+    }
+    const impl_list_item_t *get_implementation_list(
+            const op_desc_t *desc) const override {
+        return cpu_engine_impl_list_t::get_implementation_list(desc);
+    }
+
+    device_id_t device_id() const override { return std::make_tuple(0, 0, 0); }
+
+    engine_id_t engine_id() const override {
+        // Non-sycl CPU engine doesn't have device and context.
+        return {};
+    }
+
+protected:
+    ~cpu_engine_t() override = default;
+};
+
+class cpu_engine_factory_t : public engine_factory_t {
+public:
+    size_t count() const override { return 1; }
+    status_t engine_create(engine_t **engine, size_t index) const override {
+        assert(index == 0);
+        *engine = new cpu_engine_t();
+
+#if DNNL_AARCH64 && DNNL_AARCH64_USE_ACL
+        dnnl::impl::cpu::aarch64::acl_thread_utils::set_acl_threading();
+#endif
+        return status::success;
+    };
+};
+
+engine_t *get_service_engine();
+
+} // namespace cpu
+} // 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/cpu/cpu_group_normalization_pd.hpp

@@ -0,0 +1,39 @@
+/*******************************************************************************
+* 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 CPU_CPU_GROUP_NORMALIZATION_PD_HPP
+#define CPU_CPU_GROUP_NORMALIZATION_PD_HPP
+
+#include "common/group_normalization_pd.hpp"
+#include "cpu/cpu_engine.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct cpu_group_normalization_fwd_pd_t : public group_normalization_fwd_pd_t {
+    using group_normalization_fwd_pd_t::group_normalization_fwd_pd_t;
+};
+
+struct cpu_group_normalization_bwd_pd_t : public group_normalization_bwd_pd_t {
+    using group_normalization_bwd_pd_t::group_normalization_bwd_pd_t;
+};
+
+} // namespace cpu
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/cpu/cpu_inner_product_pd.hpp

@@ -0,0 +1,323 @@
+/*******************************************************************************
+* Copyright 2016-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 CPU_CPU_INNER_PRODUCT_PD_HPP
+#define CPU_CPU_INNER_PRODUCT_PD_HPP
+
+#include <assert.h>
+
+#include "common/c_types_map.hpp"
+#include "common/inner_product_pd.hpp"
+#include "common/utils.hpp"
+#include "cpu/cpu_engine.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+namespace {
+inline bool dense_gemm_consitency_check(const memory_desc_wrapper &src_d,
+        const memory_desc_wrapper &wei_d, const memory_desc_wrapper &dst_d) {
+    using namespace utils;
+
+    auto strides_compatible = [&]() {
+        bool ok = true;
+        auto w_str = wei_d.blocking_desc().strides;
+        auto d_str = src_d.blocking_desc().strides;
+        for (int i = 1; i < src_d.ndims() - 1; i++) {
+            ok = ok && w_str[i] / d_str[i] == w_str[i + 1] / d_str[i + 1];
+        }
+        return ok && one_of(w_str[1] / d_str[1], 1, wei_d.padded_dims()[0]);
+    };
+
+    auto inner_blk_compatible = [&]() {
+        auto d_inner_blks = src_d.blocking_desc().inner_blks;
+        auto w_inner_blks = wei_d.blocking_desc().inner_blks;
+        auto d_inner_idxs = src_d.blocking_desc().inner_idxs;
+        auto w_inner_idxs = wei_d.blocking_desc().inner_idxs;
+
+        int d_inner_nblks = src_d.blocking_desc().inner_nblks;
+        int w_inner_nblks = wei_d.blocking_desc().inner_nblks;
+
+        bool ok = true;
+
+        if ((wei_d.blocking_desc().strides[0] == 1) && (w_inner_nblks > 0)) {
+            ok = ok && wei_d.dims()[0] / w_inner_blks[w_inner_nblks - 1] == 1
+                    && w_inner_idxs[w_inner_nblks - 1] == 0;
+            w_inner_nblks--;
+        }
+        ok = ok && d_inner_nblks == w_inner_nblks;
+
+        for (int d = 0; d < w_inner_nblks; d++)
+            ok = ok && (d_inner_blks[d] == w_inner_blks[d])
+                    && (d_inner_idxs[d] == w_inner_idxs[d]);
+
+        return ok;
+    };
+
+    return true && src_d.is_blocking_desc() && wei_d.is_blocking_desc()
+            && src_d.ndims() == wei_d.ndims() && inner_blk_compatible()
+            && strides_compatible() && dst_d.matches_tag(format_tag::nc)
+            && src_d.only_padded_dim(1) && wei_d.only_padded_dim(1)
+            && src_d.padded_dims()[1] == wei_d.padded_dims()[1]
+            && src_d.is_dense(true) && dst_d.is_dense() && wei_d.is_dense(true);
+}
+
+void transpose_md(memory_desc_t &md) {
+    // Note: we cannot directly use good leading dimension for a
+    // in padded_dims.  This is because inner_blks does not
+    // account for padding, and should divide the corresponding
+    // padded_dim.
+    auto put_a_last = [](memory_desc_t &md) {
+        auto &md_blk = md.format_desc.blocking;
+        md.padded_dims[0] = md.dims[0];
+        md_blk.strides[0] = 1;
+        for (int d = 1; d < md.ndims; d++)
+            md_blk.strides[d] *= md.padded_dims[0];
+        if (md_blk.inner_nblks > 0) {
+            md_blk.inner_idxs[md_blk.inner_nblks] = 0;
+            md_blk.inner_blks[md_blk.inner_nblks] = md.padded_dims[0];
+            md_blk.inner_nblks++;
+        }
+    };
+
+    auto put_a_first = [](memory_desc_t &md) {
+        blocking_desc_t blk = md.format_desc.blocking;
+        // make the stride for `a` bigger than any other stride and
+        // use the fact that memory_desc_init_by_blocking_desc
+        // preserves the strides order but actually changes them to
+        // densify the descriptor
+        blk.strides[0] = memory_desc_wrapper(md).size();
+        memory_desc_init_by_blocking_desc(md, blk);
+    };
+
+    auto is_a_last = [](memory_desc_t &md) {
+        auto &md_blk = md.format_desc.blocking;
+        // The inner_blks condition makes sure that a is a non blocked dimension
+        return (md_blk.strides[0] == 1) && (md_blk.inner_nblks == 0);
+    };
+
+    auto is_a_first = [&](memory_desc_t &md) {
+        auto &md_blk = md.format_desc.blocking;
+        for (int d = 1; d < md.ndims; d++)
+            if (md_blk.strides[0] < md_blk.strides[d]) return false;
+        return true;
+    };
+
+    if (is_a_last(md))
+        put_a_first(md);
+    else if (is_a_first(md))
+        put_a_last(md);
+
+    // here, by default we do not transpose md if it is not
+}
+
+format_tag_t get_tag(memory_desc_t &md) {
+    using namespace format_tag;
+    auto tag = memory_desc_matches_one_of_tag(md, ab, abc, abcd,
+            abcde, // NCHW derivatives
+            ba, bca, bcda, bcdea, cba, cdba,
+            cdeba, // IO and spatial derivatives
+            acb, acdb, acdeb, // NHWC derivatives
+            aBcd16b, aBcde16b, aBcd8b, aBcde8b, aBcd4b,
+            aBcde4b); // blocked layouts
+    return tag;
+}
+
+inline bool is_ineff_lead_dim(const dim_t dim) {
+    return dim % 1024 == 0; // check cache aliasing
+}
+
+/* Pick between M and K for the most efficient leading
+ * dimension to compute GeMM. */
+bool transpose_leading_dim(const dim_t M, const dim_t K) {
+    return IMPLICATION(is_ineff_lead_dim(M), is_ineff_lead_dim(K) && M <= K);
+}
+} // namespace
+
+#define INIT_MEM_BY_TAG(tag_init_f, md) \
+    do { \
+        auto tag = tag_init_f; \
+        if (tag == format_tag::undef) return status::unimplemented; \
+        CHECK(memory_desc_init_by_tag(md, tag)); \
+    } while (0)
+
+struct cpu_inner_product_fwd_pd_t : public inner_product_fwd_pd_t {
+    using inner_product_fwd_pd_t::inner_product_fwd_pd_t;
+
+protected:
+    status_t set_default_params(bool allow_all_tags = false) {
+        using namespace format_tag;
+
+        auto set_default_src = [&]() {
+            if (weights_md_.format_kind == format_kind::any) {
+                INIT_MEM_BY_TAG(utils::pick(ndims() - 2, ab, abc, abcd, abcde),
+                        src_md_);
+            } else {
+                format_tag_t weights_tag = get_tag(weights_md_);
+                if (allow_all_tags && weights_tag == undef) {
+                    INIT_MEM_BY_TAG(
+                            utils::pick(ndims() - 2, ab, abc, abcd, abcde),
+                            src_md_);
+                } else {
+                    INIT_MEM_BY_TAG(weights_tag, src_md_);
+                }
+                // transpose weights to improve efficiency of non-copy kernels
+                if (src_md_.format_desc.blocking.strides[0] == 1)
+                    transpose_md(src_md_);
+            }
+            return status::success;
+        };
+
+        auto set_default_weights = [&]() {
+            format_tag_t src_tag = get_tag(src_md_);
+            if (allow_all_tags && src_tag == undef) {
+                INIT_MEM_BY_TAG(utils::pick(ndims() - 2, ab, abc, abcd, abcde),
+                        weights_md_);
+            } else {
+                INIT_MEM_BY_TAG(src_tag, weights_md_);
+            }
+            /* with batch = 1, no transpose to use the faster gemv kernels */
+            /* otherwise, we transpose the weights to improve efficiency of
+             * no-copy kernels */
+            if (MB() > 1 && transpose_leading_dim(OC(), IC_total()))
+                transpose_md(weights_md_);
+            return status::success;
+        };
+
+        if (src_md_.format_kind == format_kind::any) CHECK(set_default_src());
+        if (weights_md_.format_kind == format_kind::any)
+            CHECK(set_default_weights());
+        if (dst_md_.format_kind == format_kind::any)
+            CHECK(memory_desc_init_by_tag(dst_md_, nc));
+        if (bias_md_.format_kind == format_kind::any)
+            CHECK(memory_desc_init_by_tag(bias_md_, x));
+        return status::success;
+    }
+};
+
+struct cpu_inner_product_bwd_data_pd_t : public inner_product_bwd_data_pd_t {
+    using inner_product_bwd_data_pd_t::inner_product_bwd_data_pd_t;
+
+protected:
+    status_t set_default_params(bool allow_all_tags = false) {
+        using namespace format_tag;
+
+        auto set_default_diff_src = [&]() {
+            if (weights_md_.format_kind == format_kind::any) {
+                INIT_MEM_BY_TAG(utils::pick(ndims() - 2, ab, abc, abcd, abcde),
+                        diff_src_md_);
+            } else {
+                format_tag_t weights_tag = get_tag(weights_md_);
+                if (allow_all_tags && weights_tag == undef) {
+                    INIT_MEM_BY_TAG(
+                            utils::pick(ndims() - 2, ab, abc, abcd, abcde),
+                            diff_src_md_);
+                } else {
+                    INIT_MEM_BY_TAG(weights_tag, diff_src_md_);
+                }
+                if (diff_src_md_.format_desc.blocking.strides[0] == 1)
+                    transpose_md(diff_src_md_);
+            }
+            return status::success;
+        };
+
+        auto set_default_weights = [&]() {
+            format_tag_t diff_src_tag = get_tag(diff_src_md_);
+            if (allow_all_tags && diff_src_tag == undef) {
+                INIT_MEM_BY_TAG(utils::pick(ndims() - 2, ab, abc, abcd, abcde),
+                        weights_md_);
+            } else {
+                INIT_MEM_BY_TAG(diff_src_tag, weights_md_);
+            }
+            /* with batch = 1, no transpose to use the faster gemv kernels */
+            /* otherwise, we transpose the weights to improve efficiency of
+             * no-copy kernels */
+            if (MB() == 1) transpose_md(weights_md_);
+
+            return status::success;
+        };
+
+        if (diff_src_md_.format_kind == format_kind::any)
+            CHECK(set_default_diff_src());
+        if (weights_md_.format_kind == format_kind::any)
+            CHECK(set_default_weights());
+        if (diff_dst_md_.format_kind == format_kind::any)
+            CHECK(memory_desc_init_by_tag(diff_dst_md_, nc));
+        return status::success;
+    }
+};
+
+struct cpu_inner_product_bwd_weights_pd_t
+    : public inner_product_bwd_weights_pd_t {
+    using inner_product_bwd_weights_pd_t::inner_product_bwd_weights_pd_t;
+
+protected:
+    status_t set_default_params(bool allow_all_tags = false) {
+        using namespace format_tag;
+
+        auto set_default_src = [&]() {
+            if (diff_weights_md_.format_kind == format_kind::any) {
+                INIT_MEM_BY_TAG(utils::pick(ndims() - 2, ab, abc, abcd, abcde),
+                        src_md_);
+            } else {
+                format_tag_t diff_weights_tag = get_tag(diff_weights_md_);
+                if (allow_all_tags && diff_weights_tag == undef) {
+                    INIT_MEM_BY_TAG(
+                            utils::pick(ndims() - 2, ab, abc, abcd, abcde),
+                            src_md_);
+                } else {
+                    INIT_MEM_BY_TAG(diff_weights_tag, src_md_);
+                }
+                if (src_md_.format_desc.blocking.strides[0] == 1)
+                    transpose_md(src_md_);
+            }
+            return status::success;
+        };
+
+        auto set_default_diff_weights = [&]() {
+            format_tag_t src_tag = get_tag(src_md_);
+            if (allow_all_tags && src_tag == undef) {
+                INIT_MEM_BY_TAG(utils::pick(ndims() - 2, ab, abc, abcd, abcde),
+                        diff_weights_md_);
+            } else {
+                INIT_MEM_BY_TAG(src_tag, diff_weights_md_);
+            }
+            // Here, we want diff_weights layout to match the fwd weights layout
+            if (MB() > 1 && transpose_leading_dim(OC(), MB()))
+                transpose_md(diff_weights_md_);
+            return status::success;
+        };
+
+        if (src_md_.format_kind == format_kind::any) CHECK(set_default_src());
+        if (diff_weights_md_.format_kind == format_kind::any)
+            CHECK(set_default_diff_weights());
+        if (diff_dst_md_.format_kind == format_kind::any)
+            CHECK(memory_desc_init_by_tag(diff_dst_md_, nc));
+        if (diff_bias_md_.format_kind == format_kind::any)
+            CHECK(memory_desc_init_by_tag(diff_bias_md_, x));
+        return status::success;
+    }
+};
+#undef INIT_MEM_BY_TAG
+
+} // namespace cpu
+} // 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/cpu/cpu_layer_normalization_pd.hpp

@@ -0,0 +1,41 @@
+/*******************************************************************************
+* 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 CPU_CPU_LAYER_NORMALIZATION_PD_HPP
+#define CPU_CPU_LAYER_NORMALIZATION_PD_HPP
+
+#include "common/layer_normalization_pd.hpp"
+#include "cpu/cpu_engine.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct cpu_layer_normalization_fwd_pd_t : public layer_normalization_fwd_pd_t {
+    using layer_normalization_fwd_pd_t::layer_normalization_fwd_pd_t;
+};
+
+struct cpu_layer_normalization_bwd_pd_t : public layer_normalization_bwd_pd_t {
+    using layer_normalization_bwd_pd_t::layer_normalization_bwd_pd_t;
+};
+
+} // namespace cpu
+} // namespace impl
+} // namespace dnnl
+
+#endif
+
+// vim: et ts=4 sw=4 cindent cino^=l0,\:0,N-s

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/cpu/cpu_lrn_pd.hpp

@@ -0,0 +1,43 @@
+/*******************************************************************************
+* Copyright 2016-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 CPU_CPU_LRN_PD_HPP
+#define CPU_CPU_LRN_PD_HPP
+
+#include <assert.h>
+
+#include "common/lrn_pd.hpp"
+#include "cpu/cpu_engine.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct cpu_lrn_fwd_pd_t : public lrn_fwd_pd_t {
+    using lrn_fwd_pd_t::lrn_fwd_pd_t;
+};
+
+struct cpu_lrn_bwd_pd_t : public lrn_bwd_pd_t {
+    using lrn_bwd_pd_t::lrn_bwd_pd_t;
+};
+
+} // namespace cpu
+} // 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/cpu/cpu_memory_storage.hpp

@@ -0,0 +1,108 @@
+/*******************************************************************************
+* Copyright 2019-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 CPU_CPU_MEMORY_STORAGE_HPP
+#define CPU_CPU_MEMORY_STORAGE_HPP
+
+#include <memory>
+
+#include "common/c_types_map.hpp"
+#include "common/memory.hpp"
+#include "common/memory_storage.hpp"
+#include "common/stream.hpp"
+#include "common/utils.hpp"
+
+#include "cpu/platform.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+class cpu_memory_storage_t : public memory_storage_t {
+public:
+    cpu_memory_storage_t(engine_t *engine)
+        : memory_storage_t(engine), data_(nullptr, release) {}
+
+    status_t get_data_handle(void **handle) const override {
+        *handle = data_.get();
+        return status::success;
+    }
+
+    status_t set_data_handle(void *handle) override {
+        data_ = decltype(data_)(handle, release);
+        return status::success;
+    }
+
+    status_t map_data(
+            void **mapped_ptr, stream_t *stream, size_t size) const override {
+        UNUSED(size);
+        // This function is called for non-SYCL CPU engines only, where the
+        // runtime_kind is constant for a specific build, and engine_kind is
+        // only cpu. However, at the same time, the stream engine and memory
+        // object engine may have different memory locations. Therefore, at
+        // most, we need to ensure that the indexes of these engines are
+        // identical.
+        if (stream != nullptr && stream->engine()->index() != engine()->index())
+            return status::invalid_arguments;
+        return get_data_handle(mapped_ptr);
+    }
+
+    status_t unmap_data(void *mapped_ptr, stream_t *stream) const override {
+        UNUSED(mapped_ptr);
+        if (stream != nullptr && stream->engine()->index() != engine()->index())
+            return status::invalid_arguments;
+        return status::success;
+    }
+
+    bool is_host_accessible() const override { return true; }
+
+    std::unique_ptr<memory_storage_t> get_sub_storage(
+            size_t offset, size_t size) const override {
+        void *sub_ptr = reinterpret_cast<uint8_t *>(data_.get()) + offset;
+        auto sub_storage = new cpu_memory_storage_t(this->engine());
+        sub_storage->init(memory_flags_t::use_runtime_ptr, size, sub_ptr);
+        return std::unique_ptr<memory_storage_t>(sub_storage);
+    }
+
+    std::unique_ptr<memory_storage_t> clone() const override {
+        auto storage = new cpu_memory_storage_t(engine());
+        if (storage)
+            storage->init(memory_flags_t::use_runtime_ptr, 0, data_.get());
+        return std::unique_ptr<memory_storage_t>(storage);
+    }
+
+protected:
+    status_t init_allocate(size_t size) override {
+        void *ptr = malloc(size, platform::get_cache_line_size());
+        if (!ptr) return status::out_of_memory;
+        data_ = decltype(data_)(ptr, destroy);
+        return status::success;
+    }
+
+private:
+    std::unique_ptr<void, void (*)(void *)> data_;
+
+    DNNL_DISALLOW_COPY_AND_ASSIGN(cpu_memory_storage_t);
+
+    static void release(void *ptr) {}
+    static void destroy(void *ptr) { free(ptr); }
+};
+
+} // namespace cpu
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/cpu/cpu_pooling_pd.hpp

@@ -0,0 +1,41 @@
+/*******************************************************************************
+* Copyright 2016-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 CPU_CPU_POOLING_PD_HPP
+#define CPU_CPU_POOLING_PD_HPP
+
+#include "common/pooling_pd.hpp"
+#include "cpu/cpu_engine.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct cpu_pooling_fwd_pd_t : public pooling_fwd_pd_t {
+    using pooling_fwd_pd_t::pooling_fwd_pd_t;
+};
+
+struct cpu_pooling_bwd_pd_t : public pooling_bwd_pd_t {
+    using pooling_bwd_pd_t::pooling_bwd_pd_t;
+};
+
+} // namespace cpu
+} // 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/cpu/cpu_prelu_pd.hpp

@@ -0,0 +1,43 @@
+/*******************************************************************************
+* 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 CPU_CPU_PRELU_PD_HPP
+#define CPU_CPU_PRELU_PD_HPP
+
+#include <assert.h>
+
+#include "common/prelu_pd.hpp"
+#include "cpu/cpu_engine.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct cpu_prelu_fwd_pd_t : public prelu_fwd_pd_t {
+    using prelu_fwd_pd_t::prelu_fwd_pd_t;
+};
+
+struct cpu_prelu_bwd_pd_t : public prelu_bwd_pd_t {
+    using prelu_bwd_pd_t::prelu_bwd_pd_t;
+};
+
+} // namespace cpu
+} // 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/cpu/cpu_primitive.hpp

@@ -0,0 +1,133 @@
+/*******************************************************************************
+* Copyright 2019-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 CPU_CPU_PRIMITIVE_HPP
+#define CPU_CPU_PRIMITIVE_HPP
+
+#include <assert.h>
+
+#include "oneapi/dnnl/dnnl_types.h"
+
+#include "common/c_types_map.hpp"
+#include "common/primitive_attr.hpp"
+#include "common/primitive_exec_types.hpp"
+#include "common/utils.hpp"
+#include "common/z_magic.hpp"
+
+#define DEFINE_SCALES_BUFFER_ATTR_ARG(attr, scales, arg) \
+    alignas(16) float CONCAT2(scales, _buf16)[16] = {0}; \
+    const float *scales {nullptr}; \
+    if ((attr)) { \
+        if ((attr)->output_scales_.has_default_values()) { \
+            utils::array_set(CONCAT2(scales, _buf16), 1.0f, 16); \
+            scales = CONCAT2(scales, _buf16); \
+        } else { \
+            scales = CTX_IN_MEM(const float *, arg); \
+            if (scales == nullptr) return status::invalid_arguments; \
+            const auto scales_d = ctx.memory_mdw(arg); \
+            bool ok = scales_d.data_type() == data_type::f32 \
+                    && scales_d.ndims() == 1; \
+            if (!ok) return status::invalid_arguments; \
+            if (scales_d.dims()[0] == 1) { \
+                utils::array_set(CONCAT2(scales, _buf16), scales[0], 16); \
+                scales = CONCAT2(scales, _buf16); \
+            } \
+        } \
+    } \
+    MAYBE_UNUSED(scales);
+
+#define DEFINE_SCALES_BUFFER_ATTR(attr, scales) \
+    DEFINE_SCALES_BUFFER_ATTR_ARG(attr, scales, DNNL_ARG_ATTR_OUTPUT_SCALES);
+
+#define DEFINE_SCALES_BUFFER(scales) \
+    DEFINE_SCALES_BUFFER_ATTR(pd()->attr(), scales)
+
+#define DEFINE_ARG_SCALES_BUFFER_ATTR(attr, scales, arg) \
+    alignas(16) float CONCAT2(scales, _buf16)[16] = {0}; \
+    const float *scales {nullptr}; \
+    if ((attr)) { \
+        if ((attr)->scales_.get(arg).has_default_values()) { \
+            utils::array_set(CONCAT2(scales, _buf16), 1.0f, 16); \
+            scales = CONCAT2(scales, _buf16); \
+        } else { \
+            scales = CTX_IN_MEM(const float *, DNNL_ARG_ATTR_SCALES | arg); \
+            if (scales == nullptr) return status::invalid_arguments; \
+            const auto scales_d = ctx.memory_mdw(DNNL_ARG_ATTR_SCALES | arg); \
+            bool ok = scales_d.data_type() == data_type::f32 \
+                    && scales_d.ndims() == 1; \
+            if (!ok) return status::invalid_arguments; \
+            if (scales_d.dims()[0] == 1) { \
+                if (utils::one_of(arg, DNNL_ARG_DST, \
+                            DNNL_ARG_ATTR_POST_OP_DW | DNNL_ARG_DST)) { \
+                    utils::array_set( \
+                            CONCAT2(scales, _buf16), 1.f / scales[0], 16); \
+                } else { \
+                    utils::array_set(CONCAT2(scales, _buf16), scales[0], 16); \
+                } \
+                scales = CONCAT2(scales, _buf16); \
+            } \
+        } \
+    } \
+    MAYBE_UNUSED(scales);
+
+#define DEFINE_ARG_SCALES_BUFFER(scales, arg) \
+    DEFINE_ARG_SCALES_BUFFER_ATTR(pd()->attr(), scales, arg)
+
+#define DEFINE_ZERO_POINTS_BUFFER(zero_points_ptr, mem_arg) \
+    int32_t CONCAT2(default_zero_point_, mem_arg) = 0; \
+    const int32_t *zero_points_ptr \
+            = pd()->attr()->zero_points_.defined(mem_arg) \
+            ? &CONCAT2(default_zero_point_, mem_arg) \
+            : CTX_IN_MEM( \
+                    const int32_t *, DNNL_ARG_ATTR_ZERO_POINTS | mem_arg); \
+    if (zero_points_ptr == nullptr) return status::invalid_arguments; \
+    MAYBE_UNUSED(zero_points_ptr);
+
+#define ASSIGN_ARG_SCALE_VALUE(scale, mem_arg) \
+    alignas(16) float CONCAT2(CONCAT2(scales, _buf16), mem_arg)[16] = {0}; \
+    if (pd()->attr()->scales_.get(mem_arg).has_default_values()) { \
+        utils::array_set(CONCAT2(CONCAT2(scales, _buf16), mem_arg), 1.0f, 16); \
+        scale = CONCAT2(CONCAT2(scales, _buf16), mem_arg); \
+    } else { \
+        const auto scale_d = ctx.memory_mdw(DNNL_ARG_ATTR_SCALES | mem_arg); \
+        bool ok = scale_d.data_type() == data_type::f32 \
+                && scale_d.ndims() == 1 && scale_d.dims()[0] == 1; \
+        if (!ok) return status::invalid_arguments; \
+        const float *scale_p \
+                = CTX_IN_MEM(const float *, DNNL_ARG_ATTR_SCALES | mem_arg); \
+        if (scale_p == nullptr) return status::invalid_arguments; \
+        scale = scale_p; \
+    }
+
+#define DEFINE_ZERO_POINT_VALUE_ATTR(attr, zero_point, mem_arg) \
+    int32_t zero_point = 0; \
+    if (!attr->zero_points_.has_default_values(mem_arg)) { \
+        const auto zero_points_d \
+                = ctx.memory_mdw(DNNL_ARG_ATTR_ZERO_POINTS | mem_arg); \
+        bool ok = zero_points_d.data_type() == data_type::s32 \
+                && zero_points_d.ndims() == 1 && zero_points_d.dims()[0] == 1; \
+        if (!ok) return status::invalid_arguments; \
+        const int32_t *zero_points_ptr = CTX_IN_MEM( \
+                const int32_t *, DNNL_ARG_ATTR_ZERO_POINTS | mem_arg); \
+        if (zero_points_ptr == nullptr) return status::invalid_arguments; \
+        zero_point = *zero_points_ptr; \
+    } \
+    MAYBE_UNUSED(zero_point);
+
+#define DEFINE_ZERO_POINT_VALUE(zero_point, mem_arg) \
+    DEFINE_ZERO_POINT_VALUE_ATTR(pd()->attr(), zero_point, mem_arg)
+
+#endif // CPU_CPU_PRIMITIVE_HPP

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/cpu/cpu_reduction_pd.hpp

@@ -0,0 +1,34 @@
+/*******************************************************************************
+* 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 CPU_REDUCTION_PD_HPP
+#define CPU_REDUCTION_PD_HPP
+
+#include "common/reduction_pd.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct cpu_reduction_pd_t : public reduction_pd_t {
+    using reduction_pd_t::reduction_pd_t;
+};
+
+} // namespace cpu
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/cpu/cpu_resampling_pd.hpp

@@ -0,0 +1,41 @@
+/*******************************************************************************
+* 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 CPU_CPU_RESAMPLING_PD_HPP
+#define CPU_CPU_RESAMPLING_PD_HPP
+
+#include "common/resampling_pd.hpp"
+
+#include "cpu/cpu_engine.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct cpu_resampling_fwd_pd_t : public resampling_fwd_pd_t {
+    using resampling_fwd_pd_t::resampling_fwd_pd_t;
+};
+
+struct cpu_resampling_bwd_pd_t : public resampling_bwd_pd_t {
+    using resampling_bwd_pd_t::resampling_bwd_pd_t;
+};
+} // namespace cpu
+} // namespace impl
+} // namespace dnnl
+
+#endif
+
+// vim: et ts=4 sw=4 cindent cino^=l0,\:0,N-s

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/cpu/cpu_shuffle_pd.hpp

@@ -0,0 +1,42 @@
+/*******************************************************************************
+* Copyright 2018-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 CPU_CPU_SHUFFLE_PD_HPP
+#define CPU_CPU_SHUFFLE_PD_HPP
+
+#include <assert.h>
+
+#include "common/c_types_map.hpp"
+#include "common/shuffle_pd.hpp"
+#include "common/type_helpers.hpp"
+#include "common/utils.hpp"
+#include "cpu/cpu_engine.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct cpu_shuffle_pd_t : public shuffle_pd_t {
+    using shuffle_pd_t::shuffle_pd_t;
+};
+
+} // namespace cpu
+} // 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/cpu/cpu_softmax_pd.hpp

@@ -0,0 +1,46 @@
+/*******************************************************************************
+* Copyright 2016-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 CPU_CPU_SOFTMAX_PD_HPP
+#define CPU_CPU_SOFTMAX_PD_HPP
+
+#include <assert.h>
+
+#include "common/c_types_map.hpp"
+#include "common/softmax_pd.hpp"
+#include "common/type_helpers.hpp"
+#include "common/utils.hpp"
+#include "cpu/cpu_engine.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct cpu_softmax_fwd_pd_t : public softmax_fwd_pd_t {
+    using softmax_fwd_pd_t::softmax_fwd_pd_t;
+};
+
+struct cpu_softmax_bwd_pd_t : public softmax_bwd_pd_t {
+    using softmax_bwd_pd_t::softmax_bwd_pd_t;
+};
+
+} // namespace cpu
+} // 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/cpu/cpu_stream.hpp

@@ -0,0 +1,64 @@
+/*******************************************************************************
+* 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 CPU_CPU_STREAM_HPP
+#define CPU_CPU_STREAM_HPP
+
+#include "oneapi/dnnl/dnnl_config.h"
+
+#if DNNL_CPU_RUNTIME == DNNL_RUNTIME_THREADPOOL
+#include "oneapi/dnnl/dnnl_threadpool_iface.hpp"
+#endif
+
+#include "common/c_types_map.hpp"
+#include "common/dnnl_thread.hpp"
+#include "common/stream.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct cpu_stream_t : public stream_t {
+    cpu_stream_t(engine_t *engine, unsigned flags) : stream_t(engine, flags) {}
+    virtual ~cpu_stream_t() = default;
+
+    dnnl::impl::status_t wait() override {
+        // CPU execution is synchronous so return immediately
+        return dnnl::impl::status::success;
+    }
+
+#if DNNL_CPU_RUNTIME == DNNL_RUNTIME_THREADPOOL
+    cpu_stream_t(engine_t *engine,
+            dnnl::threadpool_interop::threadpool_iface *threadpool)
+        : stream_t(engine, threadpool) {}
+
+    void before_exec_hook() override {
+        dnnl::threadpool_interop::threadpool_iface *tp;
+        auto rc = this->get_threadpool(&tp);
+        if (rc == status::success) threadpool_utils::activate_threadpool(tp);
+    }
+
+    void after_exec_hook() override {
+        threadpool_utils::deactivate_threadpool();
+    }
+#endif
+};
+
+} // namespace cpu
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/cpu/cpu_sum_pd.hpp

@@ -0,0 +1,40 @@
+/*******************************************************************************
+* Copyright 2016-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 CPU_CPU_SUM_PD_HPP
+#define CPU_CPU_SUM_PD_HPP
+
+#include "common/c_types_map.hpp"
+#include "common/sum_pd.hpp"
+#include "common/type_helpers.hpp"
+#include "common/utils.hpp"
+#include "cpu/cpu_engine.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct cpu_sum_pd_t : public sum_pd_t {
+    using sum_pd_t::sum_pd_t;
+};
+
+} // namespace cpu
+} // 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/cpu/dw_convolution_utils.hpp

@@ -0,0 +1,131 @@
+/*******************************************************************************
+* 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 CPU_DW_CONVOLUTION_UTILS_HPP
+#define CPU_DW_CONVOLUTION_UTILS_HPP
+
+#include "common/c_types_map.hpp"
+#include "common/convolution_pd.hpp"
+#include "common/primitive_desc_iterator.hpp"
+#include "common/type_helpers.hpp"
+#include "common/utils.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+inline status_t get_depthwise_conv_desc(convolution_desc_t &cd_dw,
+        const memory_desc_t &src_dw_md, const primitive_attr_t &attr_1x1,
+        primitive_attr_t &attr_dw, int dw_po_index) {
+
+    const memory_desc_wrapper src_dw_d(src_dw_md);
+    const int ndims = src_dw_d.ndims();
+    if (ndims != 4) return status::unimplemented;
+
+    if (dw_po_index == -1 || dw_po_index >= attr_1x1.post_ops_.len()
+            || !attr_1x1.post_ops_.entry_[dw_po_index].is_convolution())
+        return status::invalid_arguments;
+
+    // Create new attributes with scales from depthwise post-op and copy
+    // post-ops after depthwise post-op.
+    auto &dw_po = attr_1x1.post_ops_.entry_[dw_po_index].depthwise_conv;
+
+    // erase 1x1 conv scales
+    for (auto arg : {DNNL_ARG_SRC, DNNL_ARG_WEIGHTS, DNNL_ARG_DST}) {
+        auto &scale = attr_dw.scales_.get(arg);
+        if (!scale.has_default_values()) attr_dw.scales_.reset(arg);
+    }
+
+    const auto &dw_src_scales = attr_1x1.scales_.get(DNNL_ARG_DST);
+    const auto &dw_wei_scales
+            = attr_1x1.scales_.get(DNNL_ARG_ATTR_POST_OP_DW | DNNL_ARG_WEIGHTS);
+    const auto &dw_dst_scales
+            = attr_1x1.scales_.get(DNNL_ARG_ATTR_POST_OP_DW | DNNL_ARG_DST);
+    if (!dw_src_scales.has_default_values())
+        attr_dw.scales_.set(DNNL_ARG_SRC, dw_src_scales.mask_);
+    if (!dw_wei_scales.has_default_values())
+        attr_dw.scales_.set(DNNL_ARG_WEIGHTS, dw_wei_scales.mask_);
+    if (!dw_dst_scales.has_default_values())
+        attr_dw.scales_.set(DNNL_ARG_DST, dw_dst_scales.mask_);
+
+    auto dw_po_len = attr_1x1.post_ops_.len() - (dw_po_index + 1);
+    attr_dw.post_ops_.entry_.resize(dw_po_len);
+    for (int i = 0; i < dw_po_len; ++i) {
+        attr_dw.post_ops_.entry_[i].copy_from(
+                attr_1x1.post_ops_.entry_[i + dw_po_index + 1]);
+    }
+
+    attr_dw.scratchpad_mode_ = attr_1x1.scratchpad_mode_;
+
+    const bool with_bias = dw_po.bias_dt != data_type::undef;
+
+    const auto n = src_dw_d.dims()[0];
+    const auto oc = src_dw_d.dims()[1];
+    const auto g = src_dw_d.dims()[1];
+    const auto ih = src_dw_d.dims()[ndims - 2];
+    const auto iw = src_dw_d.dims()[ndims - 1];
+    const auto kernel = dw_po.kernel;
+    const auto stride = dw_po.stride;
+    const auto padding = dw_po.padding;
+
+    const dims_t weights_tz = {g, 1, 1, kernel, kernel};
+
+    // Not following standard convolution formula for output shapes since
+    // right/top padding might be greated than left/top one.
+    const dim_t oh = utils::div_up(ih, stride);
+    const dim_t ow = utils::div_up(iw, stride);
+    const dims_t dst_tz = {n, oc, oh, ow};
+
+    const dims_t bias_tz = {oc};
+    const dims_t pad_tz = {padding, padding};
+    const dims_t stride_tz = {stride, stride};
+
+    const dim_t pad_h_r = (oh - 1) * stride - ih + kernel - padding;
+    const dim_t pad_w_r = (ow - 1) * stride - iw + kernel - padding;
+    const dims_t pad_r_tz = {pad_h_r, pad_w_r};
+
+    memory_desc_t src_md, weights_md, bias_md, dst_md;
+
+    const auto src_dw_tag = src_dw_d.matches_one_of_tag(
+            format_tag::nChw16c, format_tag::nChw8c, format_tag::nhwc);
+    const auto data_tag
+            = (src_dw_tag == format_tag::undef) ? format_tag::any : src_dw_tag;
+
+    memory_desc_init_by_tag(
+            src_md, ndims, src_dw_md.dims, src_dw_md.data_type, data_tag);
+
+    memory_desc_init_by_tag(
+            weights_md, ndims + 1, weights_tz, dw_po.wei_dt, format_tag::any);
+
+    if (with_bias)
+        memory_desc_init_by_tag(
+                bias_md, 1, bias_tz, dw_po.bias_dt, format_tag::a);
+
+    memory_desc_init_by_tag(dst_md, ndims, dst_tz, dw_po.dst_dt, data_tag);
+
+    CHECK(conv_desc_init(&cd_dw, prop_kind::forward_inference,
+            alg_kind::convolution_auto, &src_md, &weights_md,
+            with_bias ? &bias_md : nullptr, &dst_md, stride_tz, nullptr, pad_tz,
+            pad_r_tz));
+
+    return status::success;
+}
+
+} // namespace cpu
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/cpu/gemm_convolution.hpp

@@ -0,0 +1,229 @@
+/*******************************************************************************
+* 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 CPU_GEMM_CONVOLUTION_HPP
+#define CPU_GEMM_CONVOLUTION_HPP
+
+#include "common/broadcast_strategy.hpp"
+#include "common/c_types_map.hpp"
+#include "common/memory_tracking.hpp"
+#include "common/primitive.hpp"
+
+#include "cpu/binary_injector_utils.hpp"
+#include "cpu/cpu_convolution_pd.hpp"
+#include "cpu/gemm/gemm.hpp"
+#include "cpu/gemm_convolution_utils.hpp"
+#include "cpu/primitive_attr_postops.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct gemm_convolution_fwd_t : public primitive_t {
+    struct pd_t : public cpu_convolution_fwd_pd_t {
+        pd_t(const convolution_desc_t *adesc, const primitive_attr_t *attr,
+                const typename pd_t::base_class *hint_fwd_pd)
+            : cpu_convolution_fwd_pd_t(adesc, attr, hint_fwd_pd), jcp_() {}
+
+        DECLARE_COMMON_PD_T(
+                GEMM_IMPL_STR, gemm_convolution_fwd_t, USE_GLOBAL_SCRATCHPAD);
+
+        status_t init(engine_t *engine) {
+            using namespace data_type;
+
+            bool ok = is_fwd()
+                    && set_default_alg_kind(alg_kind::convolution_direct)
+                    && expect_data_types(f32, f32, f32, f32, f32)
+                    && !has_zero_dim_memory()
+                    && attr()->has_default_values(
+                            primitive_attr_t::skip_mask_t::post_ops, f32)
+                    && post_ops_ok();
+            if (!ok) return status::unimplemented;
+
+            auto scratchpad = scratchpad_registry().registrar();
+            return jit_gemm_convolution_utils::init_conf(jcp_, scratchpad,
+                    *desc(), src_md_, weights_md_, dst_md_, bias_md_, attr_,
+                    dnnl_get_max_threads());
+        }
+
+        conv_gemm_conf_t jcp_;
+
+    protected:
+        bool post_ops_ok() const {
+            auto const &po = attr()->post_ops_;
+            auto is_sum_ok = [&](int idx) {
+                return IMPLICATION(po.entry_[idx].kind == primitive_kind::sum,
+                        idx == 0 && po.entry_[idx].is_sum());
+            };
+            auto is_binary
+                    = [&](int idx) { return po.entry_[idx].is_binary(); };
+            auto is_prelu = [&](int idx) { return po.entry_[idx].is_prelu(); };
+            auto is_binary_or_prelu_supported = [&](int idx) {
+                bool ok = dnnl::impl::get_rhs_arg_broadcasting_strategy(
+                                  binary_injector_utils::get_src1_desc(
+                                          po.entry_[idx], dst_md_),
+                                  dst_md_,
+                                  {broadcasting_strategy_t::scalar,
+                                          broadcasting_strategy_t::per_oc})
+                        != broadcasting_strategy_t::unsupported;
+                return ok;
+            };
+
+            if (!ref_post_ops_t::primitive_kind_ok(attr()->post_ops_))
+                return false;
+
+            for (int idx = 0; idx < po.len(); idx++) {
+                bool ok = is_sum_ok(idx)
+                        && IMPLICATION(is_binary(idx) || is_prelu(idx),
+                                is_binary_or_prelu_supported(idx));
+                if (!ok) return false;
+            }
+
+            return true;
+        }
+    };
+
+    gemm_convolution_fwd_t(const pd_t *apd)
+        : primitive_t(apd), post_ops_(nullptr) {}
+
+    status_t init(engine_t *engine) override {
+        const data_t one = 1.0, zero = 0.0;
+        const auto &jcp = pd()->jcp_;
+        beta_ = jcp.with_sum ? one : zero;
+
+        if (jcp.with_eltwise || jcp.with_binary) {
+            CHECK(safe_ptr_assign(post_ops_, new ref_post_ops_t(jcp.post_ops)));
+            CHECK(post_ops_->init(pd()->dst_md()));
+        }
+        return status::success;
+    }
+
+    typedef typename prec_traits<data_type::f32>::type data_t;
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        bool is_nspc = pd()->jcp_.is_nspc;
+        return is_nspc ? execute_forward_nspc(ctx) : execute_forward_ncsp(ctx);
+    }
+
+private:
+    status_t execute_forward_ncsp(const exec_ctx_t &ctx) const;
+    status_t execute_forward_nspc(const exec_ctx_t &ctx) const;
+    status_t execute_forward_thr_nspc(const exec_ctx_t &ctx, const int ithr,
+            const int nthr, const data_t *src_base, const data_t *wei_base,
+            const data_t *bia_base, data_t *dst_base,
+            const memory_tracking::grantor_t &scratchpad) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+
+    data_t beta_;
+
+    std::unique_ptr<ref_post_ops_t> post_ops_;
+};
+
+struct gemm_convolution_bwd_data_t : public primitive_t {
+    struct pd_t : public cpu_convolution_bwd_data_pd_t {
+        pd_t(const convolution_desc_t *adesc, const primitive_attr_t *attr,
+                const convolution_fwd_pd_t *hint_fwd_pd)
+            : cpu_convolution_bwd_data_pd_t(adesc, attr, hint_fwd_pd), jcp_() {}
+
+        DECLARE_COMMON_PD_T(GEMM_IMPL_STR, gemm_convolution_bwd_data_t,
+                USE_GLOBAL_SCRATCHPAD);
+
+        status_t init(engine_t *engine) {
+            bool ok = true && desc()->prop_kind == prop_kind::backward_data
+                    && set_default_alg_kind(alg_kind::convolution_direct)
+                    && expect_data_types(data_type::f32, data_type::f32,
+                            data_type::undef, data_type::f32, data_type::f32)
+                    && !has_zero_dim_memory() && attr()->has_default_values();
+            if (!ok) return status::unimplemented;
+
+            auto scratchpad = scratchpad_registry().registrar();
+            return jit_gemm_convolution_utils::init_conf(jcp_, scratchpad,
+                    *desc(), diff_src_md_, weights_md_, diff_dst_md_, bias_md_,
+                    attr_, dnnl_get_max_threads());
+        }
+
+        conv_gemm_conf_t jcp_;
+    };
+
+    gemm_convolution_bwd_data_t(const pd_t *apd) : primitive_t(apd) {}
+
+    typedef typename prec_traits<data_type::f32>::type data_t;
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        bool is_nspc = pd()->jcp_.is_nspc;
+        return is_nspc ? execute_backward_data_nspc(ctx)
+                       : execute_backward_data_ncsp(ctx);
+    }
+
+private:
+    status_t execute_backward_data_nspc(const exec_ctx_t &ctx) const;
+    status_t execute_backward_data_ncsp(const exec_ctx_t &ctx) const;
+    status_t execute_backward_data_thr_nspc(const int ithr, const int nthr,
+            const data_t *diff_dst_base, const data_t *wei_base,
+            const data_t *bia_base, data_t *diff_src_base,
+            const memory_tracking::grantor_t &scratchpad) const;
+
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+};
+
+struct gemm_convolution_bwd_weights_t : public primitive_t {
+    struct pd_t : public cpu_convolution_bwd_weights_pd_t {
+        pd_t(const convolution_desc_t *adesc, const primitive_attr_t *attr,
+                const convolution_fwd_pd_t *hint_fwd_pd)
+            : cpu_convolution_bwd_weights_pd_t(adesc, attr, hint_fwd_pd)
+            , jcp_() {}
+
+        DECLARE_COMMON_PD_T(GEMM_IMPL_STR, gemm_convolution_bwd_weights_t,
+                USE_GLOBAL_SCRATCHPAD);
+
+        status_t init(engine_t *engine) {
+            bool ok = true && desc()->prop_kind == prop_kind::backward_weights
+                    && set_default_alg_kind(alg_kind::convolution_direct)
+                    && expect_data_types(data_type::f32, data_type::f32,
+                            data_type::f32, data_type::f32, data_type::f32)
+                    && !has_zero_dim_memory() && attr()->has_default_values();
+            if (!ok) return status::unimplemented;
+
+            auto scratchpad = scratchpad_registry().registrar();
+            return jit_gemm_convolution_utils::init_conf(jcp_, scratchpad,
+                    *desc(), src_md_, diff_weights_md_, diff_dst_md_,
+                    diff_bias_md_, attr_, dnnl_get_max_threads());
+        }
+
+        conv_gemm_conf_t jcp_;
+    };
+
+    gemm_convolution_bwd_weights_t(const pd_t *apd) : primitive_t(apd) {}
+
+    typedef typename prec_traits<data_type::f32>::type data_t;
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        const bool is_nspc = pd()->jcp_.is_nspc;
+        return is_nspc ? execute_backward_weights_nspc(ctx)
+                       : execute_backward_weights_ncsp(ctx);
+    }
+
+private:
+    status_t execute_backward_weights_ncsp(const exec_ctx_t &ctx) const;
+    status_t execute_backward_weights_nspc(const exec_ctx_t &ctx) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+};
+
+} // namespace cpu
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/cpu/gemm_convolution_utils.hpp

@@ -0,0 +1,139 @@
+/*******************************************************************************
+* Copyright 2016-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 CPU_GEMM_CONVOLUTION_UTILS_HPP
+#define CPU_GEMM_CONVOLUTION_UTILS_HPP
+
+#include "common/c_types_map.hpp"
+#include "common/dnnl_thread.hpp"
+#include "common/memory_tracking.hpp"
+
+#include "cpu/cpu_convolution_pd.hpp"
+#include "cpu/cpu_engine.hpp"
+#include "cpu/zero_point_utils.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+enum conv_gemm_loop_order_t { gemm_loop_rlb, gemm_loop_lrb, gemm_loop_lbr };
+struct conv_gemm_conf_t {
+    prop_kind_t prop_kind;
+
+    dim_t mb;
+    dim_t ngroups, ic, oc;
+    dim_t iw, ih, id, ow, oh, od;
+    dim_t l_pad, t_pad, f_pad, e_pad, b_pad, r_pad;
+    dim_t kh, kw, kd;
+    dim_t stride_h, stride_w, stride_d;
+    dim_t dilate_h, dilate_w, dilate_d;
+    bool with_bias;
+    bool with_eltwise;
+    bool with_binary;
+    bool with_sum;
+    post_ops_t post_ops;
+    bool is_nspc;
+
+    dim_t is, os, ks;
+    dim_t ic_block, oc_block;
+
+    int nthr;
+    ptrdiff_t im2col_sz;
+    bool need_wei_reduction;
+    bool signed_input;
+    dim_t oh_block;
+    dim_t ow_block;
+    dim_t os_block, os_nb_block;
+    bool outer_threading;
+    conv_gemm_loop_order_t loop_order;
+    int nthr_oc;
+
+    zero_point_config_t zp;
+
+    data_type_t bias_data_type;
+    data_type_t dst_data_type;
+    data_type_t sum_data_type;
+    size_t dst_os_stride;
+    size_t scale_idx_mult;
+    bool with_dst_scale;
+};
+
+struct single_gemm_conv_chunk_desc_t {
+    single_gemm_conv_chunk_desc_t() = default;
+    single_gemm_conv_chunk_desc_t(dim_t d_off, dim_t d_size, dim_t h_off,
+            dim_t h_size, dim_t w_off, dim_t w_size);
+
+    dim_t d_off_ = 0;
+    dim_t d_size_ = 0;
+    dim_t h_off_ = 0;
+    dim_t h_size_ = 0;
+    dim_t w_off_ = 0;
+    dim_t w_size_ = 0;
+};
+
+namespace jit_gemm_convolution_utils {
+template <typename data_type_t>
+void im2col_3d(const conv_gemm_conf_t &jcp, const data_type_t *im,
+        data_type_t *col, dim_t od, int spatial_step, int spatial_block);
+
+template <typename T>
+void transpose_dt(const conv_gemm_conf_t &jcp, const T *__restrict im,
+        T *__restrict imtr);
+
+template <typename im_dt, typename col_dt>
+void im2col_dt_3d(const conv_gemm_conf_t &jcp, const void *__restrict im,
+        col_dt *__restrict col, dim_t od);
+
+template <typename data_type_t>
+void im2col(const conv_gemm_conf_t &jcp, const data_type_t *__restrict im,
+        data_type_t *__restrict col, dim_t ss, dim_t sb, dim_t cs, dim_t cb);
+
+template <typename im_dt, typename col_dt>
+void im2col_dt(const conv_gemm_conf_t &jcp, const void *__restrict im,
+        void *__restrict imtr, col_dt *__restrict col, dim_t hs, dim_t hb,
+        dim_t ws, dim_t wb);
+
+template <typename T>
+void col2im_dt(
+        const conv_gemm_conf_t &jcp, const T *__restrict col, T *__restrict im);
+void col2im_3d(const conv_gemm_conf_t &jcp, const float *col, float *im,
+        dim_t od, int spatial_step, int spatial_block);
+void col2im(const conv_gemm_conf_t &jcp, const float *col, float *im,
+        int spatial_step, int spatial_block);
+
+status_t init_conf(conv_gemm_conf_t &jcp,
+        memory_tracking::registrar_t &scratchpad, const convolution_desc_t &cd,
+        memory_desc_t &src_md, memory_desc_t &weights_md, memory_desc_t &dst_md,
+        memory_desc_t &bias_md, primitive_attr_t &attr, int max_threads);
+
+void bwd_weights_balance(int ithr, int nthr, int ngroups, int mb, int &ithr_g,
+        int &nthr_g, int &ithr_mb, int &nthr_mb);
+void bwd_weights_reduction_par_ncsp(int ithr, int nthr,
+        const conv_gemm_conf_t &jcp, const float *weights_reduce_ws,
+        float *weights);
+void bwd_weights_reduction_par_nspc(int ithr, int nthr, size_t g_start,
+        size_t g_end, const conv_gemm_conf_t &jcp,
+        const float *weights_reduce_base, float *diff_weights);
+
+bool padding_exists(const conv_gemm_conf_t &jcp) noexcept;
+
+} // namespace jit_gemm_convolution_utils
+
+} // namespace cpu
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/cpu/gemm_inner_product.hpp

@@ -0,0 +1,200 @@
+/*******************************************************************************
+* 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 CPU_GEMM_INNER_PRODUCT_HPP
+#define CPU_GEMM_INNER_PRODUCT_HPP
+
+#include <assert.h>
+
+#include <memory>
+
+#include "common/c_types_map.hpp"
+#include "common/primitive.hpp"
+#include "common/type_helpers.hpp"
+#include "common/utils.hpp"
+
+#include "cpu/gemm/gemm.hpp"
+#include "cpu/gemm_inner_product_utils.hpp"
+
+#include "cpu/cpu_inner_product_pd.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+template <impl::data_type_t data_type>
+struct gemm_inner_product_fwd_t : public primitive_t {
+    struct pd_t : public cpu_inner_product_fwd_pd_t {
+        using cpu_inner_product_fwd_pd_t::cpu_inner_product_fwd_pd_t;
+
+        DECLARE_COMMON_PD_T(GEMM_IMPL_STR, gemm_inner_product_fwd_t);
+
+        status_t init(engine_t *engine) {
+            using namespace utils;
+
+            const bool ok = true && is_fwd() && !has_zero_dim_memory()
+                    && everyone_is(data_type, src_md()->data_type,
+                            weights_md()->data_type, dst_md()->data_type,
+                            with_bias() ? weights_md(1)->data_type : data_type)
+                    && attr()->has_default_values(
+                            primitive_attr_t::skip_mask_t::post_ops
+                            | primitive_attr_t::skip_mask_t::sum_dt)
+                    && attr()->post_ops_.check_sum_consistency(
+                            dst_md()->data_type, /* is_int8 */ false)
+                    && set_default_params() == status::success
+                    && dense_gemm_consitency_check(
+                            src_md(), weights_md(), dst_md())
+                    && inner_product_utils::post_ops_ok(
+                            attr()->post_ops_, &dst_md_)
+                    && attr_.set_default_formats(dst_md(0)) == status::success;
+            if (!ok) return status::unimplemented;
+
+            const auto sum_idx = attr()->post_ops_.find(primitive_kind::sum);
+            // Native GeMM doesn't support sum with a dt other than dst_dt.
+            sum_through_pp_kernel_ = sum_idx >= 0
+                    && !utils::one_of(attr()->post_ops_.entry_[sum_idx].sum.dt,
+                            data_type::undef, dst_md()->data_type);
+            init_scratchpad();
+
+            return status::success;
+        }
+
+        bool sum_through_pp_kernel_ = false;
+
+    private:
+        void init_scratchpad() {
+            using namespace memory_tracking::names;
+            if (sum_through_pp_kernel_) {
+                auto scratchpad = scratchpad_registry().registrar();
+                const memory_desc_wrapper dst_d(dst_md());
+                scratchpad.template book<char>(
+                        key_gemm_tmp_buffer, dst_d.size());
+            }
+        }
+    };
+
+    gemm_inner_product_fwd_t(const pd_t *apd)
+        : primitive_t(apd), postops_in_ip_(false) {}
+
+    status_t init(engine_t *engine) override {
+        const bool has_bias = pd()->with_bias();
+        const bool has_eltwise
+                = pd()->attr()->post_ops_.find(primitive_kind::eltwise) >= 0;
+        const bool has_binary
+                = pd()->attr()->post_ops_.find(primitive_kind::binary) >= 0;
+        const bool has_prelu
+                = pd()->attr()->post_ops_.find(primitive_kind::prelu) >= 0;
+
+        const bool has_sum = pd()->sum_through_pp_kernel_;
+        postops_in_ip_
+                = has_bias || has_eltwise || has_binary || has_prelu || has_sum;
+
+        CHECK(safe_ptr_assign(pp_kernel_,
+                inner_product_utils::pp_kernel_t::create(pd(), !has_sum)));
+
+        return pp_kernel_->create_kernel();
+    }
+
+    typedef typename prec_traits<data_type>::type data_t;
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_forward(ctx);
+    }
+
+private:
+    status_t execute_forward(const exec_ctx_t &ctx) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+
+    std::unique_ptr<inner_product_utils::pp_kernel_t> pp_kernel_;
+    bool postops_in_ip_;
+};
+
+template <impl::data_type_t data_type>
+struct gemm_inner_product_bwd_data_t : public primitive_t {
+    struct pd_t : public cpu_inner_product_bwd_data_pd_t {
+        using cpu_inner_product_bwd_data_pd_t::cpu_inner_product_bwd_data_pd_t;
+
+        DECLARE_COMMON_PD_T(GEMM_IMPL_STR, gemm_inner_product_bwd_data_t);
+
+        status_t init(engine_t *engine) {
+            bool ok = true && desc()->prop_kind == prop_kind::backward_data
+                    && !has_zero_dim_memory()
+                    && utils::everyone_is(data_type, diff_src_md()->data_type,
+                            weights_md()->data_type, diff_dst_md()->data_type)
+                    && attr()->has_default_values()
+                    && set_default_params() == status::success
+                    && dense_gemm_consitency_check(
+                            diff_src_md(), weights_md(), diff_dst_md());
+            return ok ? status::success : status::unimplemented;
+        }
+    };
+
+    gemm_inner_product_bwd_data_t(const pd_t *apd) : primitive_t(apd) {}
+    typedef typename prec_traits<data_type>::type data_t;
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_backward_data(ctx);
+    }
+
+private:
+    status_t execute_backward_data(const exec_ctx_t &ctx) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+};
+
+template <impl::data_type_t data_type>
+struct gemm_inner_product_bwd_weights_t : public primitive_t {
+    struct pd_t : public cpu_inner_product_bwd_weights_pd_t {
+        using cpu_inner_product_bwd_weights_pd_t::
+                cpu_inner_product_bwd_weights_pd_t;
+
+        DECLARE_COMMON_PD_T(GEMM_IMPL_STR, gemm_inner_product_bwd_weights_t);
+
+        status_t init(engine_t *engine) {
+            bool ok = true && desc()->prop_kind == prop_kind::backward_weights
+                    && !has_zero_dim_memory()
+                    && utils::everyone_is(data_type, src_md()->data_type,
+                            diff_weights_md()->data_type,
+                            diff_dst_md()->data_type,
+                            with_bias() ? diff_weights_md(1)->data_type
+                                        : data_type)
+                    && attr()->has_default_values()
+                    && set_default_params() == status::success
+                    && dense_gemm_consitency_check(
+                            src_md(), diff_weights_md(), diff_dst_md());
+
+            return ok ? status::success : status::unimplemented;
+        }
+    };
+
+    gemm_inner_product_bwd_weights_t(const pd_t *apd) : primitive_t(apd) {}
+    typedef typename prec_traits<data_type>::type data_t;
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_backward_weights(ctx);
+    }
+
+private:
+    status_t execute_backward_weights(const exec_ctx_t &ctx) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+};
+
+} // namespace cpu
+} // 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/cpu/gemm_inner_product_utils.hpp

@@ -0,0 +1,115 @@
+/*******************************************************************************
+* 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 CPU_GEMM_INNER_PRODUCT_UTILS_HPP
+#define CPU_GEMM_INNER_PRODUCT_UTILS_HPP
+
+#include "common/broadcast_strategy.hpp"
+#include "common/c_types_map.hpp"
+#include "common/type_helpers.hpp"
+#include "common/utils.hpp"
+
+#include "cpu/cpu_inner_product_pd.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+namespace inner_product_utils {
+
+struct pp_kernel_t {
+    static pp_kernel_t *create(size_t OC, size_t MB, dim_t dst_mb_stride,
+            const primitive_attr_t *attr, data_type_t bias_dt,
+            data_type_t acc_dt, const memory_desc_t *dst_md, bool skip_sum);
+    static pp_kernel_t *create(
+            const cpu_inner_product_fwd_pd_t *pd, bool skip_sum) {
+        return create(pd->OC(), pd->MB(), pd->OC(), pd->attr(),
+                pd->desc()->bias_desc.data_type, pd->desc()->accum_data_type,
+                pd->dst_md(), skip_sum);
+    }
+
+    virtual ~pp_kernel_t() = default;
+
+    // mb kernel only supports single-threaded execution where performance
+    // degradation is larger
+    bool sequential_kernel() const { return mb_blk_kernel_; }
+
+    virtual void operator()(void *dst, const void *acc, const char *bias,
+            const float *scales, float dst_scale, size_t start,
+            size_t dst_logical_off, size_t dim1_off, size_t end,
+            size_t runtime_oc, dim_t dst_mb_stride,
+            const float *dst_zero_points,
+            const void *post_ops_binary_rhs_arg_vec, const void *dst_orig,
+            size_t first_mb_matrix_addr_off, const exec_ctx_t &ctx,
+            const memory_desc_t &dst_md) const = 0;
+
+    virtual status_t create_kernel() { return status::success; }
+
+protected:
+    pp_kernel_t(size_t OC, size_t MB, dim_t dst_mb_stride,
+            const primitive_attr_t *attr, data_type_t bias_dt,
+            data_type_t acc_dt, const memory_desc_t *dst_md, bool skip_sum);
+
+    size_t OC_;
+    size_t MB_;
+    dim_t dst_mb_stride_;
+    data_type_t bias_data_type_;
+    data_type_t acc_data_type_;
+    data_type_t dst_data_type_;
+    size_t bias_data_type_size_ = 0;
+    size_t acc_data_type_size_ = 4;
+    size_t dst_data_type_size_ = 0;
+    bool do_scale_ = false;
+    size_t scale_idx_mult_ = 0;
+    bool do_eltwise_ = false;
+    bool do_binary_ = false;
+    bool do_prelu_ = false;
+    bool do_sum_ = false;
+    bool do_dst_scale_ = false;
+    bool do_dst_zero_points_ = false;
+    float sum_scale_ = 0.f;
+    int32_t sum_zp_ = 0;
+    data_type_t sum_data_type_;
+    bool mb_blk_kernel_ = false;
+    post_ops_t post_ops_;
+    int ndims_;
+
+    bool has_trivial_mb_stride() const {
+        return (!runtime_oc()) && (OC_ == (size_t)dst_mb_stride_);
+    }
+    bool do_bias() const { return bias_data_type_ != data_type::undef; }
+    bool runtime_oc() const { return OC_ == (size_t)DNNL_RUNTIME_DIM_VAL; }
+    bool runtime_mb() const { return MB_ == (size_t)DNNL_RUNTIME_DIM_VAL; }
+};
+
+inline const bcast_set_t &gemm_default_strategies() {
+    static const bcast_set_t s
+            = {broadcasting_strategy_t::scalar, broadcasting_strategy_t::per_oc,
+                    broadcasting_strategy_t::per_oc_spatial,
+                    broadcasting_strategy_t::no_broadcast};
+    return s;
+}
+
+bool post_ops_ok(const post_ops_t &post_ops, const memory_desc_wrapper *dst_d,
+        const bcast_set_t &enabled_bcast_strategy = gemm_default_strategies());
+bool post_ops_ok(const post_ops_t &post_ops, const memory_desc_t *dst_d,
+        const bcast_set_t &enabled_bcast_strategy = gemm_default_strategies());
+
+} // namespace inner_product_utils
+} // namespace cpu
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/cpu/gemm_x8s8s32x_conv_zp_src_pad_comp.hpp

@@ -0,0 +1,42 @@
+/*******************************************************************************
+* 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 CPU_GEMM_X8S8S32X_CONV_ZP_SRC_PAD_COMP_HPP_
+#define CPU_GEMM_X8S8S32X_CONV_ZP_SRC_PAD_COMP_HPP_
+
+#include "common/c_types_map.hpp"
+#include "cpu/gemm_convolution_utils.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+void compute_zp_src_comp_pad(const conv_gemm_conf_t &jcp,
+        int32_t *const zp_src_pad_buf, const int32_t *const zp_src,
+        const int8_t *weights, const memory_desc_wrapper &weights_md,
+        const bool with_groups);
+
+void apply_zp_src_comp_pad(const conv_gemm_conf_t &jcp, const dim_t g,
+        const dim_t d_offset, const dim_t h_offset, const dim_t w_offset,
+        const dim_t h_size, const dim_t w_size,
+        int32_t *__restrict gemm_conv_result,
+        const int32_t *__restrict zp_src_pad_buf);
+
+} // namespace cpu
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/cpu/gemm_x8s8s32x_convolution.hpp

@@ -0,0 +1,181 @@
+/*******************************************************************************
+* 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 CPU_GEMM_X8S8S32X_CONVOLUTION_HPP
+#define CPU_GEMM_X8S8S32X_CONVOLUTION_HPP
+
+#include <memory>
+
+#include "common/c_types_map.hpp"
+#include "common/memory_tracking.hpp"
+#include "common/primitive.hpp"
+
+#include "cpu/platform.hpp"
+
+#include "cpu/cpu_convolution_pd.hpp"
+
+#include "cpu/gemm_convolution_utils.hpp"
+#include "cpu/gemm_x8s8s32x_convolution_utils.hpp"
+
+#include "cpu/gemm/gemm.hpp"
+#include "cpu/zero_point_utils.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct gemm_x8s8s32x_convolution_fwd_t : public primitive_t {
+    struct pd_t : public cpu_convolution_fwd_pd_t {
+        pd_t(const convolution_desc_t *adesc, const primitive_attr_t *attr,
+                const typename pd_t::base_class *hint_fwd_pd)
+            : cpu_convolution_fwd_pd_t(adesc, attr, hint_fwd_pd), jcp_() {}
+
+        DECLARE_COMMON_PD_T(src_md()->data_type == data_type::u8
+                        ? IGEMM_S8U8S32_IMPL_STR
+                        : IGEMM_S8S8S32_IMPL_STR,
+                gemm_x8s8s32x_convolution_fwd_t, USE_GLOBAL_SCRATCHPAD);
+
+        status_t init(engine_t *engine) {
+            using namespace data_type;
+            using skip_mask_t = primitive_attr_t::skip_mask_t;
+            const auto dst_type = dst_md(0)->data_type;
+
+            bool ok = is_fwd()
+                    && set_default_alg_kind(alg_kind::convolution_direct)
+                    && utils::one_of(src_md()->data_type, s8, u8)
+                    && weights_md()->data_type == s8
+                    && utils::one_of(
+                            dst_md()->data_type, f32, bf16, s32, s8, u8)
+                    && IMPLICATION(with_bias(),
+                            utils::one_of(weights_md(1)->data_type, f32, bf16,
+                                    s32, s8, u8))
+                    && !has_zero_dim_memory()
+                    && attr()->has_default_values(skip_mask_t::scales_runtime
+                                    | skip_mask_t::zero_points_runtime
+                                    | skip_mask_t::post_ops
+                                    | skip_mask_t::sum_dt,
+                            dst_type)
+                    && attr()->post_ops_.check_sum_consistency(dst_type,
+                            /* is_int8 */ true)
+                    && attr_scales_ok() && zero_points_valid(attr());
+            if (!ok) return status::unimplemented;
+
+            auto scratchpad = scratchpad_registry().registrar();
+            CHECK(jit_gemm_convolution_utils::init_conf(jcp_, scratchpad,
+                    *desc(), src_md_, weights_md_, dst_md_, bias_md_, attr_,
+                    dnnl_get_max_threads()));
+            if (!gemm_x8s8s32x_convolution_utils::post_ops_ok(
+                        attr()->post_ops_, &dst_md_))
+                return status::unimplemented;
+            return status::success;
+        }
+
+        conv_gemm_conf_t jcp_;
+    };
+
+    gemm_x8s8s32x_convolution_fwd_t(const pd_t *apd) : primitive_t(apd) {}
+
+    status_t init(engine_t *engine) override {
+        CHECK(safe_ptr_assign(pp_ker_, pp_ker_t::create(pd(), pd()->jcp_)));
+        return (pp_ker_) ? pp_ker_->create_kernel() : status::success;
+    }
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_forward(ctx);
+    }
+
+private:
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+    status_t execute_forward(const exec_ctx_t &ctx) const;
+    status_t execute_forward_thr(const int ithr, const int nthr,
+            const char *src_base, const int8_t *wei_base, const char *bia_base,
+            void *dst_base, const float *scales, const float *dst_scales,
+            const zero_point_call_params_t &zp,
+            const memory_tracking::grantor_t &scratchpad,
+            const void *post_ops_binary_rhs_arg_vec,
+            const exec_ctx_t &ctx) const;
+
+    using pp_ker_t = gemm_x8s8s32x_convolution_utils::pp_ker_t;
+    std::unique_ptr<pp_ker_t> pp_ker_;
+};
+
+struct gemm_x8s8s32x_convolution_bwd_data_t : public primitive_t {
+    struct pd_t : public cpu_convolution_bwd_data_pd_t {
+        pd_t(const convolution_desc_t *adesc, const primitive_attr_t *attr,
+                const convolution_fwd_pd_t *hint_fwd_pd)
+            : cpu_convolution_bwd_data_pd_t(adesc, attr, hint_fwd_pd), jcp_() {}
+
+        DECLARE_COMMON_PD_T(diff_dst_md()->data_type == data_type::u8
+                        ? IGEMM_S8U8S32_IMPL_STR
+                        : IGEMM_S8S8S32_IMPL_STR,
+                gemm_x8s8s32x_convolution_bwd_data_t, USE_GLOBAL_SCRATCHPAD);
+
+        status_t init(engine_t *engine) {
+            using namespace data_type;
+
+            bool ok = desc()->prop_kind == prop_kind::backward_data
+                    && set_default_alg_kind(alg_kind::convolution_direct)
+                    && utils::one_of(diff_dst_md()->data_type, s8, u8)
+                    && weights_md()->data_type == s8
+                    && utils::one_of(
+                            diff_src_md()->data_type, f32, bf16, s32, s8, u8)
+                    && IMPLICATION(with_bias(),
+                            utils::one_of(weights_md(1)->data_type, f32, bf16,
+                                    s32, s8, u8))
+                    && !has_zero_dim_memory()
+                    && attr()->has_default_values(
+                            primitive_attr_t::skip_mask_t::scales_runtime)
+                    && output_scales_mask_ok();
+            if (!ok) return status::unimplemented;
+
+            auto scratchpad = scratchpad_registry().registrar();
+            return jit_gemm_convolution_utils::init_conf(jcp_, scratchpad,
+                    *desc(), diff_src_md_, weights_md_, diff_dst_md_, bias_md_,
+                    attr_, dnnl_get_max_threads());
+        }
+
+        bool support_bias() const override { return true; }
+
+        conv_gemm_conf_t jcp_;
+
+    protected:
+        bool output_scales_mask_ok() const {
+            const auto &mask = attr()->output_scales_.mask_;
+            return mask == 0 || mask == 1 << 1;
+        }
+    };
+
+    gemm_x8s8s32x_convolution_bwd_data_t(const pd_t *apd) : primitive_t(apd) {}
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_backward_data(ctx);
+    }
+
+private:
+    status_t execute_backward_data(const exec_ctx_t &ctx) const;
+    status_t execute_backward_data_thr(const int ithr, const int nthr,
+            const char *diff_dst_base, const int8_t *wei_base,
+            const char *bia_base, char *diff_src_base,
+            const memory_tracking::grantor_t &scratchpad,
+            const exec_ctx_t &ctx) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+};
+
+} // namespace cpu
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/cpu/gemm_x8s8s32x_convolution_utils.hpp

@@ -0,0 +1,62 @@
+/*******************************************************************************
+* 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 CPU_GEMM_X8S8S32X_CONVOLUTION_UTILS_HPP
+#define CPU_GEMM_X8S8S32X_CONVOLUTION_UTILS_HPP
+
+#include "cpu/gemm_convolution_utils.hpp"
+#if DNNL_X64
+#include "cpu/x64/injectors/jit_uni_postops_injector.hpp"
+#endif
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+namespace gemm_x8s8s32x_convolution_utils {
+
+struct pp_ker_t {
+    static pp_ker_t *create(
+            const convolution_pd_t *pd, const conv_gemm_conf_t &jcp);
+    virtual ~pp_ker_t() = default;
+
+    typedef typename prec_traits<data_type::s32>::type acc_data_t;
+
+    virtual void operator()(void *dst, const acc_data_t *acc, const char *bias,
+            const float *scales, float dst_scale, float sum_scale,
+            float signed_scale, int g, size_t start, size_t end,
+            const zero_point_call_params_t &zp,
+            const void *post_ops_binary_rhs_arg_vec, const void *dst_orig,
+            const exec_ctx_t &ctx, const memory_desc_t &dst_md,
+            const single_gemm_conv_chunk_desc_t &chunk_desc) const = 0;
+
+    virtual status_t create_kernel() { return status::success; }
+
+protected:
+    pp_ker_t(const convolution_pd_t *pd, const conv_gemm_conf_t &jcp);
+
+    const conv_gemm_conf_t &jcp_;
+};
+
+bool post_ops_ok(const post_ops_t &post_ops, const memory_desc_wrapper *dst_d);
+bool post_ops_ok(const post_ops_t &post_ops, const memory_desc_t *dst_d);
+bool mayiuse_jit_pp_kernel(data_type_t dst_dt) noexcept;
+
+} // namespace gemm_x8s8s32x_convolution_utils
+} // namespace cpu
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/cpu/gemm_x8s8s32x_inner_product.hpp

@@ -0,0 +1,127 @@
+/*******************************************************************************
+* Copyright 2018-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 CPU_GEMM_X8S8S32X_INNER_PRODUCT_HPP
+#define CPU_GEMM_X8S8S32X_INNER_PRODUCT_HPP
+
+#include <assert.h>
+
+#include <memory>
+
+#include "common/c_types_map.hpp"
+#include "common/memory_tracking.hpp"
+#include "common/primitive.hpp"
+#include "common/type_helpers.hpp"
+#include "common/utils.hpp"
+
+#include "cpu/gemm/gemm.hpp"
+#include "cpu/gemm_inner_product_utils.hpp"
+
+#include "cpu/cpu_inner_product_pd.hpp"
+#include "cpu/scale_utils.hpp"
+#if DNNL_X64
+#include "cpu/x64/injectors/jit_uni_postops_injector.hpp"
+#endif
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct gemm_x8s8s32x_inner_product_fwd_t : public primitive_t {
+    struct pd_t : public cpu_inner_product_fwd_pd_t {
+        using cpu_inner_product_fwd_pd_t::cpu_inner_product_fwd_pd_t;
+
+        DECLARE_COMMON_PD_T(src_md()->data_type == data_type::u8
+                        ? IGEMM_S8U8S32_IMPL_STR
+                        : IGEMM_S8S8S32_IMPL_STR,
+                gemm_x8s8s32x_inner_product_fwd_t, USE_GLOBAL_SCRATCHPAD);
+
+        status_t init(engine_t *engine) {
+            using namespace data_type;
+
+            const bool ok = is_fwd() && !has_zero_dim_memory()
+                    && utils::one_of(src_md()->data_type, s8, u8)
+                    && weights_md()->data_type == s8
+                    && utils::one_of(dst_md()->data_type, f32, s32, s8, u8)
+                    && IMPLICATION(with_bias(),
+                            utils::one_of(
+                                    weights_md(1)->data_type, f32, s32, s8, u8))
+                    && attr()->has_default_values(
+                            primitive_attr_t::skip_mask_t::scales_runtime
+                                    | primitive_attr_t::skip_mask_t::post_ops,
+                            dst_md()->data_type)
+                    && attr()->post_ops_.check_sum_consistency(
+                            dst_md()->data_type, /* is_int */ true)
+                    && attr_scales_ok()
+                    && set_default_params() == status::success
+                    && dense_gemm_consitency_check(
+                            src_md(), weights_md(), dst_md())
+                    && attr_.set_default_formats(dst_md(0)) == status::success
+                    && inner_product_utils::post_ops_ok(
+                            attr()->post_ops_, &dst_md_);
+
+            if (!ok) return status::unimplemented;
+
+            bool do_sum = attr()->post_ops_.find(primitive_kind::sum) >= 0;
+            dst_is_acc_
+                    = utils::one_of(dst_md()->data_type, s32, f32) && !do_sum;
+
+            init_scratchpad();
+
+            return status::success;
+        }
+
+        bool dst_is_acc_;
+
+    private:
+        void init_scratchpad() {
+            auto scratchpad = scratchpad_registry().registrar();
+            if (!dst_is_acc_) {
+                scratchpad.template book<int32_t>(
+                        memory_tracking::names::key_iprod_int_dat_in_acc_dt,
+                        MB() * OC());
+            }
+
+            book_precomputed_scales(scratchpad, attr()->scales_, OC());
+        }
+    };
+
+    gemm_x8s8s32x_inner_product_fwd_t(const pd_t *apd) : primitive_t(apd) {}
+
+    status_t init(engine_t *engine) override {
+        CHECK(safe_ptr_assign(pp_kernel_,
+                inner_product_utils::pp_kernel_t::create(pd(), false)));
+        return pp_kernel_->create_kernel();
+    }
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_forward(ctx);
+    }
+
+private:
+    status_t execute_forward(const exec_ctx_t &ctx) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+
+    std::unique_ptr<inner_product_utils::pp_kernel_t> pp_kernel_;
+};
+
+} // namespace cpu
+} // 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/cpu/nchw_pooling.hpp

@@ -0,0 +1,201 @@
+/*******************************************************************************
+* 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 CPU_NCHW_POOLING_HPP
+#define CPU_NCHW_POOLING_HPP
+
+#include <assert.h>
+
+#include "common/bfloat16.hpp"
+#include "common/c_types_map.hpp"
+#include "common/dnnl_thread.hpp"
+#include "common/primitive.hpp"
+#include "common/type_helpers.hpp"
+#include "common/utils.hpp"
+
+#include "cpu/cpu_pooling_pd.hpp"
+#include "cpu/platform.hpp"
+#include "cpu/primitive_attr_postops.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+template <data_type_t d_type>
+struct nchw_pooling_fwd_t : public primitive_t {
+    struct pd_t : public cpu_pooling_fwd_pd_t {
+        using cpu_pooling_fwd_pd_t::cpu_pooling_fwd_pd_t;
+
+        DECLARE_COMMON_PD_T("simple_nchw:any", nchw_pooling_fwd_t);
+
+        status_t init(engine_t *engine) {
+            const format_tag_t desired_fmt_tag = utils::pick(ndims() - 3,
+                    format_tag::ncw, format_tag::nchw, format_tag::ncdhw);
+
+            const bool ok = is_fwd()
+                    && utils::one_of(desc()->alg_kind, alg_kind::pooling_max,
+                            alg_kind::pooling_avg_include_padding,
+                            alg_kind::pooling_avg_exclude_padding)
+                    && utils::everyone_is(
+                            d_type, src_md()->data_type, dst_md()->data_type)
+                    && platform::has_data_type_support(d_type)
+                    && !has_zero_dim_memory() && !is_dilated()
+                    && attr()->has_default_values(
+                            primitive_attr_t::skip_mask_t::post_ops, d_type)
+                    && ref_post_ops_t::primitive_kind_ok(attr()->post_ops_)
+                    && set_default_params() == status::success
+                    && memory_desc_matches_tag(*src_md(), desired_fmt_tag)
+                    && memory_desc_matches_tag(*dst_md(), desired_fmt_tag)
+                    && attr_.set_default_formats(dst_md(0)) == status::success;
+            if (!ok) return status::unimplemented;
+
+            const bool is_training
+                    = desc_.prop_kind == prop_kind::forward_training;
+            if (desc()->alg_kind == alg_kind::pooling_max && is_training)
+                init_default_ws();
+
+            init_scratchpad();
+
+            return status::success;
+        }
+
+    private:
+        void init_scratchpad() {
+            using namespace memory_tracking::names;
+            if (src_md()->data_type != data_type::f32) {
+                const size_t src_sz_ = ID() * IH() * IW() * IC() * MB();
+                auto scratchpad = scratchpad_registry().registrar();
+                scratchpad.template book<float>(key_pool_src_bf16cvt, src_sz_);
+            }
+        }
+    };
+
+    nchw_pooling_fwd_t(const pd_t *apd) : primitive_t(apd) {}
+
+    using data_t = typename prec_traits<d_type>::type;
+
+    status_t init(engine_t *engine) override {
+        ref_post_ops_
+                = utils::make_unique<ref_post_ops_t>(pd()->attr()->post_ops_);
+        if (!ref_post_ops_) return status::out_of_memory;
+        CHECK(ref_post_ops_->init(pd()->dst_md()));
+        return status::success;
+    }
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_forward(ctx);
+    }
+
+private:
+    status_t execute_forward(const exec_ctx_t &ctx) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+    std::unique_ptr<ref_post_ops_t> ref_post_ops_;
+};
+
+template <data_type_t d_type>
+struct nchw_pooling_bwd_t : public primitive_t {
+    struct pd_t : public cpu_pooling_bwd_pd_t {
+        using cpu_pooling_bwd_pd_t::cpu_pooling_bwd_pd_t;
+
+        DECLARE_COMMON_PD_T("simple_nchw:any", nchw_pooling_bwd_t);
+
+        status_t init(engine_t *engine) {
+            const format_tag_t desired_fmt_tag = utils::pick(ndims() - 3,
+                    format_tag::ncw, format_tag::nchw, format_tag::ncdhw);
+
+            using namespace prop_kind;
+            using namespace alg_kind;
+            bool ok = !is_fwd()
+                    && utils::one_of(desc()->alg_kind, alg_kind::pooling_max,
+                            alg_kind::pooling_avg_include_padding,
+                            alg_kind::pooling_avg_exclude_padding)
+                    && utils::everyone_is(d_type, diff_dst_md()->data_type,
+                            diff_src_md()->data_type)
+                    && platform::has_data_type_support(d_type)
+                    && !has_zero_dim_memory()
+                    && set_default_params() == status::success
+                    && attr()->has_default_values()
+                    && memory_desc_matches_tag(*diff_dst_md(), desired_fmt_tag)
+                    && memory_desc_matches_tag(*diff_src_md(), desired_fmt_tag)
+                    && !is_dilated();
+            if (!ok) return status::unimplemented;
+
+            if (desc()->alg_kind == pooling_max) {
+                const auto ws_dt = hint_fwd_pd_->workspace_md()->data_type;
+                init_default_ws(ws_dt);
+                if (!compare_ws(hint_fwd_pd_)) return status::unimplemented;
+            }
+
+            nthr_ = dnnl_get_max_threads();
+            calculate_channel_block_size();
+            init_scratchpad();
+
+            return status::success;
+        }
+
+        dim_t channel_block_size_;
+        int nthr_; // To not exceed the limit in execute used for set up.
+
+    private:
+        void init_scratchpad() {
+            using namespace memory_tracking::names;
+            if (diff_dst_md()->data_type != data_type::f32) {
+                size_t dst_sz_ = OD() * OH() * OW();
+                size_t src_sz_ = ID() * IH() * IW();
+                auto scratchpad = scratchpad_registry().registrar();
+
+                scratchpad.template book<float>(key_pool_src_bf16cvt,
+                        src_sz_ * nthr_ * channel_block_size_);
+                scratchpad.template book<float>(key_pool_dst_bf16cvt,
+                        dst_sz_ * nthr_ * channel_block_size_);
+            }
+        }
+
+        void calculate_channel_block_size() {
+            // calculate channels block size at which the data fits into half
+            // of L1, it allows to improve performance for problems with small
+            // spatial
+            dim_t dst_sz_ = OD() * OH() * OW();
+            dim_t src_sz_ = ID() * IH() * IW();
+            dim_t C_per_thr = nstl::min(MB() * IC() / nthr_, IC());
+            const dim_t max_block_size
+                    = platform::get_per_core_cache_size(1) / 2;
+            dim_t data_size_per_ch = (dst_sz_ + src_sz_) * 6; // f32 + bf16
+            channel_block_size_ = nstl::max(
+                    nstl::min(C_per_thr, max_block_size / data_size_per_ch),
+                    (dim_t)1);
+        }
+    };
+
+    nchw_pooling_bwd_t(const pd_t *apd) : primitive_t(apd) {}
+    typedef typename prec_traits<d_type>::type data_t;
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_backward(ctx);
+    }
+
+private:
+    status_t execute_backward(const exec_ctx_t &ctx) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+};
+
+} // namespace cpu
+} // 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/cpu/ncsp_batch_normalization.hpp

@@ -0,0 +1,211 @@
+/*******************************************************************************
+* Copyright 2018-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 CPU_NCSP_BATCH_NORMALIZATION_HPP
+#define CPU_NCSP_BATCH_NORMALIZATION_HPP
+
+#include <assert.h>
+
+#include "common/c_types_map.hpp"
+#include "common/dnnl_thread.hpp"
+#include "common/memory_tracking.hpp"
+#include "common/primitive.hpp"
+#include "common/type_helpers.hpp"
+#include "common/utils.hpp"
+
+#include "cpu/platform.hpp"
+
+#include "cpu/cpu_batch_normalization_pd.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+template <data_type_t d_type>
+struct ncsp_batch_normalization_fwd_t : public primitive_t {
+    struct pd_t : public cpu_batch_normalization_fwd_pd_t {
+        using cpu_batch_normalization_fwd_pd_t::
+                cpu_batch_normalization_fwd_pd_t;
+
+        DECLARE_COMMON_PD_T("ncsp_bnorm:any", ncsp_batch_normalization_fwd_t);
+
+        status_t init(engine_t *engine) {
+            using namespace data_type;
+            using namespace format_tag;
+
+            bool ok = is_fwd() && !has_zero_dim_memory()
+                    && utils::everyone_is(
+                            d_type, src_md()->data_type, dst_md()->data_type)
+                    && platform::has_data_type_support(d_type)
+                    && IMPLICATION(is_training(),
+                            platform::has_training_support(d_type))
+                    && check_scale_shift_data_type()
+                    && (attr()->has_default_values()
+                            || with_relu_post_op(is_training()))
+                    && set_default_formats_common()
+                    && memory_desc_wrapper(src_md())
+                            == memory_desc_wrapper(dst_md())
+                    && memory_desc_matches_one_of_tag(
+                            *src_md(), ncdhw, nchw, ncw);
+            if (!ok) return status::unimplemented;
+
+            // BN+Add+Relu fusion is not currently implemented
+            if (fuse_norm_add_relu()) return status::unimplemented;
+
+            if (is_training() && fuse_norm_relu()) init_default_ws(8);
+
+            nthr_ = dnnl_get_max_threads();
+            init_scratchpad();
+
+            return status::success;
+        }
+
+        int nthr_; // To not exceed the limit in execute used for set up.
+
+    private:
+        void init_scratchpad() {
+            using namespace memory_tracking::names;
+            auto scratchpad = scratchpad_registry().registrar();
+            if (!stats_is_src()) {
+                scratchpad.template book<acc_data_t>(
+                        key_bnorm_reduction, C() * nthr_);
+
+                if (!is_training()) {
+                    scratchpad.template book<acc_data_t>(
+                            key_bnorm_tmp_mean, C());
+                    scratchpad.template book<acc_data_t>(
+                            key_bnorm_tmp_var, C());
+                }
+            }
+
+            if (utils::one_of(d_type, data_type::bf16, data_type::f16)) {
+                static constexpr dim_t simd_w = 16;
+                const dim_t SP = D() * H() * W();
+                const int nbufs = 2;
+                const size_t cvt_buf_sz
+                        = nbufs * nthr_ * utils::rnd_up(SP, simd_w);
+                scratchpad.template book<acc_data_t>(key_bnorm_cvt, cvt_buf_sz);
+            }
+        }
+    };
+
+    typedef typename prec_traits<d_type>::type data_t;
+    typedef float acc_data_t;
+
+    ncsp_batch_normalization_fwd_t(const pd_t *apd) : primitive_t(apd) {}
+    ~ncsp_batch_normalization_fwd_t() {}
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_forward(ctx);
+    }
+
+private:
+    status_t execute_forward(const exec_ctx_t &ctx) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+};
+
+template <data_type_t d_type>
+struct ncsp_batch_normalization_bwd_t : public primitive_t {
+    struct pd_t : public cpu_batch_normalization_bwd_pd_t {
+        using cpu_batch_normalization_bwd_pd_t::
+                cpu_batch_normalization_bwd_pd_t;
+
+        DECLARE_COMMON_PD_T("ncsp_bnorm:any", ncsp_batch_normalization_bwd_t);
+
+        status_t init(engine_t *engine) {
+            using namespace data_type;
+            using namespace format_tag;
+
+            bool ok = !is_fwd() && !has_zero_dim_memory()
+                    && utils::everyone_is(d_type, src_md()->data_type,
+                            diff_dst_md()->data_type, diff_src_md()->data_type)
+                    && platform::has_data_type_support(d_type)
+                    && platform::has_training_support(d_type)
+                    && check_scale_shift_data_type()
+                    && attr()->has_default_values()
+                    && set_default_formats_common()
+                    && memory_desc_wrapper(diff_src_md())
+                            == memory_desc_wrapper(diff_dst_md())
+                    && memory_desc_matches_one_of_tag(
+                            *src_md(), ncdhw, nchw, ncw)
+                    && memory_desc_matches_one_of_tag(
+                            *diff_src_md(), ncdhw, nchw, ncw);
+            if (!ok) return status::unimplemented;
+
+            // BN+Add+Relu fusion is not currently implemented
+            if (fuse_norm_add_relu()) return status::unimplemented;
+
+            if (fuse_norm_relu()) {
+                init_default_ws(8);
+                if (!compare_ws(hint_fwd_pd_)) return status::unimplemented;
+            }
+
+            nthr_ = dnnl_get_max_threads();
+            init_scratchpad();
+
+            return status::success;
+        }
+
+        int nthr_; // To not exceed the limit in execute used for set up.
+
+    private:
+        void init_scratchpad() {
+            using namespace memory_tracking::names;
+            auto scratchpad = scratchpad_registry().registrar();
+            scratchpad.template book<acc_data_t>(
+                    key_bnorm_reduction, 2 * C() * nthr_);
+            const auto pk_is_bwd = desc()->prop_kind == prop_kind::backward;
+            size_t ss_size = 0;
+            if (!use_scale() || !pk_is_bwd) ss_size += C();
+            if (!use_shift() || !pk_is_bwd) ss_size += C();
+
+            if (ss_size)
+                scratchpad.template book<acc_data_t>(
+                        key_bnorm_tmp_diff_ss, ss_size);
+
+            if (utils::one_of(d_type, data_type::bf16, data_type::f16)) {
+                static constexpr dim_t simd_w = 16;
+                const dim_t SP = D() * H() * W();
+                const int nbufs = 2 + !use_global_stats();
+                const size_t cvt_buf_sz
+                        = nbufs * nthr_ * utils::rnd_up(SP, simd_w);
+                scratchpad.template book<acc_data_t>(key_bnorm_cvt, cvt_buf_sz);
+            }
+        }
+    };
+
+    typedef typename prec_traits<d_type>::type data_t;
+    typedef float acc_data_t;
+
+    ncsp_batch_normalization_bwd_t(const pd_t *apd) : primitive_t(apd) {}
+    ~ncsp_batch_normalization_bwd_t() {}
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_backward(ctx);
+    }
+
+private:
+    status_t execute_backward(const exec_ctx_t &ctx) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+};
+
+} // namespace cpu
+} // 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/cpu/ncsp_group_normalization.hpp

@@ -0,0 +1,106 @@
+/*******************************************************************************
+* 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 CPU_NCSP_GROUP_NORMALIZATION_HPP
+#define CPU_NCSP_GROUP_NORMALIZATION_HPP
+
+#include "common/c_types_map.hpp"
+#include "common/dnnl_thread.hpp"
+#include "common/memory_tracking.hpp"
+#include "common/primitive.hpp"
+#include "common/type_helpers.hpp"
+#include "common/utils.hpp"
+
+#include "cpu/cpu_group_normalization_pd.hpp"
+#include "cpu/platform.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct ncsp_group_normalization_fwd_t : public primitive_t {
+    using primitive_t::primitive_t;
+
+    struct pd_t : public cpu_group_normalization_fwd_pd_t {
+        using cpu_group_normalization_fwd_pd_t::
+                cpu_group_normalization_fwd_pd_t;
+
+        DECLARE_COMMON_PD_T("ncsp_gnorm:any", ncsp_group_normalization_fwd_t);
+
+        status_t init(engine_t *engine) {
+            using namespace data_type;
+            using namespace format_tag;
+            using skip_mask_t = primitive_attr_t::skip_mask_t;
+
+            VDISPATCH_GNORM(is_fwd(), VERBOSE_BAD_PROPKIND);
+            VDISPATCH_GNORM(
+                    !has_zero_dim_memory(), VERBOSE_EMPTY_TENSOR, "src");
+            VDISPATCH_GNORM(
+                    utils::one_of(src_md()->data_type, f32, bf16, f16, s8, u8)
+                            && platform::has_data_type_support(
+                                    src_md()->data_type),
+                    VERBOSE_UNSUPPORTED_DT);
+            VDISPATCH_GNORM(
+                    utils::one_of(dst_md()->data_type, f32, bf16, f16, s8, u8)
+                            && platform::has_data_type_support(
+                                    dst_md()->data_type),
+                    VERBOSE_UNSUPPORTED_DT);
+            VDISPATCH_GNORM(
+                    check_scale_shift_data_type(), VERBOSE_UNSUPPORTED_DT);
+            VDISPATCH_GNORM(memory_desc_matches_one_of_tag(
+                                    *src_md(), ncdhw, nchw, ncw, nc),
+                    VERBOSE_UNSUPPORTED_TAG);
+            VDISPATCH_GNORM(memory_desc_matches_one_of_tag(
+                                    *dst_md(), ncdhw, nchw, ncw, nc),
+                    VERBOSE_UNSUPPORTED_TAG);
+            VDISPATCH_GNORM(
+                    set_default_formats_common(), VERBOSE_UNSUPPORTED_TAG);
+            VDISPATCH_GNORM(
+                    attr()->has_default_values(skip_mask_t::scales_runtime)
+                            && attr_scales_ok(),
+                    VERBOSE_UNSUPPORTED_ATTR);
+            nthr_ = dnnl_get_max_threads();
+
+            using namespace memory_tracking::names;
+            auto scratchpad = scratchpad_registry().registrar();
+
+            const auto src_dt = src_md()->data_type;
+            const auto dst_dt = dst_md()->data_type;
+            if (!utils::everyone_is(data_type::f32, src_dt, dst_dt)) {
+                const size_t cvt_buf_sz = nthr_ * cvt_per_thread_size_;
+                scratchpad.template book<float>(key_gnorm_cvt, cvt_buf_sz);
+            }
+            return status::success;
+        }
+
+        static constexpr size_t cvt_per_thread_size_ = 16;
+        int nthr_; // To not exceed the limit in execute used for set up.
+    };
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_forward(ctx);
+    }
+
+private:
+    status_t execute_forward(const exec_ctx_t &ctx) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+};
+
+} // namespace cpu
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/cpu/nhwc_pooling.hpp

@@ -0,0 +1,204 @@
+/*******************************************************************************
+* 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 CPU_NHWC_POOLING_HPP
+#define CPU_NHWC_POOLING_HPP
+
+#include <assert.h>
+
+#include "common/bfloat16.hpp"
+#include "common/c_types_map.hpp"
+#include "common/dnnl_thread.hpp"
+#include "common/primitive.hpp"
+#include "common/type_helpers.hpp"
+#include "common/utils.hpp"
+
+#include "cpu/cpu_pooling_pd.hpp"
+#include "cpu/platform.hpp"
+#include "cpu/primitive_attr_postops.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+namespace nhwc_pooling {
+size_t strided_offset(const int _n, const size_t _sn, const int _d,
+        const size_t _sd, const int _h, const size_t _sh, const int _w,
+        const size_t _sw);
+}
+
+template <data_type_t d_type>
+struct nhwc_pooling_fwd_t : public primitive_t {
+    struct pd_t : public cpu_pooling_fwd_pd_t {
+        using cpu_pooling_fwd_pd_t::cpu_pooling_fwd_pd_t;
+
+        DECLARE_COMMON_PD_T("simple_nhwc:any", nhwc_pooling_fwd_t);
+
+        status_t init(engine_t *engine) {
+            const format_tag_t desired_fmt_tag = utils::pick(ndims() - 3,
+                    format_tag::nwc, format_tag::nhwc, format_tag::ndhwc);
+
+            using namespace prop_kind;
+            using namespace alg_kind;
+            const bool ok = is_fwd()
+                    && utils::one_of(desc()->alg_kind, pooling_max,
+                            pooling_avg_include_padding,
+                            pooling_avg_exclude_padding)
+                    && utils::everyone_is(
+                            d_type, src_md()->data_type, dst_md()->data_type)
+                    && platform::has_data_type_support(d_type) && !is_dilated()
+                    && attr()->has_default_values(
+                            primitive_attr_t::skip_mask_t::post_ops, d_type)
+                    && ref_post_ops_t::primitive_kind_ok(attr()->post_ops_)
+                    && set_default_params() == status::success
+                    && memory_desc_matches_tag(*src_md(), desired_fmt_tag)
+                    && memory_desc_matches_tag(*dst_md(), desired_fmt_tag)
+                    && attr_.set_default_formats(dst_md(0)) == status::success;
+            if (!ok) return status::unimplemented;
+
+            const bool is_training = desc_.prop_kind == forward_training;
+            if (desc()->alg_kind == pooling_max && is_training) {
+                init_default_ws();
+            }
+
+            nthr_ = dnnl_get_max_threads();
+            init_scratchpad();
+
+            return status::success;
+        }
+
+        int nthr_; // To not exceed the limit in execute used for set up.
+
+    private:
+        void init_scratchpad() {
+            using namespace memory_tracking::names;
+            if (src_md()->data_type != data_type::f32) {
+                const size_t bf16cvt_sz_ = IC() * nthr_;
+                auto scratchpad = scratchpad_registry().registrar();
+                scratchpad.template book<float>(
+                        key_pool_src_bf16cvt, bf16cvt_sz_);
+                scratchpad.template book<float>(
+                        key_pool_dst_bf16cvt, bf16cvt_sz_);
+            }
+        }
+    };
+
+    nhwc_pooling_fwd_t(const pd_t *apd) : primitive_t(apd) {}
+
+    using data_t = typename prec_traits<d_type>::type;
+    using ker_data_t = typename prec_traits<data_type::f32>::type;
+
+    status_t init(engine_t *engine) override {
+        ref_post_ops_
+                = utils::make_unique<ref_post_ops_t>(pd()->attr()->post_ops_);
+        if (!ref_post_ops_) return status::out_of_memory;
+        CHECK(ref_post_ops_->init(pd()->dst_md()));
+        return status::success;
+    }
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_forward(ctx);
+    }
+
+private:
+    status_t execute_forward(const exec_ctx_t &ctx) const;
+    void array_div_by_const(const int n, const ker_data_t *src,
+            const size_t num, ker_data_t *dst) const;
+    void array_add(const int n, const ker_data_t *src, ker_data_t *dst) const;
+    void array_nhwc_max(const int n, ker_data_t *dst, const ker_data_t *src,
+            unsigned char *ws, const size_t ws_offset, const data_type_t ws_dt,
+            const int index) const;
+    void array_nhwc_initialize(const int n, ker_data_t *dst, unsigned char *ws,
+            const size_t ws_offset, const data_type_t ws_dt) const;
+
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+    std::unique_ptr<ref_post_ops_t> ref_post_ops_;
+};
+
+template <impl::data_type_t d_type>
+struct nhwc_pooling_bwd_t : public primitive_t {
+    struct pd_t : public cpu_pooling_bwd_pd_t {
+        using cpu_pooling_bwd_pd_t::cpu_pooling_bwd_pd_t;
+
+        DECLARE_COMMON_PD_T("simple_nhwc:any", nhwc_pooling_bwd_t);
+
+        status_t init(engine_t *engine) {
+            const format_tag_t desired_fmt_tag = utils::pick(ndims() - 3,
+                    format_tag::nwc, format_tag::nhwc, format_tag::ndhwc);
+
+            using namespace prop_kind;
+            using namespace alg_kind;
+            bool ok = !is_fwd()
+                    && utils::one_of(desc()->alg_kind, pooling_max,
+                            pooling_avg_include_padding,
+                            pooling_avg_exclude_padding)
+                    && utils::everyone_is(d_type, diff_dst_md()->data_type,
+                            diff_src_md()->data_type)
+                    && platform::has_data_type_support(d_type)
+                    && set_default_params() == status::success && !is_fwd()
+                    && attr()->has_default_values()
+                    && memory_desc_matches_tag(*diff_dst_md(), desired_fmt_tag)
+                    && memory_desc_matches_tag(*diff_src_md(), desired_fmt_tag)
+                    && !is_dilated();
+            if (!ok) return status::unimplemented;
+
+            if (desc()->alg_kind == pooling_max) {
+                const auto ws_dt = hint_fwd_pd_->workspace_md()->data_type;
+                init_default_ws(ws_dt);
+                if (!compare_ws(hint_fwd_pd_)) return status::unimplemented;
+            }
+
+            nthr_ = dnnl_get_max_threads();
+            init_scratchpad();
+
+            return status::success;
+        }
+
+        int nthr_; // To not exceed the limit in execute used for set up.
+
+    private:
+        void init_scratchpad() {
+            using namespace memory_tracking::names;
+            if (diff_src_md()->data_type != data_type::f32) {
+                size_t bf16cvt_sz_ = IC() * nthr_;
+                auto scratchpad = scratchpad_registry().registrar();
+                scratchpad.template book<float>(
+                        key_pool_src_bf16cvt, bf16cvt_sz_);
+                scratchpad.template book<float>(
+                        key_pool_dst_bf16cvt, bf16cvt_sz_);
+            }
+        }
+    };
+
+    nhwc_pooling_bwd_t(const pd_t *apd) : primitive_t(apd) {}
+    typedef typename prec_traits<d_type>::type data_t;
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_backward(ctx);
+    }
+
+private:
+    status_t execute_backward(const exec_ctx_t &ctx) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+};
+
+} // namespace cpu
+} // 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/cpu/nspc_batch_normalization.hpp

@@ -0,0 +1,206 @@
+/*******************************************************************************
+* Copyright 2018-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 CPU_NSPC_BATCH_NORMALIZATION_HPP
+#define CPU_NSPC_BATCH_NORMALIZATION_HPP
+
+#include <assert.h>
+
+#include "common/c_types_map.hpp"
+#include "common/dnnl_thread.hpp"
+#include "common/memory_tracking.hpp"
+#include "common/primitive.hpp"
+#include "common/type_helpers.hpp"
+#include "common/utils.hpp"
+
+#include "cpu/cpu_batch_normalization_pd.hpp"
+#include "cpu/platform.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+template <data_type_t d_type>
+struct nspc_batch_normalization_fwd_t : public primitive_t {
+    struct pd_t : public cpu_batch_normalization_fwd_pd_t {
+        pd_t(const batch_normalization_desc_t *adesc,
+                const primitive_attr_t *attr,
+                const batch_normalization_fwd_pd_t *hint_fwd_pd)
+            : cpu_batch_normalization_fwd_pd_t(adesc, attr, hint_fwd_pd) {}
+
+        DECLARE_COMMON_PD_T("nspc_bnorm:any", nspc_batch_normalization_fwd_t);
+
+        status_t init(engine_t *engine) {
+            using namespace data_type;
+            using namespace format_tag;
+
+            bool ok = is_fwd() && !has_zero_dim_memory()
+                    && utils::everyone_is(
+                            d_type, src_md()->data_type, dst_md()->data_type)
+                    && platform::has_data_type_support(d_type)
+                    && IMPLICATION(is_training(),
+                            platform::has_training_support(d_type))
+                    && check_scale_shift_data_type()
+                    && (attr()->has_default_values()
+                            || with_relu_post_op(is_training()))
+                    && set_default_formats_common()
+                    && memory_desc_wrapper(src_md())
+                            == memory_desc_wrapper(dst_md())
+                    && memory_desc_matches_one_of_tag(
+                            *src_md(), ndhwc, nhwc, nwc, nc);
+            if (!ok) return status::unimplemented;
+
+            // BN+Add+Relu fusion is not currently implemented
+            if (fuse_norm_add_relu()) return status::unimplemented;
+
+            if (is_training() && fuse_norm_relu()) init_default_ws(8);
+
+            nthr_ = dnnl_get_max_threads();
+            init_scratchpad();
+
+            return status::success;
+        }
+
+        int nthr_; // To not exceed the limit in execute used for set up.
+
+    private:
+        void init_scratchpad() {
+            using namespace memory_tracking::names;
+            using namespace data_type;
+
+            auto scratchpad = scratchpad_registry().registrar();
+            if (!stats_is_src()) {
+                const size_t stats_buf_sz = nstl::max(C(), dim_t(16)) * nthr_;
+                scratchpad.template book<acc_data_t>(
+                        key_bnorm_reduction, stats_buf_sz);
+                scratchpad.template book<acc_data_t>(
+                        key_bnorm_tmp_mean, stats_buf_sz);
+                scratchpad.template book<acc_data_t>(
+                        key_bnorm_tmp_var, stats_buf_sz);
+            }
+            if (utils::one_of(d_type, bf16, f16)) {
+                const int simd_w = 16;
+                const int nbufs = 2;
+                const size_t cvt_buf_sz
+                        = nbufs * nthr_ * utils::rnd_up(C(), simd_w);
+                scratchpad.template book<acc_data_t>(key_bnorm_cvt, cvt_buf_sz);
+            }
+        }
+    };
+
+    typedef typename prec_traits<d_type>::type data_t;
+    typedef float acc_data_t;
+
+    nspc_batch_normalization_fwd_t(const pd_t *apd) : primitive_t(apd) {}
+    ~nspc_batch_normalization_fwd_t() {}
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_forward(ctx);
+    }
+
+private:
+    status_t execute_forward(const exec_ctx_t &ctx) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+};
+
+template <data_type_t d_type>
+struct nspc_batch_normalization_bwd_t : public primitive_t {
+    struct pd_t : public cpu_batch_normalization_bwd_pd_t {
+        pd_t(const batch_normalization_desc_t *adesc,
+                const primitive_attr_t *attr,
+                const batch_normalization_fwd_pd_t *hint_fwd_pd)
+            : cpu_batch_normalization_bwd_pd_t(adesc, attr, hint_fwd_pd) {}
+
+        DECLARE_COMMON_PD_T("nspc_bnorm:any", nspc_batch_normalization_bwd_t);
+
+        status_t init(engine_t *engine) {
+            using namespace data_type;
+            using namespace format_tag;
+
+            bool ok = !is_fwd() && !has_zero_dim_memory()
+                    && utils::everyone_is(d_type, src_md()->data_type,
+                            diff_dst_md()->data_type, diff_src_md()->data_type)
+                    && platform::has_data_type_support(d_type)
+                    && platform::has_training_support(d_type)
+                    && check_scale_shift_data_type()
+                    && attr()->has_default_values()
+                    && set_default_formats_common()
+                    && memory_desc_wrapper(diff_src_md())
+                            == memory_desc_wrapper(diff_dst_md())
+                    && memory_desc_matches_one_of_tag(
+                            *src_md(), ndhwc, nhwc, nwc, nc)
+                    && memory_desc_matches_one_of_tag(
+                            *diff_src_md(), ndhwc, nhwc, nwc, nc);
+            if (!ok) return status::unimplemented;
+
+            // BN+Add+Relu fusion is not currently implemented
+            if (fuse_norm_add_relu()) return status::unimplemented;
+
+            if (fuse_norm_relu()) {
+                init_default_ws(8);
+                if (!compare_ws(hint_fwd_pd_)) return status::unimplemented;
+            }
+
+            nthr_ = dnnl_get_max_threads();
+            init_scratchpad();
+
+            return status::success;
+        }
+
+        int nthr_; // To not exceed the limit in execute used for set up.
+
+    private:
+        void init_scratchpad() {
+            using namespace memory_tracking::names;
+            using namespace data_type;
+
+            auto scratchpad = scratchpad_registry().registrar();
+            scratchpad.template book<acc_data_t>(
+                    key_bnorm_reduction, 2 * C() * nthr_);
+            scratchpad.template book<acc_data_t>(
+                    key_bnorm_tmp_diff_ss, 2 * C() * (nthr_ + 1));
+            if (utils::one_of(d_type, bf16, f16)) {
+                const int simd_w = 16;
+                const int nbufs = 2 + !use_global_stats();
+                const size_t cvt_buf_sz
+                        = nbufs * nthr_ * utils::rnd_up(C(), simd_w);
+                scratchpad.template book<acc_data_t>(key_bnorm_cvt, cvt_buf_sz);
+            }
+        }
+    };
+
+    typedef typename prec_traits<d_type>::type data_t;
+    typedef float acc_data_t;
+
+    nspc_batch_normalization_bwd_t(const pd_t *apd) : primitive_t(apd) {}
+    ~nspc_batch_normalization_bwd_t() {}
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_backward(ctx);
+    }
+
+private:
+    status_t execute_backward(const exec_ctx_t &ctx) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+};
+
+} // namespace cpu
+} // 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/cpu/platform.hpp

@@ -0,0 +1,197 @@
+/*******************************************************************************
+* Copyright 2020-2023 Intel Corporation
+* Copyright 2020 Arm Ltd. and affiliates
+*
+* 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 CPU_PLATFORM_HPP
+#define CPU_PLATFORM_HPP
+
+#include "oneapi/dnnl/dnnl_config.h"
+
+#include "common/c_types_map.hpp"
+#include "common/impl_registration.hpp"
+#include "common/z_magic.hpp"
+
+// Possible architectures:
+// - DNNL_X64
+// - DNNL_AARCH64
+// - DNNL_PPC64
+// - DNNL_S390X
+// - DNNL_RV64
+// - DNNL_ARCH_GENERIC
+// Target architecture macro is set to 1, others to 0. All macros are defined.
+
+#if defined(DNNL_X64) + defined(DNNL_AARCH64) + defined(DNNL_PPC64) \
+                + defined(DNNL_S390X) + defined(DNNL_RV64) \
+                + defined(DNNL_ARCH_GENERIC) \
+        == 0
+#if defined(__x86_64__) || defined(_M_X64)
+#define DNNL_X64 1
+#elif defined(__aarch64__)
+#define DNNL_AARCH64 1
+#elif defined(__powerpc64__) || defined(__PPC64__) || defined(_ARCH_PPC64)
+#define DNNL_PPC64 1
+#elif defined(__s390x__)
+#define DNNL_S390X 1
+#elif defined(__riscv)
+#define DNNL_RV64 1
+#else
+#define DNNL_ARCH_GENERIC 1
+#endif
+#endif // defined(DNNL_X64) + ... == 0
+
+#if defined(DNNL_X64) + defined(DNNL_AARCH64) + defined(DNNL_PPC64) \
+                + defined(DNNL_S390X) + defined(DNNL_RV64) \
+                + defined(DNNL_ARCH_GENERIC) \
+        != 1
+#error One and only one architecture should be defined at a time
+#endif
+
+#if !defined(DNNL_X64)
+#define DNNL_X64 0
+#endif
+#if !defined(DNNL_AARCH64)
+#define DNNL_AARCH64 0
+#endif
+#if !defined(DNNL_PPC64)
+#define DNNL_PPC64 0
+#endif
+#if !defined(DNNL_S390X)
+#define DNNL_S390X 0
+#endif
+#if !defined(DNNL_RV64)
+#define DNNL_RV64 0
+#endif
+#if !defined(DNNL_ARCH_GENERIC)
+#define DNNL_ARCH_GENERIC 0
+#endif
+
+// Helper macros: expand the parameters only on the corresponding architecture.
+// Equivalent to: #if DNNL_$ARCH ... #endif
+#define DNNL_X64_ONLY(...) Z_CONDITIONAL_DO(DNNL_X64, __VA_ARGS__)
+#define DNNL_PPC64_ONLY(...) Z_CONDITIONAL_DO(DNNL_PPC64_ONLY, __VA_ARGS__)
+#define DNNL_S390X_ONLY(...) Z_CONDITIONAL_DO(DNNL_S390X_ONLY, __VA_ARGS__)
+#define DNNL_AARCH64_ONLY(...) Z_CONDITIONAL_DO(DNNL_AARCH64, __VA_ARGS__)
+
+// Using RISC-V implementations optimized with RVV Intrinsics is optional for RISC-V builds
+// and can be enabled with DNNL_ARCH_OPT_FLAGS="-march=<ISA-string>" option, where <ISA-string>
+// contains V extension. If disabled, generic reference implementations will be used.
+#if defined(DNNL_RV64) && defined(DNNL_RISCV_USE_RVV_INTRINSICS)
+#define DNNL_RV64GCV_ONLY(...) __VA_ARGS__
+#else
+#define DNNL_RV64GCV_ONLY(...)
+#endif
+
+// Negation of the helper macros above
+#define DNNL_NON_X64_ONLY(...) Z_CONDITIONAL_DO(Z_NOT(DNNL_X64), __VA_ARGS__)
+
+// Using Arm Compute Library kernels is optional for AArch64 builds
+// and can be enabled with the DNNL_AARCH64_USE_ACL CMake option
+#if defined(DNNL_AARCH64) && defined(DNNL_AARCH64_USE_ACL)
+#define DNNL_AARCH64_ACL_ONLY(...) __VA_ARGS__
+#else
+#define DNNL_AARCH64_ACL_ONLY(...)
+#endif
+
+// Primitive ISA section for configuring knobs.
+// Note: MSVC preprocessor by some reason "eats" symbols it's not supposed to
+// if __VA_ARGS__ is passed as empty. Then things happen like this for non-x64:
+// impl0, AMX(X64_impl1), impl2, ... -> impl0   impl2, ...
+// resulting in compilation error. Such problem happens for lists interleaving
+// X64 impls and non-X64 for non-X64 build.
+#if DNNL_X64
+// Note: unlike workload or primitive set, these macros will work with impl
+// items directly, thus, just make an item disappear, no empty lists.
+#define __BUILD_AMX BUILD_PRIMITIVE_CPU_ISA_ALL || BUILD_AMX
+#define __BUILD_AVX512 __BUILD_AMX || BUILD_AVX512
+#define __BUILD_AVX2 __BUILD_AVX512 || BUILD_AVX2
+#define __BUILD_SSE41 __BUILD_AVX2 || BUILD_SSE41
+#else
+#define __BUILD_AMX 0
+#define __BUILD_AVX512 0
+#define __BUILD_AVX2 0
+#define __BUILD_SSE41 0
+#endif
+
+#if __BUILD_AMX
+#define REG_AMX_ISA(...) __VA_ARGS__
+#else
+#define REG_AMX_ISA(...)
+#endif
+
+#if __BUILD_AVX512
+#define REG_AVX512_ISA(...) __VA_ARGS__
+#else
+#define REG_AVX512_ISA(...)
+#endif
+
+#if __BUILD_AVX2
+#define REG_AVX2_ISA(...) __VA_ARGS__
+#else
+#define REG_AVX2_ISA(...)
+#endif
+
+#if __BUILD_SSE41
+#define REG_SSE41_ISA(...) __VA_ARGS__
+#else
+#define REG_SSE41_ISA(...)
+#endif
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+namespace platform {
+
+const char *get_isa_info();
+dnnl_cpu_isa_t get_effective_cpu_isa();
+status_t set_max_cpu_isa(dnnl_cpu_isa_t isa);
+status_t set_cpu_isa_hints(dnnl_cpu_isa_hints_t isa_hints);
+dnnl_cpu_isa_hints_t get_cpu_isa_hints();
+
+bool DNNL_API prefer_ymm_requested();
+// This call is limited to performing checks on plain C-code implementations
+// (e.g. 'ref' and 'simple_primitive') and should avoid any x64 JIT
+// implementations since these require specific code-path updates.
+bool DNNL_API has_data_type_support(data_type_t data_type);
+bool DNNL_API has_training_support(data_type_t data_type);
+float DNNL_API s8s8_weights_scale_factor();
+
+unsigned DNNL_API get_per_core_cache_size(int level);
+unsigned DNNL_API get_num_cores();
+#if DNNL_CPU_THREADING_RUNTIME == DNNL_RUNTIME_THREADPOOL
+unsigned DNNL_API get_max_threads_to_use();
+#endif
+
+constexpr int get_cache_line_size() {
+    return 64;
+}
+
+int get_vector_register_size();
+
+size_t get_timestamp();
+
+} // namespace platform
+
+// XXX: find a better place for these values?
+enum {
+    PAGE_4K = 4096,
+    PAGE_2M = 2097152,
+};
+
+} // namespace cpu
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/cpu/primitive_attr_postops.hpp

@@ -0,0 +1,96 @@
+/*******************************************************************************
+* 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 CPU_PRIMITIVE_ATTR_POSTOPS_HPP
+#define CPU_PRIMITIVE_ATTR_POSTOPS_HPP
+
+#include <vector>
+
+#include "common/primitive.hpp"
+#include "common/primitive_attr.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+float compute_binary_scalar(alg_kind_t alg, float x, float y);
+float compute_eltwise_scalar_fwd(
+        const alg_kind_t alg, float s, float alpha, float beta);
+float compute_eltwise_scalar_bwd(
+        const alg_kind_t alg, float dd, float s, float alpha, float beta);
+
+struct ref_binary_scalar_t {
+    ref_binary_scalar_t(alg_kind_t alg);
+    ref_binary_scalar_t(const post_ops_t::entry_t::binary_t &binary);
+
+    float compute_scalar(float src0, float src1) const;
+
+private:
+    const alg_kind_t alg_;
+};
+
+struct ref_eltwise_scalar_fwd_t {
+    ref_eltwise_scalar_fwd_t(
+            alg_kind_t alg, float alpha, float beta, float scale);
+    ref_eltwise_scalar_fwd_t(const post_ops_t::entry_t::eltwise_t &eltwise);
+
+    float compute_scalar(float s) const;
+
+    const alg_kind_t alg_;
+    const float alpha_;
+    const float beta_;
+    const float scale_;
+};
+
+struct ref_post_ops_t {
+    struct args_t {
+        args_t() : dst_val(0.f), ctx(nullptr), l_offset(-1), dst_md(nullptr) {}
+
+        float dst_val; // sum arg
+        const exec_ctx_t *ctx; // binary arg
+        dim_t l_offset; // binary arg
+        const memory_desc_t *dst_md; // binary arg
+    };
+
+    ref_post_ops_t(const post_ops_t &po, bool skip_sum = false);
+
+    virtual ~ref_post_ops_t() = default;
+
+    status_t init(const memory_desc_t *dst_md);
+
+    void execute(float &res, const args_t &args = args_t()) const;
+
+    static bool primitive_kind_ok(const post_ops_t &po) {
+        using namespace primitive_kind;
+        return po.has_default_values({binary, eltwise, prelu, sum});
+    }
+
+private:
+    const post_ops_t &po_;
+    // some primitives for example gemm are able to perform sum postop itself,
+    // in such cases executing sum should be skipped
+    const bool skip_sum_;
+
+    std::vector<ref_eltwise_scalar_fwd_t> eltwise_po_;
+    std::vector<ref_binary_scalar_t> binary_po_;
+    std::vector<memory_desc_t> prelu_md_;
+};
+
+} // namespace cpu
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/cpu/ref_batch_normalization.hpp

@@ -0,0 +1,141 @@
+/*******************************************************************************
+* Copyright 2016-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 CPU_REF_BATCH_NORMALIZATION_HPP
+#define CPU_REF_BATCH_NORMALIZATION_HPP
+
+#include <assert.h>
+
+#include "common/c_types_map.hpp"
+#include "common/primitive.hpp"
+#include "common/type_helpers.hpp"
+#include "common/utils.hpp"
+
+#include "cpu/platform.hpp"
+
+#include "cpu/cpu_batch_normalization_pd.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+template <data_type_t d_type>
+struct ref_batch_normalization_fwd_t : public primitive_t {
+    struct pd_t : public cpu_batch_normalization_fwd_pd_t {
+        pd_t(const batch_normalization_desc_t *adesc,
+                const primitive_attr_t *attr,
+                const batch_normalization_fwd_pd_t *hint_fwd_pd)
+            : cpu_batch_normalization_fwd_pd_t(adesc, attr, hint_fwd_pd) {}
+
+        DECLARE_COMMON_PD_T("ref:any", ref_batch_normalization_fwd_t);
+
+        status_t init(engine_t *engine) {
+            using namespace data_type;
+            bool ok = is_fwd()
+                    && utils::everyone_is(
+                            d_type, src_md()->data_type, dst_md()->data_type)
+                    && platform::has_data_type_support(d_type)
+                    && IMPLICATION(is_training(),
+                            platform::has_training_support(d_type))
+                    && check_scale_shift_data_type()
+                    && (attr()->has_default_values()
+                            || with_relu_post_op(is_training()))
+                    && set_default_formats_common()
+                    && memory_desc_wrapper(src_md())
+                            == memory_desc_wrapper(dst_md());
+            if (!ok) return status::unimplemented;
+
+            // BN+Add+Relu fusion is not currently implemented
+            if (fuse_norm_add_relu()) return status::unimplemented;
+
+            if (src_md()->data_type == s8 && !stats_is_src())
+                return status::unimplemented;
+
+            if (is_training() && fuse_norm_relu()) init_default_ws(8);
+
+            return status::success;
+        }
+    };
+
+    ref_batch_normalization_fwd_t(const pd_t *apd) : primitive_t(apd) {}
+
+    typedef typename prec_traits<d_type>::type data_t;
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_forward(ctx);
+    }
+
+private:
+    status_t execute_forward(const exec_ctx_t &ctx) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+};
+
+template <data_type_t d_type>
+struct ref_batch_normalization_bwd_t : public primitive_t {
+    struct pd_t : public cpu_batch_normalization_bwd_pd_t {
+        pd_t(const batch_normalization_desc_t *adesc,
+                const primitive_attr_t *attr,
+                const batch_normalization_fwd_pd_t *hint_fwd_pd)
+            : cpu_batch_normalization_bwd_pd_t(adesc, attr, hint_fwd_pd) {}
+
+        DECLARE_COMMON_PD_T("ref:any", ref_batch_normalization_bwd_t);
+
+        status_t init(engine_t *engine) {
+            using namespace data_type;
+
+            bool ok = !is_fwd()
+                    && utils::everyone_is(d_type, src_md()->data_type,
+                            diff_dst_md()->data_type, diff_src_md()->data_type)
+                    && platform::has_data_type_support(d_type)
+                    && platform::has_training_support(d_type)
+                    && check_scale_shift_data_type()
+                    && attr()->has_default_values()
+                    && set_default_formats_common()
+                    && memory_desc_wrapper(diff_src_md())
+                            == memory_desc_wrapper(diff_dst_md());
+            if (!ok) return status::unimplemented;
+
+            // BN+Add+Relu fusion is not currently implemented
+            if (fuse_norm_add_relu()) return status::unimplemented;
+
+            if (fuse_norm_relu()) {
+                init_default_ws(8);
+                if (!compare_ws(hint_fwd_pd_)) return status::unimplemented;
+            }
+
+            return status::success;
+        }
+    };
+
+    ref_batch_normalization_bwd_t(const pd_t *apd) : primitive_t(apd) {}
+    typedef typename prec_traits<d_type>::type data_t;
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_backward(ctx);
+    }
+
+private:
+    status_t execute_backward(const exec_ctx_t &ctx) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+};
+
+} // namespace cpu
+} // 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/cpu/ref_binary.hpp

@@ -0,0 +1,94 @@
+/*******************************************************************************
+* 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 CPU_REF_BINARY_HPP
+#define CPU_REF_BINARY_HPP
+
+#include <assert.h>
+
+#include "common/c_types_map.hpp"
+#include "common/primitive.hpp"
+#include "common/type_helpers.hpp"
+#include "common/utils.hpp"
+
+#include "cpu/platform.hpp"
+#include "cpu/primitive_attr_postops.hpp"
+
+#include "cpu/cpu_binary_pd.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct ref_binary_t : public primitive_t {
+    struct pd_t : public cpu_binary_pd_t {
+        using cpu_binary_pd_t::cpu_binary_pd_t;
+
+        DECLARE_COMMON_PD_T("ref:any", ref_binary_t);
+
+        status_t init(engine_t *engine) {
+            using namespace data_type;
+            using sm = primitive_attr_t::skip_mask_t;
+
+            const bool ok
+                    = platform::has_data_type_support(src_md(0)->data_type)
+                    && platform::has_data_type_support(src_md(1)->data_type)
+                    && platform::has_data_type_support(dst_md()->data_type)
+                    && set_default_params() == status::success
+                    && attr()->has_default_values(
+                            sm::post_ops | sm::scales_runtime)
+                    && IMPLICATION(!attr()->scales_.has_default_values(),
+                            check_scales_mask())
+                    && ref_post_ops_t::primitive_kind_ok(attr()->post_ops_)
+                    && attr_.set_default_formats(dst_md(0)) == status::success;
+            if (!ok) return status::unimplemented;
+
+            return status::success;
+        }
+
+    private:
+        bool check_scales_mask() const {
+            const std::vector<int> supported_args
+                    = {DNNL_ARG_SRC_0, DNNL_ARG_SRC_1};
+            return attr_scales_ok(supported_args);
+        }
+    };
+
+    ref_binary_t(const pd_t *apd) : primitive_t(apd) {}
+
+    status_t init(engine_t *engine) override {
+        ref_post_ops
+                = utils::make_unique<ref_post_ops_t>(pd()->attr()->post_ops_);
+        if (!ref_post_ops) return status::out_of_memory;
+        CHECK(ref_post_ops->init(pd()->dst_md()));
+        return status::success;
+    }
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_ref(ctx);
+    }
+
+private:
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+    status_t execute_ref(const exec_ctx_t &ctx) const;
+    std::unique_ptr<ref_post_ops_t> ref_post_ops;
+};
+
+} // namespace cpu
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/cpu/ref_concat.hpp

@@ -0,0 +1,189 @@
+/*******************************************************************************
+* Copyright 2017-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 CPU_REF_CONCAT_HPP
+#define CPU_REF_CONCAT_HPP
+
+#include "common/engine.hpp"
+#include "common/primitive.hpp"
+#include "common/reorder.hpp"
+#include "common/reorder_pd.hpp"
+#include "common/stream.hpp"
+
+#include "cpu/cpu_concat_pd.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct ref_concat_t : public primitive_t {
+    struct pd_t : public cpu_concat_pd_t {
+        pd_t(const primitive_attr_t *attr, const memory_desc_t *dst_md, int n,
+                int concat_dim, const memory_desc_t *const *src_mds)
+            : cpu_concat_pd_t(attr, dst_md, n, concat_dim, src_mds)
+            , tent_dst_md_(types::zero_md()) {}
+        pd_t(const pd_t &rhs) = default;
+        ~pd_t() = default;
+
+        DECLARE_CONCAT_PD_T("ref:any", ref_concat_t);
+
+        status_t init(engine_t *engine) {
+            using sm = primitive_attr_t::skip_mask_t;
+            if (!attr()->has_default_values(sm::scales_runtime))
+                return status::unimplemented;
+            status_t status = cpu_concat_pd_t::init();
+            if (status != status::success) {
+                assert(dst_md_.format_kind != format_kind::undef);
+                status = memory_desc_init_by_strides(tent_dst_md_,
+                        dst_md_.ndims, dst_md_.dims, dst_md_.data_type,
+                        nullptr);
+                if (status != status::success) return status::unimplemented;
+
+                status = cpu_concat_pd_t::init(&tent_dst_md_);
+                if (status != status::success) return status::unimplemented;
+            }
+
+            const auto &sc = attr()->scales_;
+            reorder_pds_.resize(n_ + use_tent_dst());
+            for (int i = 0; i < n_; ++i) {
+                primitive_attr_t r_attr;
+                if (!sc.get(DNNL_ARG_MULTIPLE_SRC + i).has_default_values()) {
+                    int mask = 0;
+                    CHECK(sc.get(DNNL_ARG_MULTIPLE_SRC + i, &mask, nullptr));
+                    if (mask != 0) return status::unimplemented;
+                    r_attr.scales_.set(DNNL_ARG_SRC, mask);
+                }
+                CHECK(reorder_primitive_desc_create(reorder_pds_[i], engine,
+                        src_md(i), src_image_md(i), &r_attr));
+            }
+            if (use_tent_dst()) {
+                assert(tent_dst_md_.format_kind != format_kind::undef);
+                assert(dst_md_.format_kind != format_kind::undef);
+                CHECK(reorder_primitive_desc_create(
+                        reorder_pds_[n_], engine, &tent_dst_md_, &dst_md_));
+            }
+            init_scratchpad();
+            return status;
+        }
+
+        // if dst is forced and cannot be used directly.
+        bool use_tent_dst() const { return !types::is_zero_md(&tent_dst_md_); }
+
+        std::vector<std::shared_ptr<primitive_desc_t>> reorder_pds_;
+        memory_desc_t tent_dst_md_;
+
+    private:
+        void init_scratchpad() {
+            using namespace memory_tracking::names;
+            auto scratchpad = scratchpad_registry().registrar();
+            if (use_tent_dst()) {
+                const memory_desc_wrapper tent_dst_d(&tent_dst_md_);
+                scratchpad.book(memory_tracking::names::key_concat_tent_dst,
+                        tent_dst_d.size(), 1, tent_dst_d.data_type_size());
+            }
+
+            for (size_t i = 0; i < reorder_pds_.size(); i++) {
+                scratchpad.book(key_nested_multiple + (int)i,
+                        reorder_pds_[i]->scratchpad_registry());
+            }
+        }
+    };
+
+    ref_concat_t(const pd_t *apd) : primitive_t(apd) {}
+
+    status_t init(engine_t *engine) override {
+        const size_t n = pd()->reorder_pds_.size();
+        reorders_.resize(n);
+        for (size_t i = 0; i < n; ++i)
+            pd()->reorder_pds_[i]->create_primitive(reorders_[i], engine);
+        return status::success;
+    }
+
+    ~ref_concat_t() = default;
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        using namespace memory_tracking::names;
+        engine_t *engine = ctx.stream()->engine();
+        const auto n = pd()->n_inputs();
+
+        auto execute_reorder = [&](const std::shared_ptr<primitive_t> &reorder,
+                                       const memory_arg_t &src,
+                                       const memory_arg_t &dst,
+                                       const memory_arg_t *src_scales,
+                                       int r_num) {
+            exec_args_t r_args;
+            r_args[DNNL_ARG_SRC] = src;
+            r_args[DNNL_ARG_DST] = dst;
+            if (src_scales)
+                r_args[DNNL_ARG_ATTR_SCALES | DNNL_ARG_SRC] = *src_scales;
+            exec_ctx_t r_ctx(ctx, std::move(r_args));
+
+            nested_scratchpad_t ns(ctx, key_nested_multiple + r_num, reorder);
+            r_ctx.set_scratchpad_grantor(ns.grantor());
+            reorder->execute(r_ctx);
+        };
+
+        if (pd()->use_tent_dst()) {
+            using namespace memory_tracking::names;
+            auto scratchpad = ctx.get_scratchpad_grantor();
+            auto tent_dst_storage
+                    = scratchpad.get_memory_storage(key_concat_tent_dst);
+
+            for (int i = 0; i < n; ++i) {
+                memory_t tent_dst_i(engine, pd()->src_image_md(i),
+                        tent_dst_storage->clone());
+                const auto &src_scales_arg = ctx.args().find(
+                        DNNL_ARG_ATTR_SCALES | (DNNL_ARG_MULTIPLE_SRC + i));
+                const memory_arg_t *src_scales = nullptr;
+                if (src_scales_arg != ctx.args().end())
+                    src_scales = &src_scales_arg->second;
+                execute_reorder(reorders_[i],
+                        ctx.args().at(DNNL_ARG_MULTIPLE_SRC + i),
+                        {&tent_dst_i, false}, src_scales, i);
+            }
+
+            memory_t tent_dst(
+                    engine, &pd()->tent_dst_md_, tent_dst_storage->clone());
+            execute_reorder(reorders_[n], {&tent_dst, true},
+                    ctx.args().at(DNNL_ARG_DST), nullptr, n);
+        } else {
+            auto &dst_mem_storage = CTX_OUT_STORAGE(DNNL_ARG_DST);
+            for (int i = 0; i < n; ++i) {
+                memory_t tent_dst_i(
+                        engine, pd()->src_image_md(i), dst_mem_storage.clone());
+                const auto &src_scales_arg = ctx.args().find(
+                        DNNL_ARG_ATTR_SCALES | (DNNL_ARG_MULTIPLE_SRC + i));
+                const memory_arg_t *src_scales = nullptr;
+                if (src_scales_arg != ctx.args().end())
+                    src_scales = &src_scales_arg->second;
+                execute_reorder(reorders_[i],
+                        ctx.args().at(DNNL_ARG_MULTIPLE_SRC + i),
+                        {&tent_dst_i, false}, src_scales, i);
+            }
+        }
+        return status::success;
+    }
+
+private:
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+    std::vector<std::shared_ptr<primitive_t>> reorders_;
+};
+
+} // namespace cpu
+} // namespace impl
+} // namespace dnnl
+
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/cpu/ref_convolution.hpp

@@ -0,0 +1,203 @@
+/*******************************************************************************
+* 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 CPU_REF_CONVOLUTION_HPP
+#define CPU_REF_CONVOLUTION_HPP
+
+#include <assert.h>
+
+#include "common/c_types_map.hpp"
+#include "common/primitive.hpp"
+#include "common/type_helpers.hpp"
+#include "common/utils.hpp"
+
+#include "cpu/cpu_convolution_pd.hpp"
+#include "cpu/primitive_attr_postops.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct ref_convolution_fwd_t : public primitive_t {
+    struct pd_t : public cpu_convolution_fwd_pd_t {
+        using cpu_convolution_fwd_pd_t::cpu_convolution_fwd_pd_t;
+
+        DECLARE_COMMON_PD_T("ref:any", ref_convolution_fwd_t);
+
+        status_t init(engine_t *engine) {
+            using namespace data_type;
+            using smask_t = primitive_attr_t::skip_mask_t;
+            const auto src_type = src_md(0)->data_type;
+            const auto wei_type = weights_md(0)->data_type;
+            const auto bia_type = weights_md(1)->data_type;
+            const auto dst_type = dst_md(0)->data_type;
+
+            bool ok = is_fwd()
+                    && set_default_alg_kind(alg_kind::convolution_direct)
+                    && platform::has_data_type_support(src_type)
+                    && platform::has_data_type_support(bia_type)
+                    && platform::has_data_type_support(dst_type)
+                    && utils::one_of(src_type, f32, bf16, f16)
+                    && src_type == wei_type
+                    && utils::one_of(dst_type, src_type, f32)
+                    && utils::one_of(bia_type, data_type::undef, src_type, f32)
+                    && set_default_formats()
+                    && attr()->has_default_values(
+                            smask_t::post_ops | smask_t::sum_dt, dst_type)
+                    && attr()->post_ops_.check_sum_consistency(
+                            dst_type, /* is_int8 */ false)
+                    && post_ops_ok()
+                    && attr_.set_default_formats(dst_md(0)) == status::success;
+            return ok ? status::success : status::unimplemented;
+        }
+
+    protected:
+        bool set_default_formats() {
+            using namespace format_tag;
+            auto dat_tag = utils::pick(ndims() - 3, nwc, nhwc, ndhwc);
+            auto wei_tag = with_groups()
+                    ? utils::pick(ndims() - 3, goiw, goihw, goidhw)
+                    : utils::pick(ndims() - 3, oiw, oihw, oidhw);
+            return set_default_formats_common(dat_tag, wei_tag, dat_tag);
+        }
+
+        bool post_ops_ok() const {
+            return ref_post_ops_t::primitive_kind_ok(attr()->post_ops_);
+        }
+    };
+
+    ref_convolution_fwd_t(const pd_t *apd) : primitive_t(apd) {}
+
+    status_t init(engine_t *engine) override {
+        ref_post_ops
+                = utils::make_unique<ref_post_ops_t>(pd()->attr()->post_ops_);
+        if (!ref_post_ops) return status::out_of_memory;
+        CHECK(ref_post_ops->init(pd()->dst_md()));
+        return status::success;
+    }
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_forward(ctx);
+    }
+
+private:
+    status_t execute_forward(const exec_ctx_t &ctx) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+    std::unique_ptr<ref_post_ops_t> ref_post_ops;
+};
+
+struct ref_convolution_bwd_data_t : public primitive_t {
+    struct pd_t : public cpu_convolution_bwd_data_pd_t {
+        using cpu_convolution_bwd_data_pd_t::cpu_convolution_bwd_data_pd_t;
+
+        DECLARE_COMMON_PD_T("ref:any", ref_convolution_bwd_data_t);
+
+        status_t init(engine_t *engine) {
+            using namespace data_type;
+            const auto diff_src_type = diff_src_md(0)->data_type;
+            const auto wei_type = weights_md(0)->data_type;
+            const auto diff_dst_type = diff_dst_md(0)->data_type;
+
+            bool ok = desc()->prop_kind == prop_kind::backward_data
+                    && set_default_alg_kind(alg_kind::convolution_direct)
+                    && platform::has_data_type_support(diff_src_type)
+                    && platform::has_data_type_support(diff_dst_type)
+                    && utils::one_of(diff_dst_type, f32, bf16, f16)
+                    && wei_type == diff_dst_type
+                    && utils::one_of(diff_src_type, f32, diff_dst_type)
+                    && set_default_formats() && attr()->has_default_values();
+
+            return ok ? status::success : status::unimplemented;
+        }
+
+    protected:
+        bool set_default_formats() {
+            using namespace format_tag;
+            auto dat_tag = utils::pick(ndims() - 3, nwc, nhwc, ndhwc);
+            auto wei_tag = with_groups()
+                    ? utils::pick(ndims() - 3, goiw, goihw, goidhw)
+                    : utils::pick(ndims() - 3, oiw, oihw, oidhw);
+            return set_default_formats_common(dat_tag, wei_tag, dat_tag);
+        }
+    };
+
+    ref_convolution_bwd_data_t(const pd_t *apd) : primitive_t(apd) {}
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_backward_data(ctx);
+    }
+
+private:
+    status_t execute_backward_data(const exec_ctx_t &ctx) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+};
+
+struct ref_convolution_bwd_weights_t : public primitive_t {
+    struct pd_t : public cpu_convolution_bwd_weights_pd_t {
+        using cpu_convolution_bwd_weights_pd_t::
+                cpu_convolution_bwd_weights_pd_t;
+
+        DECLARE_COMMON_PD_T("ref:any", ref_convolution_bwd_weights_t);
+
+        status_t init(engine_t *engine) {
+            using namespace data_type;
+            const auto src_type = src_md(0)->data_type;
+            const auto diff_wei_type = diff_weights_md(0)->data_type;
+            const auto diff_bia_type = diff_weights_md(1)->data_type;
+            const auto diff_dst_type = diff_dst_md(0)->data_type;
+
+            bool ok = desc()->prop_kind == prop_kind::backward_weights
+                    && set_default_alg_kind(alg_kind::convolution_direct)
+                    && platform::has_data_type_support(src_type)
+                    && platform::has_data_type_support(diff_wei_type)
+                    && utils::one_of(src_type, f32, bf16, f16)
+                    && diff_dst_type == src_type
+                    && utils::one_of(diff_wei_type, f32, src_type)
+                    && utils::one_of(
+                            diff_bia_type, data_type::undef, f32, src_type)
+                    && set_default_formats() && attr()->has_default_values();
+            return ok ? status::success : status::unimplemented;
+        }
+
+    protected:
+        bool set_default_formats() {
+            using namespace format_tag;
+            auto dat_tag = utils::pick(ndims() - 3, ncw, nchw, ncdhw);
+            auto wei_tag = with_groups()
+                    ? utils::pick(ndims() - 3, goiw, goihw, goidhw)
+                    : utils::pick(ndims() - 3, oiw, oihw, oidhw);
+            return set_default_formats_common(dat_tag, wei_tag, dat_tag);
+        }
+    };
+
+    ref_convolution_bwd_weights_t(const pd_t *apd) : primitive_t(apd) {}
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_backward_weights(ctx);
+    }
+
+private:
+    status_t execute_backward_weights(const exec_ctx_t &ctx) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+};
+
+} // namespace cpu
+} // 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/cpu/ref_convolution_int8.hpp

@@ -0,0 +1,163 @@
+/*******************************************************************************
+* 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 CPU_REF_CONVOLUTION_INT8_HPP
+#define CPU_REF_CONVOLUTION_INT8_HPP
+
+#include <assert.h>
+
+#include "common/c_types_map.hpp"
+#include "common/primitive.hpp"
+#include "common/type_helpers.hpp"
+#include "common/utils.hpp"
+
+#include "cpu/cpu_convolution_pd.hpp"
+#include "cpu/primitive_attr_postops.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct ref_convolution_int8_fwd_t : public primitive_t {
+    struct pd_t : public cpu_convolution_fwd_pd_t {
+        using cpu_convolution_fwd_pd_t::cpu_convolution_fwd_pd_t;
+
+        DECLARE_COMMON_PD_T("ref:any", ref_convolution_int8_fwd_t);
+
+        status_t init(engine_t *engine) {
+            using namespace data_type;
+            using smask_t = primitive_attr_t::skip_mask_t;
+            const auto src_type = src_md(0)->data_type;
+            const auto wei_type = weights_md(0)->data_type;
+            const auto bia_type = weights_md(1)->data_type;
+            const auto dst_type = dst_md(0)->data_type;
+
+            bool ok = is_fwd()
+                    && set_default_alg_kind(alg_kind::convolution_direct)
+                    && utils::one_of(src_type, s8, u8) && wei_type == s8
+                    && IMPLICATION(with_bias(),
+                            utils::one_of(bia_type, f32, bf16, s32, s8, u8))
+                    && utils::one_of(dst_type, f32, bf16, s32, s8, u8)
+                    && set_default_formats()
+                    && attr()->has_default_values(smask_t::scales_runtime
+                                    | smask_t::zero_points_runtime
+                                    | smask_t::post_ops | smask_t::sum_dt,
+                            dst_type)
+                    && attr()->post_ops_.check_sum_consistency(dst_type,
+                            /* is_int8 */ true)
+                    && attr_scales_ok() && zero_points_ok() && post_ops_ok()
+                    && attr_.set_default_formats(dst_md(0)) == status::success;
+            return ok ? status::success : status::unimplemented;
+        }
+
+    protected:
+        bool set_default_formats() {
+            using namespace format_tag;
+            auto dat_tag = utils::pick(ndims() - 3, nwc, nhwc, ndhwc);
+            auto wei_tag = with_groups()
+                    ? utils::pick(ndims() - 3, goiw, goihw, goidhw)
+                    : utils::pick(ndims() - 3, oiw, oihw, oidhw);
+            return set_default_formats_common(dat_tag, wei_tag, dat_tag);
+        }
+
+        bool zero_points_ok() const {
+            int mask_src = 0, mask_dst = 0;
+            attr()->zero_points_.get(DNNL_ARG_SRC, &mask_src);
+            attr()->zero_points_.get(DNNL_ARG_DST, &mask_dst);
+
+            return attr()->zero_points_.has_default_values(DNNL_ARG_WEIGHTS)
+                    && (mask_src == 0 || mask_src == 1 << 1)
+                    && (mask_dst == 0 || mask_dst == 1 << 1);
+        }
+
+        bool post_ops_ok() const {
+            return ref_post_ops_t::primitive_kind_ok(attr()->post_ops_);
+        }
+    };
+
+    ref_convolution_int8_fwd_t(const pd_t *apd) : primitive_t(apd) {}
+
+    status_t init(engine_t *engine) override {
+        ref_post_ops
+                = utils::make_unique<ref_post_ops_t>(pd()->attr()->post_ops_);
+        if (!ref_post_ops) return status::out_of_memory;
+        CHECK(ref_post_ops->init(pd()->dst_md()));
+        return status::success;
+    }
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_forward(ctx);
+    }
+
+private:
+    status_t execute_forward(const exec_ctx_t &ctx) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+    std::unique_ptr<ref_post_ops_t> ref_post_ops;
+};
+
+struct ref_convolution_int8_bwd_data_t : public primitive_t {
+    struct pd_t : public cpu_convolution_bwd_data_pd_t {
+        using cpu_convolution_bwd_data_pd_t::cpu_convolution_bwd_data_pd_t;
+
+        DECLARE_COMMON_PD_T("ref:any", ref_convolution_int8_bwd_data_t);
+
+        status_t init(engine_t *engine) {
+            using namespace data_type;
+            const auto diff_src_type = diff_src_md(0)->data_type;
+            const auto wei_type = weights_md(0)->data_type;
+            const auto diff_dst_type = diff_dst_md(0)->data_type;
+
+            bool ok = desc()->prop_kind == prop_kind::backward_data
+                    && set_default_alg_kind(alg_kind::convolution_direct)
+                    && utils::one_of(diff_dst_type, s8, u8) && wei_type == s8
+                    && utils::one_of(diff_src_type, f32, bf16, s32, s8, u8)
+                    && set_default_formats()
+                    && attr()->has_default_values(
+                            primitive_attr_t::skip_mask_t::scales_runtime)
+                    && attr_scales_ok();
+
+            return ok ? status::success : status::unimplemented;
+        }
+
+    protected:
+        bool set_default_formats() {
+            using namespace format_tag;
+            auto dat_tag = utils::pick(ndims() - 3, nwc, nhwc, ndhwc);
+            auto wei_tag = with_groups()
+                    ? utils::pick(ndims() - 3, goiw, goihw, goidhw)
+                    : utils::pick(ndims() - 3, oiw, oihw, oidhw);
+            return set_default_formats_common(dat_tag, wei_tag, dat_tag);
+        }
+    };
+
+    ref_convolution_int8_bwd_data_t(const pd_t *apd) : primitive_t(apd) {}
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_backward_data(ctx);
+    }
+
+private:
+    status_t execute_backward_data(const exec_ctx_t &ctx) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+};
+
+} // namespace cpu
+} // 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/cpu/ref_convolution_utils.hpp

@@ -0,0 +1,67 @@
+/*******************************************************************************
+* 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 CPU_REF_CONVOLUTION_UTILS_HPP
+#define CPU_REF_CONVOLUTION_UTILS_HPP
+
+#include <assert.h>
+
+#include "common/c_types_map.hpp"
+#include "common/primitive.hpp"
+#include "common/type_helpers.hpp"
+#include "common/utils.hpp"
+
+#include "cpu/cpu_convolution_pd.hpp"
+#include "cpu/primitive_attr_postops.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+namespace ref_conv_utils {
+inline dim_t get_data_off(const memory_desc_wrapper &mdw, int ndims, dim_t mb,
+        dim_t c, dim_t id, dim_t ih, dim_t iw) {
+    switch (ndims) {
+        case 5: return mdw.off(mb, c, id, ih, iw);
+        case 4: return mdw.off(mb, c, ih, iw);
+        case 3: return mdw.off(mb, c, iw);
+        default: assert(!"unsupported ndims"); return dim_t(0);
+    }
+}
+
+inline dim_t get_weights_off(const memory_desc_wrapper &mdw, bool with_groups,
+        int ndims, dim_t g, dim_t oc, dim_t ic, dim_t kd, dim_t kh, dim_t kw) {
+    switch (ndims) {
+        case 5:
+            return with_groups ? mdw.off(g, oc, ic, kd, kh, kw)
+                               : mdw.off(oc, ic, kd, kh, kw);
+        case 4:
+            return with_groups ? mdw.off(g, oc, ic, kh, kw)
+                               : mdw.off(oc, ic, kh, kw);
+        case 3:
+            return with_groups ? mdw.off(g, oc, ic, kw) : mdw.off(oc, ic, kw);
+        default: assert(!"unsupported ndims"); return dim_t(0);
+    }
+}
+} // namespace ref_conv_utils
+
+} // namespace cpu
+} // 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/cpu/ref_deconvolution.hpp

@@ -0,0 +1,554 @@
+/*******************************************************************************
+* Copyright 2018-2023 Intel Corporation
+* Copyright 2022 Arm Ltd. and affiliates
+*
+* 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 CPU_REF_DECONVOLUTION_HPP
+#define CPU_REF_DECONVOLUTION_HPP
+
+#include <assert.h>
+#include <string.h>
+
+#include "common/c_types_map.hpp"
+#include "common/primitive.hpp"
+#include "common/primitive_desc_iterator.hpp"
+#include "common/stream.hpp"
+#include "common/type_helpers.hpp"
+#include "common/utils.hpp"
+
+#include "cpu/primitive_attr_postops.hpp"
+
+#include "cpu/cpu_convolution_pd.hpp"
+#include "cpu/cpu_deconvolution_pd.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+static status_t weights_axes_permutation(
+        memory_desc_t *o_md, const memory_desc_t *i_md, bool with_groups) {
+    int perm[DNNL_MAX_NDIMS] {}; // deconv to conv weight permutation
+    for (int d = 0; d < DNNL_MAX_NDIMS; ++d)
+        perm[d] = d;
+    nstl::swap(perm[0 + with_groups], perm[1 + with_groups]);
+
+    return memory_desc_permute_axes(*o_md, *i_md, perm);
+}
+
+static status_t conv_descr_create(const deconvolution_desc_t *dd,
+        convolution_desc_t *cd, const memory_desc_t *bias_md = nullptr,
+        data_type_t src_dt = data_type::undef) {
+    using namespace prop_kind;
+    alg_kind_t alg_kind = dd->alg_kind == alg_kind::deconvolution_direct
+            ? alg_kind::convolution_direct
+            : alg_kind::convolution_winograd;
+
+    const memory_desc_t *src_md, *dst_md, *d_weights_d;
+    memory_desc_t src_md_patched;
+    prop_kind_t prop_kind;
+
+    if (utils::one_of(dd->prop_kind, forward_training, forward_inference)) {
+        prop_kind = backward_data;
+        assert(src_dt != data_type::undef);
+        CHECK(memory_desc_init_by_md_and_dt(
+                src_md_patched, dd->dst_desc, src_dt));
+        src_md = &src_md_patched;
+        dst_md = &dd->src_desc;
+        d_weights_d = &dd->weights_desc;
+    } else if (dd->prop_kind == backward_data) {
+        assert(src_dt == data_type::undef);
+        prop_kind = forward_training;
+        src_md = &dd->diff_dst_desc;
+        dst_md = &dd->diff_src_desc;
+        d_weights_d = &dd->weights_desc;
+    } else {
+        assert(src_dt == data_type::undef);
+        prop_kind = dd->prop_kind;
+        src_md = &dd->diff_dst_desc;
+        dst_md = &dd->src_desc;
+        d_weights_d = &dd->diff_weights_desc;
+    }
+
+    /* create weights desc for convolution */
+    memory_desc_t c_weights_d;
+    const bool with_groups = d_weights_d->ndims == src_md->ndims + 1;
+    CHECK(weights_axes_permutation(&c_weights_d, d_weights_d, with_groups));
+
+    return conv_desc_init(cd, prop_kind, alg_kind, src_md, &c_weights_d,
+            bias_md, dst_md, dd->strides, dd->dilates, dd->padding[0],
+            dd->padding[1]);
+}
+
+struct ref_deconvolution_fwd_t : public primitive_t {
+    struct pd_t : public cpu_deconvolution_fwd_pd_t {
+        pd_t(const deconvolution_desc_t *adesc, const primitive_attr_t *attr,
+                const deconvolution_fwd_pd_t *hint_fwd_pd)
+            : cpu_deconvolution_fwd_pd_t(adesc, attr, hint_fwd_pd) {}
+
+        pd_t(const pd_t &other)
+            : cpu_deconvolution_fwd_pd_t(other)
+            , conv_pd_(other.conv_pd_->clone())
+            , conv_supports_bias_(other.conv_supports_bias_)
+            , dst_tag_(other.dst_tag_)
+            , name_(other.name_) {}
+
+        ~pd_t() = default;
+
+        DECLARE_COMMON_PD_T(name_.c_str(), ref_deconvolution_fwd_t);
+
+        status_t init_convolution(engine_t *engine) {
+            using namespace format_tag;
+            using namespace data_type;
+
+            // Create empty attributes for bwd_d conv to pick up the fastest
+            // impl available and apply post-ops and/or bias update later in
+            // this impl via simple loop.
+            primitive_attr_t conv_attr;
+
+            convolution_desc_t cd;
+            // When no attributes were requested, try to find a bwd_d conv impl
+            // which supports bias update in-place, if requested, in requested
+            // dst_dt. If appropriate conv impl was not found, enforce f32
+            // diff_src for conv for correct result. If attributes are
+            // requested, enforce conv impl to return f32 output no matter what.
+            if (attr()->has_default_values()) {
+                CHECK(conv_descr_create(
+                        desc(), &cd, weights_md(1), dst_md()->data_type));
+                primitive_desc_iterator_t it(
+                        engine, (op_desc_t *)&cd, &conv_attr, nullptr);
+                if (!it.is_initialized()) return status::out_of_memory;
+
+                while (++it != it.end()) {
+                    conv_pd_ = *it;
+                    if (with_bias()) {
+                        conv_supports_bias_ = utils::downcast<
+                                cpu_convolution_bwd_data_pd_t *>(conv_pd_.get())
+                                                      ->support_bias();
+                        if (!conv_supports_bias_) continue;
+                    }
+                    bool ok = conv_pd_->weights_md()->extra.flags == 0;
+                    if (ok) return status::success;
+                }
+            }
+
+            // Intermediate f32 buffer is supported only for given condition.
+            if (!attr()->has_default_values() || with_bias()) {
+                // Enforce f32 dt for diff src and work with f32 output for bias
+                // update or post ops after conv execution.
+                CHECK(conv_descr_create(desc(), &cd, nullptr, data_type::f32));
+                primitive_desc_iterator_t it(
+                        engine, (op_desc_t *)&cd, &conv_attr, nullptr);
+                if (!it.is_initialized()) return status::out_of_memory;
+
+                while (++it != it.end()) {
+                    conv_pd_ = *it;
+                    bool ok = conv_pd_->weights_md()->extra.flags == 0;
+                    if (ok) return status::success;
+                }
+            }
+            return status::unimplemented;
+        }
+
+        status_t init(engine_t *engine) {
+            using namespace format_tag;
+            using namespace data_type;
+            using smask_t = primitive_attr_t::skip_mask_t;
+            auto skip_mask = smask_t::post_ops | smask_t::sum_dt;
+            if (utils::one_of(desc()->src_desc.data_type, s8, u8))
+                skip_mask |= smask_t::scales_runtime
+                        | smask_t::zero_points_runtime;
+
+            const bool ok = is_fwd()
+                    && utils::one_of(desc()->alg_kind,
+                            alg_kind::deconvolution_direct,
+                            alg_kind::deconvolution_winograd)
+                    && attr()->has_default_values(skip_mask) && attr_scales_ok()
+                    && post_ops_ok() && zero_points_ok();
+            if (!ok) return status::unimplemented;
+
+            CHECK(init_convolution(engine));
+
+            if (weights_md_.format_kind == format_kind::any)
+                CHECK(weights_axes_permutation(
+                        &weights_md_, conv_pd_->weights_md(), with_groups()));
+            if (src_md_.format_kind == format_kind::any)
+                src_md_ = *conv_pd_->diff_dst_md();
+            if (dst_md_.format_kind == format_kind::any) {
+                // re-apply dt manually since it could be changed due to bias
+                const auto dst_dt = dst_md_.data_type;
+                memory_desc_init_by_md_and_dt(
+                        dst_md_, *conv_pd_->diff_src_md(), dst_dt);
+            }
+            if (bias_md_.format_kind == format_kind::any)
+                CHECK(memory_desc_init_by_tag(bias_md_, x));
+
+            dst_tag_ = memory_desc_matches_one_of_tag(dst_md_,
+                    utils::pick(ndims() - 3, ncw, nchw, ncdhw),
+                    utils::pick(ndims() - 3, nwc, nhwc, ndhwc),
+                    utils::pick(ndims() - 3, nCw8c, nChw8c, nCdhw8c),
+                    utils::pick(ndims() - 3, nCw16c, nChw16c, nCdhw16c));
+
+            init_name();
+            init_scratchpad();
+            return attr_.set_default_formats(dst_md(0));
+        }
+
+        std::shared_ptr<primitive_desc_t> conv_pd_;
+        bool conv_supports_bias_ = false;
+        format_tag_t dst_tag_;
+
+    private:
+        std::string name_ = "conv:any+"; // convolution-based deconvolution
+
+        void init_name() { name_.append(conv_pd_->name()); }
+
+        void init_scratchpad() {
+            using namespace memory_tracking::names;
+            auto scratchpad = scratchpad_registry().registrar();
+            scratchpad.book(key_nested, conv_pd_->scratchpad_registry());
+
+            // This scratchpad is required for intermediate f32 conv output
+            // since original memory can be of smaller size and will cause
+            // out of boundary access.
+            if ((with_bias() && !conv_supports_bias_)
+                    || !attr()->has_default_values()) {
+                const memory_desc_wrapper diff_src_d(conv_pd_->diff_src_md());
+                assert(diff_src_d.data_type_size() == sizeof(float));
+                scratchpad.book(key_deconv_bias, diff_src_d.nelems(true),
+                        diff_src_d.data_type_size());
+            }
+            // This scratchpad is required to stash original dst memory for sum
+            // post-op. It will be overwritten by conv execution and will not
+            // be available to get the correct result.
+            const memory_desc_wrapper dst_d(dst_md());
+            if (attr()->post_ops_.find(primitive_kind::sum) != -1)
+                scratchpad.book(key_deconv_sum, dst_d.nelems(true),
+                        dst_d.data_type_size());
+
+            if (!attr()->zero_points_.has_default_values(DNNL_ARG_SRC)) {
+                scratchpad.book<int32_t>(key_deconv_zp, OC() * G());
+            }
+        }
+
+        bool post_ops_ok() const {
+            using namespace data_type;
+            const bool is_int8 = utils::one_of(src_md()->data_type, s8, u8);
+            return attr()->post_ops_.check_sum_consistency(
+                           dst_md()->data_type, is_int8)
+                    && ref_post_ops_t::primitive_kind_ok(attr()->post_ops_);
+        }
+
+        bool zero_points_ok() const {
+            using namespace data_type;
+            int mask_src = 0, mask_dst = 0;
+            attr()->zero_points_.get(DNNL_ARG_SRC, &mask_src);
+            attr()->zero_points_.get(DNNL_ARG_DST, &mask_dst);
+
+            return IMPLICATION(!utils::one_of(src_md()->data_type, s8, u8),
+                           attr()->zero_points_.has_default_values())
+                    && attr()->zero_points_.has_default_values(DNNL_ARG_WEIGHTS)
+                    && (mask_src == 0 || mask_src == 1 << 1)
+                    && (mask_dst == 0 || mask_dst == 1 << 1);
+        }
+    };
+
+    ref_deconvolution_fwd_t(const pd_t *apd) : primitive_t(apd) {}
+
+    status_t init(engine_t *engine) override {
+        CHECK(pd()->conv_pd_->create_primitive(conv_p_, engine));
+
+        ref_post_ops
+                = utils::make_unique<ref_post_ops_t>(pd()->attr()->post_ops_);
+        if (!ref_post_ops) return status::out_of_memory;
+        CHECK(ref_post_ops->init(pd()->dst_md()));
+        return status::success;
+    }
+
+    status_t execute(const exec_ctx_t &ctx) const override;
+
+private:
+    void compute_fwd_bias_common(const exec_ctx_t &ctx, void *dst,
+            const float *conv_output, bool non_default_attr) const;
+
+    void compute_fwd_bias_ncdhw(const exec_ctx_t &ctx, void *dst,
+            const float *conv_output, bool non_default_attr) const;
+
+    void compute_fwd_bias_ndhwc(const exec_ctx_t &ctx, void *dst,
+            const float *conv_output, bool non_default_attr) const;
+
+    template <dim_t blk_size>
+    void compute_fwd_bias_nCdhwXc(const exec_ctx_t &ctx, void *dst,
+            const float *conv_output, bool non_default_attr) const;
+
+    status_t compute_oscale(const exec_ctx_t &ctx, float *dst) const;
+
+    void compute_fwd_bias(const exec_ctx_t &ctx, void *dst,
+            const float *conv_output, bool non_default_attr) const;
+
+    status_t compute_ref_attrs(const exec_ctx_t &ctx, const float *conv_output,
+            void *original_dst) const;
+
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+    std::shared_ptr<primitive_t> conv_p_;
+    std::unique_ptr<ref_post_ops_t> ref_post_ops;
+};
+
+struct ref_deconvolution_bwd_data_t : public primitive_t {
+    struct pd_t : public cpu_deconvolution_bwd_data_pd_t {
+        pd_t(const deconvolution_desc_t *adesc, const primitive_attr_t *attr,
+                const deconvolution_fwd_pd_t *hint_fwd_pd)
+            : cpu_deconvolution_bwd_data_pd_t(adesc, attr, hint_fwd_pd) {}
+
+        pd_t(const pd_t &other)
+            : cpu_deconvolution_bwd_data_pd_t(other)
+            , conv_pd_(other.conv_pd_->clone())
+            , name_(other.name_) {}
+
+        ~pd_t() = default;
+
+        DECLARE_COMMON_PD_T(name_.c_str(), ref_deconvolution_bwd_data_t);
+
+        status_t init_convolution(engine_t *engine) {
+            using namespace types;
+
+            convolution_desc_t cd;
+            status_t status = conv_descr_create(desc(), &cd);
+            if (status != status::success) return status;
+            primitive_attr_t conv_attr(*attr());
+            if (!conv_attr.is_initialized()) return status::out_of_memory;
+
+            primitive_desc_iterator_t it(
+                    engine, (op_desc_t *)&cd, &conv_attr, nullptr);
+            if (!it.is_initialized()) return status::out_of_memory;
+            while (++it != it.end()) {
+                conv_pd_ = *it;
+                if (conv_pd_->weights_md()->extra.flags == 0)
+                    return status::success;
+            }
+
+            return status::unimplemented;
+        }
+
+        status_t init(engine_t *engine) {
+            using namespace data_type;
+            auto dsrc_type = desc()->diff_src_desc.data_type;
+            auto wei_type = desc()->weights_desc.data_type;
+            auto ddst_type = desc()->diff_dst_desc.data_type;
+            bool ok = true && desc()->prop_kind == prop_kind::backward_data
+                    && utils::one_of(wei_type, f32, bf16, f16)
+                    && ddst_type == wei_type
+                    && utils::one_of(dsrc_type, wei_type, f32)
+                    && utils::one_of(desc()->alg_kind,
+                            alg_kind::deconvolution_direct,
+                            alg_kind::deconvolution_winograd)
+                    && attr()->has_default_values();
+
+            if (ok) {
+                CHECK(init_convolution(engine));
+                if (weights_md_.format_kind == format_kind::any)
+                    CHECK(weights_axes_permutation(&weights_md_,
+                            conv_pd_->weights_md(), with_groups()));
+                if (diff_src_md_.format_kind == format_kind::any)
+                    diff_src_md_ = *conv_pd_->dst_md();
+                if (diff_dst_md_.format_kind == format_kind::any)
+                    diff_dst_md_ = *conv_pd_->src_md();
+
+                init_name();
+                init_scratchpad();
+                return status::success;
+            }
+
+            return status::unimplemented;
+        }
+
+        std::shared_ptr<primitive_desc_t> conv_pd_;
+
+    private:
+        std::string name_ = "conv:any+"; // convolution-based deconvolution
+
+        void init_name() { name_.append(conv_pd_->name()); }
+
+        void init_scratchpad() {
+            auto scratchpad = scratchpad_registry().registrar();
+            scratchpad.book(memory_tracking::names::key_nested,
+                    conv_pd_->scratchpad_registry());
+        }
+    };
+
+    typedef typename prec_traits<data_type::f32>::type data_t;
+
+    ref_deconvolution_bwd_data_t(const pd_t *apd) : primitive_t(apd) {}
+
+    status_t init(engine_t *engine) override {
+        return pd()->conv_pd_->create_primitive(conv_p_, engine);
+    }
+
+#if DNNL_AARCH64 && DNNL_AARCH64_USE_ACL
+    status_t create_resource(
+            engine_t *engine, resource_mapper_t &mapper) const override {
+        CHECK(conv_p_->create_resource(engine, mapper));
+        return status::success;
+    }
+#endif
+
+    status_t execute(const exec_ctx_t &ctx) const override;
+
+private:
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+    std::shared_ptr<primitive_t> conv_p_;
+};
+
+struct ref_deconvolution_bwd_weights_t : public primitive_t {
+    struct pd_t : public cpu_deconvolution_bwd_weights_pd_t {
+        pd_t(const deconvolution_desc_t *adesc, const primitive_attr_t *attr,
+                const deconvolution_fwd_pd_t *hint_fwd_pd)
+            : cpu_deconvolution_bwd_weights_pd_t(adesc, attr, hint_fwd_pd) {}
+
+        pd_t(const pd_t &other)
+            : cpu_deconvolution_bwd_weights_pd_t(other)
+            , conv_pd_(other.conv_pd_->clone())
+            , dst_tag_(other.dst_tag_)
+            , name_(other.name_) {}
+
+        ~pd_t() = default;
+
+        DECLARE_COMMON_PD_T(name_.c_str(), ref_deconvolution_bwd_weights_t);
+
+        status_t init_convolution(engine_t *engine) {
+            using namespace types;
+            using namespace format_tag;
+
+            convolution_desc_t cd;
+            status_t status = conv_descr_create(desc(), &cd);
+            if (status != status::success) return status;
+            primitive_attr_t conv_attr(*attr());
+            if (!conv_attr.is_initialized()) return status::out_of_memory;
+
+            primitive_desc_iterator_t it(
+                    engine, (op_desc_t *)&cd, &conv_attr, nullptr);
+            if (!it.is_initialized()) return status::out_of_memory;
+            while (++it != it.end()) {
+                conv_pd_ = *it;
+                bool bf16_ref_deconv_supports_bias = IMPLICATION(with_bias()
+                                && desc()->src_desc.data_type
+                                        == data_type::bf16,
+                        memory_desc_matches_one_of_tag(*conv_pd_->src_md(),
+                                utils::pick(ndims() - 3, ncw, nchw, ncdhw),
+                                utils::pick(ndims() - 3, nwc, nhwc, ndhwc),
+                                utils::pick(ndims() - 3, nCw16c, nChw16c,
+                                        nCdhw16c)));
+                if (conv_pd_->diff_weights_md()->extra.flags == 0
+                        && bf16_ref_deconv_supports_bias) {
+                    return status::success;
+                }
+            }
+            return status::unimplemented;
+        }
+
+        status_t init(engine_t *engine) {
+            using namespace format_tag;
+            using namespace data_type;
+            auto src_type = desc()->src_desc.data_type;
+            auto dwei_type = desc()->diff_weights_desc.data_type;
+            auto ddst_type = desc()->diff_dst_desc.data_type;
+            bool ok = true && desc()->prop_kind == prop_kind::backward_weights
+                    && utils::one_of(src_type, f32, bf16, f16)
+                    && ddst_type == src_type
+                    && utils::one_of(dwei_type, src_type, f32)
+                    && utils::one_of(desc()->alg_kind,
+                            alg_kind::deconvolution_direct,
+                            alg_kind::deconvolution_winograd)
+                    && attr()->has_default_values();
+
+            if (ok) {
+                CHECK(init_convolution(engine));
+                if (diff_weights_md_.format_kind == format_kind::any)
+                    CHECK(weights_axes_permutation(&diff_weights_md_,
+                            conv_pd_->diff_weights_md(), with_groups()));
+                if (src_md_.format_kind == format_kind::any)
+                    src_md_ = *conv_pd_->diff_dst_md();
+                if (diff_dst_md_.format_kind == format_kind::any)
+                    diff_dst_md_ = *conv_pd_->src_md();
+                if (diff_bias_md_.format_kind == format_kind::any)
+                    CHECK(memory_desc_init_by_tag(diff_bias_md_, x));
+
+                dst_tag_ = memory_desc_matches_one_of_tag(diff_dst_md_,
+                        utils::pick(ndims() - 3, ncw, nchw, ncdhw),
+                        utils::pick(ndims() - 3, nwc, nhwc, ndhwc),
+                        utils::pick(ndims() - 3, nCw8c, nChw8c, nCdhw8c),
+                        utils::pick(ndims() - 3, nCw16c, nChw16c, nCdhw16c));
+
+                init_name();
+                init_scratchpad();
+                return status::success;
+            }
+
+            return status::unimplemented;
+        }
+
+        std::shared_ptr<primitive_desc_t> conv_pd_;
+        format_tag_t dst_tag_;
+
+    private:
+        std::string name_ = "conv:any+"; // convolution-based deconvolution
+
+        void init_name() { name_.append(conv_pd_->name()); }
+
+        void init_scratchpad() {
+            auto scratchpad = scratchpad_registry().registrar();
+            scratchpad.book(memory_tracking::names::key_nested,
+                    conv_pd_->scratchpad_registry());
+        }
+    };
+
+    ref_deconvolution_bwd_weights_t(const pd_t *apd) : primitive_t(apd) {}
+
+    status_t init(engine_t *engine) override {
+        return pd()->conv_pd_->create_primitive(conv_p_, engine);
+    }
+
+    status_t execute(const exec_ctx_t &ctx) const override;
+
+private:
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+    void compute_bwd_bias(float *diff_bias, const float *diff_dst) const;
+
+    template <data_type_t dbia_type, data_type_t ddst_type>
+    void compute_bwd_bias_ncdhw(
+            typename prec_traits<dbia_type>::type *diff_bias,
+            const typename prec_traits<ddst_type>::type *diff_dst) const;
+
+    template <data_type_t dbia_type, data_type_t ddst_type>
+    void compute_bwd_bias_ndhwc(
+            typename prec_traits<dbia_type>::type *diff_bias,
+            const typename prec_traits<ddst_type>::type *diff_dst) const;
+
+    template <data_type_t dbia_type, data_type_t ddst_type, dim_t blksize>
+    void compute_bwd_bias_nCdhwXc(
+            typename prec_traits<dbia_type>::type *diff_bias,
+            const typename prec_traits<ddst_type>::type *diff_dst) const;
+
+    template <data_type_t dbia_type, data_type_t ddst_type>
+    void compute_bias(const exec_ctx_t &ctx) const;
+    std::shared_ptr<primitive_t> conv_p_;
+};
+
+} // namespace cpu
+} // 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/cpu/ref_eltwise.hpp

@@ -0,0 +1,181 @@
+/*******************************************************************************
+* 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 CPU_REF_ELTWISE_HPP
+#define CPU_REF_ELTWISE_HPP
+
+#include <assert.h>
+
+#include "common/c_types_map.hpp"
+#include "common/primitive.hpp"
+#include "common/type_helpers.hpp"
+#include "common/utils.hpp"
+
+#include "cpu/platform.hpp"
+#include "cpu/primitive_attr_postops.hpp"
+
+#include "cpu/cpu_eltwise_pd.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+template <impl::data_type_t data_type>
+struct ref_eltwise_fwd_t : public primitive_t {
+    struct pd_t : public cpu_eltwise_fwd_pd_t {
+        using cpu_eltwise_fwd_pd_t::cpu_eltwise_fwd_pd_t;
+
+        DECLARE_COMMON_PD_T("ref:any", ref_eltwise_fwd_t);
+
+        status_t init(engine_t *engine) {
+            using namespace utils;
+            using sm = primitive_attr_t::skip_mask_t;
+
+            const memory_desc_wrapper src_d(src_md());
+            const memory_desc_wrapper dst_d(dst_md());
+
+            bool ok = is_fwd()
+                    && utils::everyone_is(
+                            data_type, src_md()->data_type, dst_md()->data_type)
+                    && platform::has_data_type_support(data_type)
+                    && attr()->has_default_values(sm::post_ops)
+                    && ref_post_ops_t::primitive_kind_ok(attr()->post_ops_)
+                    && set_default_formats_common() && src_d == dst_d
+                    && attr_.set_default_formats(dst_md(0)) == status::success;
+            if (!ok) return status::unimplemented;
+
+            use_dense_ = src_d.is_dense(true) && dst_d.is_dense(true)
+                    && IMPLICATION(!src_d.is_dense() || !dst_d.is_dense(),
+                            is_zero_preserved());
+
+            use_nCspBc_padded_ = !use_dense_
+                    && src_d.blocking_desc().inner_nblks == 1
+                    && one_of(src_d.blocking_desc().inner_blks[0], 8, 16)
+                    && src_d.blocking_desc().inner_idxs[0] == 1
+                    && src_d.only_padded_dim(1) && src_d.is_dense(true);
+
+            const auto &po = attr()->post_ops_;
+            if (has_zero_dim_memory() || !po.has_default_values())
+                use_dense_ = use_nCspBc_padded_ = false;
+
+            return status::success;
+        }
+
+        bool use_dense_, use_nCspBc_padded_;
+    };
+
+    ref_eltwise_fwd_t(const pd_t *apd) : primitive_t(apd) {}
+
+    status_t init(engine_t *engine) override {
+        ref_post_ops
+                = utils::make_unique<ref_post_ops_t>(pd()->attr()->post_ops_);
+        if (!ref_post_ops) return status::out_of_memory;
+        CHECK(ref_post_ops->init(pd()->dst_md()));
+        return status::success;
+    }
+
+    using data_t = typename prec_traits<data_type>::type;
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        if (pd()->use_dense_)
+            return execute_forward_dense(ctx);
+        else if (pd()->use_nCspBc_padded_)
+            return execute_forward_nCspBc_padded(ctx);
+        else
+            return execute_forward_generic(ctx);
+    }
+
+private:
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+    status_t execute_forward_nCspBc_padded(const exec_ctx_t &ctx) const;
+    status_t execute_forward_dense(const exec_ctx_t &ctx) const;
+    status_t execute_forward_generic(const exec_ctx_t &ctx) const;
+    std::unique_ptr<ref_post_ops_t> ref_post_ops;
+};
+
+template <impl::data_type_t data_type>
+struct ref_eltwise_bwd_t : public primitive_t {
+    struct pd_t : public cpu_eltwise_bwd_pd_t {
+        using cpu_eltwise_bwd_pd_t::cpu_eltwise_bwd_pd_t;
+
+        DECLARE_COMMON_PD_T("ref:any", ref_eltwise_bwd_t);
+
+        status_t init(engine_t *engine) {
+            using namespace utils;
+            using namespace data_type;
+
+            const memory_desc_wrapper diff_src_d(diff_src_md());
+            const memory_desc_wrapper diff_dst_d(diff_dst_md());
+
+            bool ok = !is_fwd()
+                    && utils::everyone_is(data_type, data_md()->data_type,
+                            diff_src_md()->data_type, diff_dst_md()->data_type)
+                    && platform::has_data_type_support(data_type)
+                    && attr()->has_default_values()
+                    && set_default_formats_common() && diff_dst_d == diff_src_d;
+            if (!ok) return status::unimplemented;
+
+            use_dense_ = diff_dst_d.is_dense()
+                    || (diff_dst_d.is_dense(true) && is_zero_preserved());
+
+            if (has_zero_dim_memory()) use_dense_ = false;
+            if (diff_dst_d != memory_desc_wrapper(data_md()))
+                use_dense_ = false;
+
+            if (utils::one_of(data_type, bf16, f16)) init_scratchpad();
+
+            return status::success;
+        }
+
+        bool use_dense_;
+
+    private:
+        void init_scratchpad() {
+            const memory_desc_wrapper data_d(data_md());
+            const memory_desc_wrapper diff_dst_d(diff_dst_md());
+            using namespace memory_tracking::names;
+            auto scratchpad = scratchpad_registry().registrar();
+            const auto diff_dst_size = diff_dst_d.nelems(true);
+            scratchpad.template book<float>(
+                    key_eltwise_src, data_d.nelems(true));
+            scratchpad.template book<float>(
+                    key_eltwise_diff_dst, diff_dst_size);
+        }
+    };
+
+    ref_eltwise_bwd_t(const pd_t *apd) : primitive_t(apd) {}
+    typedef typename prec_traits<data_type>::type data_t;
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        if (pd()->use_dense_)
+            return execute_backward_dense(ctx);
+        else
+            return execute_backward_generic(ctx);
+    }
+
+private:
+    status_t execute_backward_dense(const exec_ctx_t &ctx) const;
+    status_t execute_backward_generic(const exec_ctx_t &ctx) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+};
+
+} // namespace cpu
+} // 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/cpu/ref_group_normalization.hpp

@@ -0,0 +1,143 @@
+/*******************************************************************************
+* 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 CPU_REF_GROUP_NORMALIZATION_HPP
+#define CPU_REF_GROUP_NORMALIZATION_HPP
+
+#include "common/c_types_map.hpp"
+#include "common/primitive.hpp"
+
+#include "cpu/primitive_attr_postops.hpp"
+
+#include "cpu/cpu_group_normalization_pd.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct ref_group_normalization_fwd_t : public primitive_t {
+    struct pd_t : public cpu_group_normalization_fwd_pd_t {
+        using cpu_group_normalization_fwd_pd_t::
+                cpu_group_normalization_fwd_pd_t;
+
+        DECLARE_COMMON_PD_T("ref:any", ref_group_normalization_fwd_t);
+
+        status_t init(engine_t *engine) {
+            using namespace data_type;
+            using skip_mask_t = primitive_attr_t::skip_mask_t;
+
+            VDISPATCH_GNORM(is_fwd(), VERBOSE_BAD_PROPKIND);
+            VDISPATCH_GNORM(
+                    utils::one_of(src_md()->data_type, f32, bf16, f16, s8, u8)
+                            && platform::has_data_type_support(
+                                    src_md()->data_type),
+                    VERBOSE_UNSUPPORTED_DT);
+            VDISPATCH_GNORM(
+                    utils::one_of(dst_md()->data_type, f32, bf16, f16, s8, u8)
+                            && platform::has_data_type_support(
+                                    dst_md()->data_type),
+                    VERBOSE_UNSUPPORTED_DT);
+            VDISPATCH_GNORM(
+                    attr()->has_default_values(skip_mask_t::scales_runtime
+                            | skip_mask_t::post_ops),
+                    VERBOSE_UNSUPPORTED_ATTR);
+            VDISPATCH_GNORM(attr_scales_ok(), VERBOSE_UNSUPPORTED_SCALES_CFG);
+            VDISPATCH_GNORM(post_ops_ok(), VERBOSE_UNSUPPORTED_POSTOP);
+
+            VDISPATCH_GNORM(
+                    set_default_formats_common(), VERBOSE_UNSUPPORTED_TAG);
+
+            bool ok = attr_.set_default_formats(dst_md(0)) == status::success;
+            if (!ok) return status::unimplemented;
+
+            return status::success;
+        }
+
+    private:
+        bool post_ops_ok() const {
+            return ref_post_ops_t::primitive_kind_ok(attr()->post_ops_);
+        }
+    };
+
+    using primitive_t::primitive_t;
+
+    status_t init(engine_t *engine) override {
+        ref_post_ops
+                = utils::make_unique<ref_post_ops_t>(pd()->attr()->post_ops_);
+        if (!ref_post_ops) return status::out_of_memory;
+        CHECK(ref_post_ops->init(pd()->dst_md()));
+        return status::success;
+    }
+
+    status_t execute(const exec_ctx_t &ctx) const override;
+
+private:
+    std::unique_ptr<ref_post_ops_t> ref_post_ops;
+
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+};
+
+struct ref_group_normalization_bwd_t : public primitive_t {
+    struct pd_t : public cpu_group_normalization_bwd_pd_t {
+        using cpu_group_normalization_bwd_pd_t::
+                cpu_group_normalization_bwd_pd_t;
+
+        DECLARE_COMMON_PD_T("ref:any", ref_group_normalization_bwd_t);
+
+        status_t init(engine_t *engine) {
+            using namespace data_type;
+
+            VDISPATCH_GNORM(!is_fwd(), VERBOSE_BAD_PROPKIND);
+
+            VDISPATCH_GNORM(utils::one_of(src_md()->data_type, f32, bf16, f16)
+                            && platform::has_data_type_support(
+                                    src_md()->data_type),
+                    VERBOSE_UNSUPPORTED_DT);
+            VDISPATCH_GNORM(
+                    utils::one_of(diff_dst_md()->data_type, f32, bf16, f16)
+                            && platform::has_data_type_support(
+                                    diff_dst_md()->data_type),
+                    VERBOSE_UNSUPPORTED_DT);
+            VDISPATCH_GNORM(
+                    utils::one_of(diff_src_md()->data_type, f32, bf16, f16)
+                            && platform::has_data_type_support(
+                                    diff_src_md()->data_type),
+                    VERBOSE_UNSUPPORTED_DT);
+            VDISPATCH_GNORM(
+                    attr()->has_default_values(), VERBOSE_UNSUPPORTED_ATTR);
+
+            VDISPATCH_GNORM(
+                    set_default_formats_common(), VERBOSE_UNSUPPORTED_TAG);
+
+            return status::success;
+        }
+    };
+
+    ref_group_normalization_bwd_t(const pd_t *apd) : primitive_t(apd) {}
+
+    status_t execute(const exec_ctx_t &ctx) const override;
+
+private:
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+};
+
+} // namespace cpu
+} // namespace impl
+} // namespace dnnl
+
+#endif
+
+// vim: et ts=4 sw=4 cindent cino^=l0,\:0,N-s

videochat2/lib/python3.10/site-packages/tensorflow/include/external/onednn/src/cpu/ref_inner_product.hpp

@@ -0,0 +1,175 @@
+/*******************************************************************************
+* 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 CPU_REF_INNER_PRODUCT_HPP
+#define CPU_REF_INNER_PRODUCT_HPP
+
+#include <assert.h>
+
+#include "common/c_types_map.hpp"
+#include "common/primitive.hpp"
+#include "common/type_helpers.hpp"
+#include "common/utils.hpp"
+
+#include "cpu/primitive_attr_postops.hpp"
+
+#include "cpu/cpu_inner_product_pd.hpp"
+
+namespace dnnl {
+namespace impl {
+namespace cpu {
+
+struct ref_inner_product_fwd_t : public primitive_t {
+    struct pd_t : public cpu_inner_product_fwd_pd_t {
+        using cpu_inner_product_fwd_pd_t::cpu_inner_product_fwd_pd_t;
+
+        DECLARE_COMMON_PD_T("ref:any", ref_inner_product_fwd_t);
+
+        status_t init(engine_t *engine) {
+            using namespace data_type;
+            using smask_t = primitive_attr_t::skip_mask_t;
+            const auto src_type = src_md(0)->data_type;
+            const auto wei_type = weights_md(0)->data_type;
+            const auto bia_type = weights_md(1)->data_type;
+            const auto dst_type = dst_md(0)->data_type;
+
+            const bool allow_all_tags = true; // ref should support all tags
+
+            bool ok = is_fwd() && platform::has_data_type_support(src_type)
+                    && platform::has_data_type_support(wei_type)
+                    && platform::has_data_type_support(bia_type)
+                    && platform::has_data_type_support(dst_type)
+                    && utils::one_of(src_type, f32, bf16, f16)
+                    && wei_type == src_type
+                    && utils::one_of(dst_type, f32, src_type)
+                    && IMPLICATION(
+                            with_bias(), utils::one_of(bia_type, f32, src_type))
+                    && set_default_params(allow_all_tags) == status::success
+                    && attr()->has_default_values(
+                            smask_t::post_ops | smask_t::sum_dt)
+                    && attr()->post_ops_.check_sum_consistency(dst_type,
+                            /* is_int8 */ false)
+                    && ref_post_ops_t::primitive_kind_ok(attr()->post_ops_)
+                    && attr_.set_default_formats(dst_md(0)) == status::success;
+            return ok ? status::success : status::unimplemented;
+        }
+    };
+
+    ref_inner_product_fwd_t(const pd_t *apd) : primitive_t(apd) {}
+
+    status_t init(engine_t *engine) override {
+        ref_post_ops
+                = utils::make_unique<ref_post_ops_t>(pd()->attr()->post_ops_);
+        if (!ref_post_ops) return status::out_of_memory;
+        CHECK(ref_post_ops->init(pd()->dst_md()));
+        return status::success;
+    }
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_forward(ctx);
+    }
+
+private:
+    status_t execute_forward(const exec_ctx_t &ctx) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+    std::unique_ptr<ref_post_ops_t> ref_post_ops;
+};
+
+struct ref_inner_product_bwd_data_t : public primitive_t {
+    struct pd_t : public cpu_inner_product_bwd_data_pd_t {
+        using cpu_inner_product_bwd_data_pd_t::cpu_inner_product_bwd_data_pd_t;
+
+        DECLARE_COMMON_PD_T("ref:any", ref_inner_product_bwd_data_t);
+
+        status_t init(engine_t *engine) {
+            using namespace data_type;
+            const auto diff_src_type = diff_src_md(0)->data_type;
+            const auto wei_type = weights_md(0)->data_type;
+            const auto diff_dst_type = diff_dst_md(0)->data_type;
+
+            const bool allow_all_tags = true; // ref should support all tags
+
+            bool ok = desc()->prop_kind == prop_kind::backward_data
+                    && platform::has_data_type_support(diff_src_type)
+                    && platform::has_data_type_support(wei_type)
+                    && platform::has_data_type_support(diff_dst_type)
+                    && utils::one_of(diff_src_type, f32, wei_type)
+                    && utils::one_of(wei_type, f32, bf16, f16)
+                    && diff_dst_type == wei_type && attr()->has_default_values()
+                    && set_default_params(allow_all_tags) == status::success;
+            return ok ? status::success : status::unimplemented;
+        }
+    };
+
+    ref_inner_product_bwd_data_t(const pd_t *apd) : primitive_t(apd) {}
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_backward_data(ctx);
+    }
+
+private:
+    status_t execute_backward_data(const exec_ctx_t &ctx) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+};
+
+struct ref_inner_product_bwd_weights_t : public primitive_t {
+    struct pd_t : public cpu_inner_product_bwd_weights_pd_t {
+        using cpu_inner_product_bwd_weights_pd_t::
+                cpu_inner_product_bwd_weights_pd_t;
+
+        DECLARE_COMMON_PD_T("ref:any", ref_inner_product_bwd_weights_t);
+
+        status_t init(engine_t *engine) {
+            using namespace data_type;
+            const auto src_type = src_md(0)->data_type;
+            const auto diff_wei_type = diff_weights_md(0)->data_type;
+            const auto diff_bia_type = diff_weights_md(1)->data_type;
+            const auto diff_dst_type = diff_dst_md(0)->data_type;
+
+            const bool allow_all_tags = true; // ref should support all tags
+
+            bool ok = desc()->prop_kind == prop_kind::backward_weights
+                    && platform::has_data_type_support(src_type)
+                    && platform::has_data_type_support(diff_wei_type)
+                    && platform::has_data_type_support(diff_bia_type)
+                    && utils::one_of(src_type, f32, bf16, f16)
+                    && utils::one_of(diff_wei_type, f32, src_type)
+                    && IMPLICATION(with_bias(),
+                            utils::one_of(diff_bia_type, f32, src_type))
+                    && diff_dst_type == src_type && attr()->has_default_values()
+                    && set_default_params(allow_all_tags) == status::success;
+            return ok ? status::success : status::unimplemented;
+        }
+    };
+
+    ref_inner_product_bwd_weights_t(const pd_t *apd) : primitive_t(apd) {}
+
+    status_t execute(const exec_ctx_t &ctx) const override {
+        return execute_backward_weights(ctx);
+    }
+
+private:
+    status_t execute_backward_weights(const exec_ctx_t &ctx) const;
+    const pd_t *pd() const { return (const pd_t *)primitive_t::pd().get(); }
+};
+
+} // namespace cpu
+} // namespace impl
+} // namespace dnnl
+
+#endif
+
+// vim: et ts=4 sw=4 cindent cino+=l0,\:4,N-s