path: root/tests/validation/dynamic_fusion/gpu/Integration.cpp

/*
 * Copyright (c) 2022-2024 Arm Limited.
 *
 * SPDX-License-Identifier: MIT
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
 * deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include "arm_compute/core/CL/CLKernelLibrary.h"
#include "arm_compute/core/QuantizationInfo.h"
#include "arm_compute/core/TensorInfo.h"
#include "arm_compute/core/Types.h"
#include "arm_compute/dynamic_fusion/runtime/gpu/cl/ClWorkloadRuntime.h"
#include "arm_compute/dynamic_fusion/sketch/attributes/CastAttributes.h"
#include "arm_compute/dynamic_fusion/sketch/attributes/Conv2dAttributes.h"
#include "arm_compute/dynamic_fusion/sketch/attributes/DepthwiseConv2dAttributes.h"
#include "arm_compute/dynamic_fusion/sketch/gpu/GpuWorkloadSketch.h"
#include "arm_compute/dynamic_fusion/sketch/gpu/operators/GpuAdd.h"
#include "arm_compute/dynamic_fusion/sketch/gpu/operators/GpuCast.h"
#include "arm_compute/dynamic_fusion/sketch/gpu/operators/GpuConv2d.h"
#include "arm_compute/dynamic_fusion/sketch/gpu/operators/GpuDepthwiseConv2d.h"
#include "arm_compute/dynamic_fusion/sketch/gpu/operators/GpuMul.h"
#include "arm_compute/dynamic_fusion/sketch/gpu/operators/GpuOutput.h"
#include "arm_compute/dynamic_fusion/sketch/gpu/operators/GpuSigmoid.h"

#include "tests/CL/CLAccessor.h"
#include "tests/framework/Macros.h"
#include "tests/validation/dynamic_fusion/Utils.h"
#include "tests/validation/reference/ActivationLayer.h"
#include "tests/validation/reference/ConvolutionLayer.h"
#include "tests/validation/reference/DepthConvertLayer.h"
#include "tests/validation/reference/DepthwiseConvolutionLayer.h"
#include "tests/validation/reference/ElementwiseOperations.h"
#include "tests/validation/reference/Permute.h"
#include "tests/validation/reference/PixelWiseMultiplication.h"
#include "tests/validation/Validation.h"

using namespace arm_compute::experimental::dynamic_fusion;
using namespace arm_compute::test::validation::utils;

namespace arm_compute
{
namespace test
{
namespace validation
{
TEST_SUITE(CL)
TEST_SUITE(INTEGRATION)
TEST_SUITE(DYNAMIC_FUSION)

TEST_CASE(Conv2d, framework::DatasetMode::ALL)
{
    /* Computation:
     * out = conv2d1x1(direct_conv)(input, weights, bias)
     */
    CLScheduler::get().default_reinit();

    const auto data_type      = DataType::F32;
    const auto data_layout    = DataLayout::NHWC;
    const auto t_input_shape  = TensorShape(384, 12, 12);
    const auto t_weight_shape = TensorShape(384, 1, 1, 16);
    const auto t_dst_shape    = TensorShape(16, 12, 12);

    // Create a new workload sketch
    auto              cl_compile_ctx = CLKernelLibrary::get().get_compile_context();
    auto              context        = GpuWorkloadContext{&cl_compile_ctx};
    GpuWorkloadSketch sketch{&context};

    // Fuse conv2d
    Conv2dAttributes conv2d_attr{};
    ITensorInfo     *input_info  = context.create_tensor_info(t_input_shape, 1, data_type, data_layout);
    ITensorInfo     *weight_info = context.create_tensor_info(TensorInfo(t_weight_shape, 1, data_type, data_layout));

    ITensorInfo *conv_out_info = GpuConv2d::create_op(sketch, input_info, weight_info, nullptr, conv2d_attr);

    ITensorInfo *dst_info = context.create_tensor_info();
    GpuOutput::create_op(sketch, conv_out_info, dst_info);

    // Configure runtime
    ClWorkloadRuntime runtime;
    runtime.configure(sketch);

    // (Important) Allocate auxiliary tensor memory if there are any
    // Instead of using ACL allocated memory, the user can choose to import memory into the tensors
    for (auto &data : runtime.get_auxiliary_tensors())
    {
        CLTensor     *tensor      = std::get<0>(data);
        TensorInfo    info        = std::get<1>(data);
        AuxMemoryInfo aux_mem_req = std::get<2>(data);
        tensor->allocator()->init(info, aux_mem_req.alignment);
        tensor->allocator()->allocate(); // Use ACL allocated memory
        // auto buf = cl::Buffer();
        // tensor->allocator()->import_memory(buf);  // Or, import external memory
    }

    // Construct user tensors
    CLTensor t_input{};
    CLTensor t_weight{};
    CLTensor t_dst{};

    // Initialize user tensors
    t_input.allocator()->init(*input_info);
    t_weight.allocator()->init(*weight_info);
    t_dst.allocator()->init(*dst_info);

    // Allocate and fill user tensors
    // Instead of using ACL allocator, the user can choose to import memory into the tensors
    t_input.allocator()->allocate();
    t_weight.allocator()->allocate();
    t_dst.allocator()->allocate();
    fill<float>(CLAccessor(t_input), 0, library.get());
    fill<float>(CLAccessor(t_weight), 1, library.get());

    // Run runtime
    runtime.run({&t_input, &t_weight, &t_dst});

    // Create reference
    SimpleTensor<float> ref_t_input{t_input_shape, data_type, 1, QuantizationInfo(), DataLayout::NHWC};
    SimpleTensor<float> ref_t_weight{t_weight_shape, data_type, 1, QuantizationInfo(), DataLayout::NHWC};
    SimpleTensor<float> ref_t_bias_placeholder{t_dst_shape, data_type, 1, QuantizationInfo(), DataLayout::NHWC};

    // Fill reference
    fill<float>(ref_t_input, 0, library.get());
    fill<float>(ref_t_weight, 1, library.get());

    auto ref_t_input_nchw            = reference::permute(ref_t_input, PermutationVector(1U, 2U, 0U));
    auto ref_t_weight_nchw           = reference::permute(ref_t_weight, PermutationVector(1U, 2U, 0U));
    auto ref_t_bias_placeholder_nchw = reference::permute(ref_t_bias_placeholder, PermutationVector(1U, 2U, 0U));
    auto t_dst_shape_nchw            = t_dst_shape;
    permute(t_dst_shape_nchw, PermutationVector(1U, 2U, 0U));

    PadStrideInfo legacy_pad_stride(conv2d_attr.stride().x(), conv2d_attr.stride().y(), conv2d_attr.pad().left,
                                    conv2d_attr.pad().right, conv2d_attr.pad().top, conv2d_attr.pad().bottom,
                                    DimensionRoundingType{});
    auto ref_t_dst_nchw = reference::convolution_layer(ref_t_input_nchw, ref_t_weight_nchw, ref_t_bias_placeholder_nchw,
                                                       t_dst_shape_nchw, legacy_pad_stride, conv2d_attr.dilation());
    const auto ref_t_dst = reference::permute(ref_t_dst_nchw, PermutationVector(2U, 0U, 1U));

    RelativeTolerance<float> tolerance_f32(
        0.001f); /**< Tolerance value for comparing reference's output against implementation's output for floating point data types */
    validate(CLAccessor(t_dst), ref_t_dst_nchw, tolerance_f32);
}

TEST_CASE(Add_Output_Add_Output, framework::DatasetMode::ALL)
{
    /* Computation:
     *   out_0 = in_0 + in_1
     *   out_1 = out_0 + in_2
     */
    CLScheduler::get().default_reinit();

    const auto data_type     = DataType::F32;
    const auto t_input_shape = TensorShape(33, 3, 2);

    // Create a new workload sketch
    auto              cl_compile_ctx = CLKernelLibrary::get().get_compile_context();
    auto              context        = GpuWorkloadContext{&cl_compile_ctx};
    GpuWorkloadSketch sketch{&context};

    ITensorInfo *in_0_info = context.create_tensor_info(t_input_shape, 1, data_type);
    ITensorInfo *in_1_info = context.create_tensor_info(t_input_shape, 1, data_type);
    ITensorInfo *in_2_info = context.create_tensor_info(t_input_shape, 1, data_type);

    ITensorInfo *out_0_info = context.create_tensor_info();
    ITensorInfo *out_1_info = context.create_tensor_info();

    ITensorInfo *ans_0_info = GpuAdd::create_op(sketch, in_0_info, in_1_info);
    GpuOutput::create_op(sketch, ans_0_info, out_0_info);
    ITensorInfo *ans_1_info = GpuAdd::create_op(sketch, ans_0_info, in_2_info);
    GpuOutput::create_op(sketch, ans_1_info, out_1_info);

    // Configure runtime
    ClWorkloadRuntime runtime;
    runtime.configure(sketch);

    // (Important) Allocate auxiliary tensor memory if there are any
    // Instead of using ACL allocated memory, the user can choose to import memory into the tensors
    for (auto &data : runtime.get_auxiliary_tensors())
    {
        CLTensor     *tensor      = std::get<0>(data);
        TensorInfo    info        = std::get<1>(data);
        AuxMemoryInfo aux_mem_req = std::get<2>(data);
        tensor->allocator()->init(info, aux_mem_req.alignment);
        tensor->allocator()->allocate(); // Use ACL allocated memory
        // auto buf = cl::Buffer();
        // tensor->allocator()->import_memory(buf);  // Or, import external memory
    }

    // Construct user tensors
    CLTensor t_in_0{};
    CLTensor t_in_1{};
    CLTensor t_in_2{};

    CLTensor t_out_0{};
    CLTensor t_out_1{};

    // Initialize user tensors
    t_in_0.allocator()->init(*in_0_info);
    t_in_1.allocator()->init(*in_1_info);
    t_in_2.allocator()->init(*in_2_info);

    t_out_0.allocator()->init(*out_0_info);
    t_out_1.allocator()->init(*out_1_info);

    // Allocate and fill user tensors
    // Instead of using ACL allocator, the user can choose to import memory into the tensors
    t_in_0.allocator()->allocate();
    t_in_1.allocator()->allocate();
    t_in_2.allocator()->allocate();

    t_out_0.allocator()->allocate();
    t_out_1.allocator()->allocate();

    fill<float>(CLAccessor(t_in_0), 0, library.get());
    fill<float>(CLAccessor(t_in_1), 1, library.get());
    fill<float>(CLAccessor(t_in_2), 2, library.get());

    // Run runtime
    runtime.run({&t_in_0, &t_in_1, &t_in_2, &t_out_0, &t_out_1});

    // Create reference
    SimpleTensor<float> ref_t_in_0{t_input_shape, data_type, 1, QuantizationInfo()};
    SimpleTensor<float> ref_t_in_1{t_input_shape, data_type, 1, QuantizationInfo()};
    SimpleTensor<float> ref_t_in_2{t_input_shape, data_type, 1, QuantizationInfo()};

    SimpleTensor<float> ref_t_out_0{t_input_shape, data_type, 1, QuantizationInfo()};
    SimpleTensor<float> ref_t_out_1{t_input_shape, data_type, 1, QuantizationInfo()};

    // Fill reference
    fill<float>(ref_t_in_0, 0, library.get());
    fill<float>(ref_t_in_1, 1, library.get());
    fill<float>(ref_t_in_2, 2, library.get());

    reference::arithmetic_operation(ArithmeticOperation::ADD, ref_t_in_0, ref_t_in_1, ref_t_out_0, ConvertPolicy::WRAP);
    reference::arithmetic_operation(ArithmeticOperation::ADD, ref_t_out_0, ref_t_in_2, ref_t_out_1,
                                    ConvertPolicy::WRAP);

    RelativeTolerance<float> tolerance_f32(
        0.001f); /**< Tolerance value for comparing reference's output against implementation's output for floating point data types */
    validate(CLAccessor(t_out_0), ref_t_out_0, tolerance_f32);
    validate(CLAccessor(t_out_1), ref_t_out_1, tolerance_f32);
}
TEST_CASE(Add_Output_Add_Cast_Cast_Output, framework::DatasetMode::ALL)
{
    /* Computation:
     *   out_0 = in_0 + in_1
     *   out_1 = float(int32_t(out_0 + in_2))
     */
    CLScheduler::get().default_reinit();

    const auto data_type     = DataType::F32;
    const auto t_input_shape = TensorShape(3, 8, 5);

    // Create a new workload sketch
    auto              cl_compile_ctx = CLKernelLibrary::get().get_compile_context();
    auto              context        = GpuWorkloadContext{&cl_compile_ctx};
    GpuWorkloadSketch sketch{&context};

    ITensorInfo *in_0_info = context.create_tensor_info(t_input_shape, 1, data_type);
    ITensorInfo *in_1_info = context.create_tensor_info(t_input_shape, 1, data_type);
    ITensorInfo *in_2_info = context.create_tensor_info(t_input_shape, 1, data_type);

    ITensorInfo *out_0_info = context.create_tensor_info();
    ITensorInfo *out_1_info = context.create_tensor_info();

    CastAttributes cast_0_attr;
    cast_0_attr.data_type(DataType::F16);

    CastAttributes cast_1_attr;
    cast_1_attr.data_type(DataType::F32);

    ITensorInfo *ans_0_info = GpuAdd::create_op(sketch, in_0_info, in_1_info);
    GpuOutput::create_op(sketch, ans_0_info, out_0_info);
    ITensorInfo *ans_1_info = GpuAdd::create_op(sketch, ans_0_info, in_2_info);
    ITensorInfo *ans_2_info = GpuCast::create_op(sketch, ans_1_info, cast_0_attr);
    ITensorInfo *ans_3_info = GpuCast::create_op(sketch, ans_2_info, cast_1_attr);
    GpuOutput::create_op(sketch, ans_3_info, out_1_info);

    // Configure runtime
    ClWorkloadRuntime runtime;
    runtime.configure(sketch);

    // (Important) Allocate auxiliary tensor memory if there are any
    // Instead of using ACL allocated memory, the user can choose to import memory into the tensors
    for (auto &data : runtime.get_auxiliary_tensors())
    {
        CLTensor     *tensor      = std::get<0>(data);
        TensorInfo    info        = std::get<1>(data);
        AuxMemoryInfo aux_mem_req = std::get<2>(data);
        tensor->allocator()->init(info, aux_mem_req.alignment);
        tensor->allocator()->allocate(); // Use ACL allocated memory
        // auto buf = cl::Buffer();
        // tensor->allocator()->import_memory(buf);  // Or, import external memory
    }

    // Construct user tensors
    CLTensor t_in_0{};
    CLTensor t_in_1{};
    CLTensor t_in_2{};

    CLTensor t_out_0{};
    CLTensor t_out_1{};

    // Initialize user tensors
    t_in_0.allocator()->init(*in_0_info);
    t_in_1.allocator()->init(*in_1_info);
    t_in_2.allocator()->init(*in_2_info);

    t_out_0.allocator()->init(*out_0_info);
    t_out_1.allocator()->init(*out_1_info);

    // Allocate and fill user tensors
    // Instead of using ACL allocator, the user can choose to import memory into the tensors
    t_in_0.allocator()->allocate();
    t_in_1.allocator()->allocate();
    t_in_2.allocator()->allocate();

    t_out_0.allocator()->allocate();
    t_out_1.allocator()->allocate();

    fill<float>(CLAccessor(t_in_0), 0, library.get());
    fill<float>(CLAccessor(t_in_1), 1, library.get());
    fill<float>(CLAccessor(t_in_2), 2, library.get());

    // Run runtime
    runtime.run({&t_in_0, &t_in_1, &t_in_2, &t_out_0, &t_out_1});

    // Create reference
    SimpleTensor<float> ref_t_in_0{t_input_shape, data_type, 1, QuantizationInfo()};
    SimpleTensor<float> ref_t_in_1{t_input_shape, data_type, 1, QuantizationInfo()};
    SimpleTensor<float> ref_t_in_2{t_input_shape, data_type, 1, QuantizationInfo()};

    SimpleTensor<float> ref_t_out_0{t_input_shape, data_type, 1, QuantizationInfo()};
    SimpleTensor<float> ref_t_ans_1{t_input_shape, data_type, 1, QuantizationInfo()};

    // Fill reference
    fill<float>(ref_t_in_0, 0, library.get());
    fill<float>(ref_t_in_1, 1, library.get());
    fill<float>(ref_t_in_2, 2, library.get());

    reference::arithmetic_operation(ArithmeticOperation::ADD, ref_t_in_0, ref_t_in_1, ref_t_out_0, ConvertPolicy::WRAP);
    reference::arithmetic_operation(ArithmeticOperation::ADD, ref_t_out_0, ref_t_in_2, ref_t_ans_1,
                                    ConvertPolicy::WRAP);
    const auto ref_t_ans_2 =
        reference::depth_convert<float, int32_t>(ref_t_ans_1, DataType::S32, ConvertPolicy::SATURATE, 0);
    const auto ref_t_out_1 =
        reference::depth_convert<int32_t, float>(ref_t_ans_2, DataType::F32, ConvertPolicy::SATURATE, 0);

    RelativeTolerance<float> tolerance_add_f32(0.001f);
    AbsoluteTolerance<float> tolerance_cast_f32(1.0f);
    validate(CLAccessor(t_out_0), ref_t_out_0, tolerance_add_f32);
    validate(CLAccessor(t_out_1), ref_t_out_1, tolerance_cast_f32);
}

/// TODO: COMPMID-6593 : This integration test fails with CKW backend.
/// It was not enabled for CKW before, therefore went unnoticed.
TEST_CASE(Conv2d_Sigmoid_DepthwiseConv2d_Mul, framework::DatasetMode::DISABLED)
{
    //   (tensor0)
    //       |
    // ======|============================================== Sketch 0
    //       |     (tensor1)     +---- (tensor2)
    //       |         |         |         |
    // +-- input -- weights -- biases --+  |
    // |                                |  |
    // |            Conv2d              |  |
    // |                                |  |
    // +----------- output -------------+  |
    //                |                    |
    //          +-- input ---+             |
    //          |            |             |
    //          |  Sigmoid   |             |
    //          |            |             |
    //          +-- output --+             |
    //                |                    |
    //          +-- input ---+             |
    //          |            |             |
    //          |   Output   |             |
    //          |            |             |
    //          +-- output --+             |
    //                |                    |
    //            (tensor5)                |
    //                |                    |
    //       +--------+                    |
    // ======|=============================|================ Sketch 1
    //       |     (tensor3) (tensor4)     |
    //       |         |         |         |
    // +-- input -- weights -- biases --+  |
    // |                                |  |
    // |        DepthwiseConv2d         |  |
    // |                                |  |
    // +----------- output -------------+  |
    //                |                    |
    //             +--+   +----------------+
    //             |      |
    //        +-- lhs -- rhs --+
    //        |                |
    //        |    Multiply    |
    //        |                |
    //        +---- output ----+
    //                |
    //          +-- input ---+
    //          |            |
    //          |   Output   |
    //          |            |
    //          +-- output --+
    //                |
    //            (tensor6)

    TensorShape conv2d_src_shape(10, 20, 30);
    TensorShape conv2d_wei_shape(10, 3, 3, 5);
    TensorShape conv2d_bia_shape(5);
    TensorShape conv2d_dst_shape(5, 18, 28);
    TensorShape dwc_wei_shape(5, 3, 3);
    TensorShape dwc_bia_shape(5);
    TensorShape dwc_dst_shape(5, 16, 26);

    // Initialize the context.
    CLScheduler::get().default_reinit();

    auto               cl_compile_ctx = CLKernelLibrary::get().get_compile_context();
    GpuWorkloadContext context(&cl_compile_ctx);

    auto tensor0_info = context.create_tensor_info(conv2d_src_shape, 1, DataType::F32, DataLayout::NHWC);

    // Create the first sketch: conv2d + cast + output.
    GpuWorkloadSketch sketch0(&context);

    Conv2dAttributes conv2d_attr;
    auto             tensor1_info = context.create_tensor_info(conv2d_wei_shape, 1, DataType::F32, DataLayout::NHWC);
    auto             tensor2_info = context.create_tensor_info(conv2d_bia_shape, 1, DataType::F32, DataLayout::NHWC);
    ARM_COMPUTE_EXPECT(GpuConv2d::validate_op(sketch0, tensor0_info, tensor1_info, tensor2_info, conv2d_attr),
                       framework::LogLevel::ERRORS);
    auto ans_info = GpuConv2d::create_op(sketch0, tensor0_info, tensor1_info, tensor2_info, conv2d_attr);

    ARM_COMPUTE_EXPECT(GpuSigmoid::validate_op(sketch0, ans_info), framework::LogLevel::ERRORS);
    ans_info = GpuSigmoid::create_op(sketch0, ans_info);

    DepthwiseConv2dAttributes dwc_attr;
    auto tensor3_info = context.create_tensor_info(dwc_wei_shape, 1, DataType::F32, DataLayout::NHWC);
    auto tensor4_info = context.create_tensor_info(dwc_bia_shape, 1, DataType::F32, DataLayout::NHWC);
    ARM_COMPUTE_EXPECT(!GpuDepthwiseConv2d::validate_op(sketch0, ans_info, tensor3_info, tensor4_info, dwc_attr),
                       framework::LogLevel::ERRORS);

    auto tensor5_info = context.create_tensor_info();
    ARM_COMPUTE_EXPECT(GpuOutput::validate_op(sketch0, ans_info, tensor5_info), framework::LogLevel::ERRORS);
    GpuOutput::create_op(sketch0, ans_info, tensor5_info);

    // Create the first workload runtime.
    ClWorkloadRuntime runtime0;
    runtime0.configure(sketch0);

    // Create the second sketch: dwc + sigmoid + output.
    GpuWorkloadSketch sketch1(&context);

    ARM_COMPUTE_EXPECT(GpuDepthwiseConv2d::validate_op(sketch1, tensor5_info, tensor3_info, tensor4_info, dwc_attr),
                       framework::LogLevel::ERRORS);
    ans_info = GpuDepthwiseConv2d::create_op(sketch1, tensor5_info, tensor3_info, tensor4_info, dwc_attr);

    ARM_COMPUTE_EXPECT(GpuMul::validate_op(sketch1, ans_info, tensor2_info), framework::LogLevel::ERRORS);
    ans_info = GpuMul::create_op(sketch1, ans_info, tensor2_info);

    auto tensor6_info = context.create_tensor_info();
    ARM_COMPUTE_EXPECT(GpuOutput::validate_op(sketch1, ans_info, tensor6_info), framework::LogLevel::ERRORS);
    GpuOutput::create_op(sketch1, ans_info, tensor6_info);

    // Create the second workload runtime.
    ClWorkloadRuntime runtime1;
    runtime1.configure(sketch1);

    // Create the user tensors.
    CLTensor tensor0;
    CLTensor tensor1;
    CLTensor tensor2;
    CLTensor tensor3;
    CLTensor tensor4;
    CLTensor tensor5;
    CLTensor tensor6;

    tensor0.allocator()->init(*tensor0_info);
    tensor1.allocator()->init(*tensor1_info);
    tensor2.allocator()->init(*tensor2_info);
    tensor3.allocator()->init(*tensor3_info);
    tensor4.allocator()->init(*tensor4_info);
    tensor5.allocator()->init(*tensor5_info);
    tensor6.allocator()->init(*tensor6_info);

    tensor0.allocator()->allocate();
    tensor1.allocator()->allocate();
    tensor2.allocator()->allocate();
    tensor3.allocator()->allocate();
    tensor4.allocator()->allocate();
    tensor5.allocator()->allocate();
    tensor6.allocator()->allocate();

    // Allocate the auxiliary tensors.
    for (auto &data : runtime0.get_auxiliary_tensors())
    {
        auto  tensor      = std::get<0>(data);
        auto &tensor_info = std::get<1>(data);
        auto  mem_req     = std::get<2>(data);

        tensor->allocator()->init(tensor_info, mem_req.alignment);
        tensor->allocator()->allocate();
    }

    for (auto &data : runtime1.get_auxiliary_tensors())
    {
        auto  tensor      = std::get<0>(data);
        auto &tensor_info = std::get<1>(data);
        auto  mem_req     = std::get<2>(data);

        tensor->allocator()->init(tensor_info, mem_req.alignment);
        tensor->allocator()->allocate();
    }

    // Fill the input tensors with random data.
    fill<float>(CLAccessor(tensor0), 0, library.get());
    fill<float>(CLAccessor(tensor1), 1, library.get());
    fill<float>(CLAccessor(tensor2), 2, library.get());
    fill<float>(CLAccessor(tensor3), 3, library.get());
    fill<float>(CLAccessor(tensor4), 4, library.get());

    // Run each runtime.
    runtime0.run({&tensor0, &tensor1, &tensor2, &tensor5});
    runtime1.run({&tensor5, &tensor3, &tensor4, &tensor2, &tensor6});

    // Compute the reference result.
    SimpleTensor<float> ref_conv2d_src(conv2d_src_shape, DataType::F32, 1, QuantizationInfo(), DataLayout::NHWC);
    SimpleTensor<float> ref_conv2d_wei(conv2d_wei_shape, DataType::F32, 1, QuantizationInfo(), DataLayout::NHWC);
    SimpleTensor<float> ref_conv2d_bia(conv2d_bia_shape, DataType::F32, 1, QuantizationInfo(), DataLayout::NHWC);
    SimpleTensor<float> ref_dwc_wei(dwc_wei_shape, DataType::F32, 1, QuantizationInfo(), DataLayout::NHWC);
    SimpleTensor<float> ref_dwc_bia(dwc_bia_shape, DataType::F32, 1, QuantizationInfo(), DataLayout::NHWC);

    fill<float>(ref_conv2d_src, 0, library.get());
    fill<float>(ref_conv2d_wei, 1, library.get());
    fill<float>(ref_conv2d_bia, 2, library.get());
    fill<float>(ref_dwc_wei, 3, library.get());
    fill<float>(ref_dwc_bia, 4, library.get());

    PermutationVector nhwc_to_nchw(1, 2, 0);

    auto conv2d_dst_shape_nchw = conv2d_dst_shape;
    permute(conv2d_dst_shape_nchw, nhwc_to_nchw);
    const auto ref_conv2d_src_nchw = reference::permute(ref_conv2d_src, nhwc_to_nchw);
    const auto ref_conv2d_wei_nchw = reference::permute(ref_conv2d_wei, nhwc_to_nchw);
    const auto ref_conv2d_bia_nchw = reference::permute(ref_conv2d_bia, nhwc_to_nchw);
    const auto ref_conv2d_dst_nchw = reference::convolution_layer(
        ref_conv2d_src_nchw, ref_conv2d_wei_nchw, ref_conv2d_bia_nchw, conv2d_dst_shape_nchw, PadStrideInfo());

    const auto ref_sigmoid_dst_nchw = reference::activation_layer(
        ref_conv2d_dst_nchw, ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::LOGISTIC));

    auto dwc_dst_shape_nchw = dwc_dst_shape;
    permute(dwc_dst_shape_nchw, nhwc_to_nchw);
    const auto ref_dwc_wei_nchw = reference::permute(ref_dwc_wei, nhwc_to_nchw);
    const auto ref_dwc_bia_nchw = reference::permute(ref_dwc_bia, nhwc_to_nchw);
    const auto ref_dwc_dst_nchw = reference::depthwise_convolution(
        ref_sigmoid_dst_nchw, ref_dwc_wei_nchw, ref_dwc_bia_nchw, dwc_dst_shape_nchw, PadStrideInfo(), 1);

    const auto ref_mul_dst_nchw = reference::pixel_wise_multiplication<float, float, float>(
        ref_dwc_dst_nchw, ref_conv2d_bia_nchw, 1.0, ConvertPolicy::SATURATE, RoundingPolicy::TO_NEAREST_UP,
        DataType::F32);

    constexpr RelativeTolerance<float> tolerance(0.001f);
    validate(CLAccessor(tensor6), ref_mul_dst_nchw, tolerance);
}

TEST_SUITE(Invalid_Fusion_Should_Fail)
TEST_CASE(Multiple_Complex_Ops_0, framework::DatasetMode::ALL)
{
    /* Computation:
     * out = conv2d(conv2d(l0_input, l0_weight), l1_weight)
     */
    CLScheduler::get().default_reinit();

    const auto data_type      = DataType::F32;
    const auto data_layout    = DataLayout::NHWC;
    const auto t_input_shape  = TensorShape(384, 12, 12);
    const auto t_weight_shape = TensorShape(384, 1, 1, 16);
    auto       t_input_info   = TensorInfo(t_input_shape, 1, data_type, data_layout);
    auto       t_weight_info  = TensorInfo(t_weight_shape, 1, data_type, data_layout);
    auto       t_dst_info     = TensorInfo();

    Conv2dAttributes conv2d_attr{};

    // Create a new workload sketch
    auto              cl_compile_ctx = CLKernelLibrary::get().get_compile_context();
    auto              context        = GpuWorkloadContext{&cl_compile_ctx};
    GpuWorkloadSketch sketch{&context};

    // Create tensor infos
    ITensorInfo *input_info  = context.create_tensor_info(t_input_shape, 1, data_type, data_layout);
    ITensorInfo *weight_info = context.create_tensor_info(TensorInfo(t_weight_shape, 1, data_type, data_layout));
    ITensorInfo *dst_info;

    // Fuse conv2d into the workload
    {
        // Validate operator
        const Status success = GpuConv2d::validate_op(sketch, input_info, weight_info, nullptr, conv2d_attr);
        ARM_COMPUTE_EXPECT(bool(success), framework::LogLevel::ERRORS);

        dst_info = GpuConv2d::create_op(sketch, input_info, weight_info, nullptr, conv2d_attr);
    }

    // Create tensor infos
    ITensorInfo *weight_info_2 = context.create_tensor_info(t_weight_info);

    // Fuse conv2d into the workload
    {
        // Validate operator, should fail
        const Status success          = GpuConv2d::validate_op(sketch, dst_info, weight_info_2, nullptr, conv2d_attr);
        const auto expected_error_str = "Operator fusion test failed. This operator cannot be fused into the workload";

        ARM_COMPUTE_EXPECT(!bool(success), framework::LogLevel::ERRORS);
        ARM_COMPUTE_EXPECT((success.error_description().find(expected_error_str) != std::string::npos),
                           framework::LogLevel::ERRORS);
    }
}
TEST_SUITE_END() // Invalid_Fusion_Should_Fail
TEST_SUITE_END() // DYNAMIC_FUSION
TEST_SUITE_END() // INTEGRATION
TEST_SUITE_END() // CL
} // namespace validation
} // namespace test
} // namespace arm_compute