src/backends/backendsCommon/test/LayerReleaseConstantDataTest.cpp

//
// Copyright © 2017,2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//

#include <CommonTestUtils.hpp>

#include <Graph.hpp>

#include <armnn/backends/TensorHandle.hpp>
#include <armnn/backends/WorkloadData.hpp>

#include <doctest/doctest.h>

using namespace armnn;
using namespace std;

/////////////////////////////////////////////////////////////////////////////////////////////
// The following test are created specifically to test ReleaseConstantData() method in the Layer
// They build very simple graphs including the layer will be checked.
// Checks weights and biases before the method called and after.
/////////////////////////////////////////////////////////////////////////////////////////////

TEST_SUITE("LayerReleaseConstantDataTest")
{
TEST_CASE("ReleaseBatchNormalizationLayerConstantDataTest")
{
    Graph graph;

    // create the layer we're testing
    BatchNormalizationDescriptor layerDesc;
    layerDesc.m_Eps = 0.05f;
    BatchNormalizationLayer* const layer = graph.AddLayer<BatchNormalizationLayer>(layerDesc, "layer");

    armnn::TensorInfo weightInfo({3}, armnn::DataType::Float32);
    layer->m_Mean     = std::make_unique<ScopedTensorHandle>(weightInfo);
    layer->m_Variance = std::make_unique<ScopedTensorHandle>(weightInfo);
    layer->m_Beta     = std::make_unique<ScopedTensorHandle>(weightInfo);
    layer->m_Gamma    = std::make_unique<ScopedTensorHandle>(weightInfo);
    layer->m_Mean->Allocate();
    layer->m_Variance->Allocate();
    layer->m_Beta->Allocate();
    layer->m_Gamma->Allocate();

    // create extra layers
    Layer* const input = graph.AddLayer<InputLayer>(0, "input");
    Layer* const output = graph.AddLayer<OutputLayer>(0, "output");

    // connect up
    armnn::TensorInfo tensorInfo({2, 3, 1, 1}, armnn::DataType::Float32);
    Connect(input, layer, tensorInfo);
    Connect(layer, output, tensorInfo);

    // check the constants that they are not NULL
    CHECK(layer->m_Mean != nullptr);
    CHECK(layer->m_Variance != nullptr);
    CHECK(layer->m_Beta != nullptr);
    CHECK(layer->m_Gamma != nullptr);

    // free up the constants..
    layer->ReleaseConstantData();

    // check the constants that they are NULL now
    CHECK(layer->m_Mean == nullptr);
    CHECK(layer->m_Variance == nullptr);
    CHECK(layer->m_Beta == nullptr);
    CHECK(layer->m_Gamma == nullptr);

 }

TEST_CASE("ReleaseConvolution2dLayerConstantDataTest")
{
    Graph graph;

    // create the layer we're testing
    Convolution2dDescriptor layerDesc;
    layerDesc.m_PadLeft = 3;
    layerDesc.m_PadRight = 3;
    layerDesc.m_PadTop = 1;
    layerDesc.m_PadBottom = 1;
    layerDesc.m_StrideX = 2;
    layerDesc.m_StrideY = 4;
    layerDesc.m_BiasEnabled = true;

    auto* const convolutionLayer = graph.AddLayer<Convolution2dLayer>(layerDesc, "convolution");
    auto* const weightsLayer = graph.AddLayer<ConstantLayer>("weights");
    auto* const biasLayer = graph.AddLayer<ConstantLayer>("bias");

    TensorInfo weightsInfo = TensorInfo({ 2, 3, 5, 3 }, armnn::DataType::Float32, 1.0, 0.0, true);
    TensorInfo biasInfo = TensorInfo({ 2 }, GetBiasDataType(armnn::DataType::Float32), 1.0, 0.0, true);

    weightsLayer->m_LayerOutput = std::make_shared<ScopedTensorHandle>(weightsInfo);
    biasLayer->m_LayerOutput = std::make_shared<ScopedTensorHandle>(biasInfo);

    weightsLayer->GetOutputSlot(0).SetTensorInfo(weightsInfo);
    biasLayer->GetOutputSlot(0).SetTensorInfo(biasInfo);

    // create extra layers
    Layer* const input = graph.AddLayer<InputLayer>(0, "input");
    Layer* const output = graph.AddLayer<OutputLayer>(0, "output");

    // connect up
    Connect(input, convolutionLayer, TensorInfo({ 2, 3, 8, 16 }, armnn::DataType::Float32));
    weightsLayer->GetOutputSlot().Connect(convolutionLayer->GetInputSlot(1));
    biasLayer->GetOutputSlot().Connect(convolutionLayer->GetInputSlot(2));
    Connect(convolutionLayer, output, TensorInfo({ 2, 2, 2, 10 }, armnn::DataType::Float32));

    // check the constants that they are not NULL
    CHECK(weightsLayer->m_LayerOutput != nullptr);
    CHECK(biasLayer->m_LayerOutput != nullptr);

    // free up the constants.
    convolutionLayer->ReleaseConstantData();

    // check the constants that they are still not NULL
    CHECK(weightsLayer->m_LayerOutput != nullptr);
    CHECK(biasLayer->m_LayerOutput != nullptr);
}

TEST_CASE("ReleaseDepthwiseConvolution2dLayerConstantDataTest")
{
    Graph graph;

    // create the layer we're testing
    DepthwiseConvolution2dDescriptor layerDesc;
    layerDesc.m_PadLeft         = 3;
    layerDesc.m_PadRight        = 3;
    layerDesc.m_PadTop          = 1;
    layerDesc.m_PadBottom       = 1;
    layerDesc.m_StrideX         = 2;
    layerDesc.m_StrideY         = 4;
    layerDesc.m_BiasEnabled     = true;

    auto* const convolutionLayer = graph.AddLayer<DepthwiseConvolution2dLayer>(layerDesc, "convolution");
    auto* const weightsLayer = graph.AddLayer<ConstantLayer>("weights");
    auto* const biasLayer = graph.AddLayer<ConstantLayer>("bias");

    TensorInfo weightsInfo = TensorInfo({ 3, 3, 5, 3 }, armnn::DataType::Float32, 1.0, 0.0, true);
    TensorInfo biasInfo = TensorInfo({ 9 }, GetBiasDataType(armnn::DataType::Float32), 1.0, 0.0, true);

    weightsLayer->m_LayerOutput = std::make_shared<ScopedTensorHandle>(weightsInfo);
    biasLayer->m_LayerOutput = std::make_shared<ScopedTensorHandle>(biasInfo);

    weightsLayer->GetOutputSlot(0).SetTensorInfo(weightsInfo);
    biasLayer->GetOutputSlot(0).SetTensorInfo(biasInfo);

    // create extra layers
    Layer* const input = graph.AddLayer<InputLayer>(0, "input");
    Layer* const output = graph.AddLayer<OutputLayer>(0, "output");

    // connect up
    Connect(input, convolutionLayer, TensorInfo({2, 3, 8, 16}, armnn::DataType::Float32));
    weightsLayer->GetOutputSlot().Connect(convolutionLayer->GetInputSlot(1));
    biasLayer->GetOutputSlot().Connect(convolutionLayer->GetInputSlot(2));
    Connect(convolutionLayer, output, TensorInfo({2, 9, 2, 10}, armnn::DataType::Float32));

    // check the constants that they are not NULL
    CHECK(weightsLayer->m_LayerOutput != nullptr);
    CHECK(biasLayer->m_LayerOutput != nullptr);

    // free up the constants.
    convolutionLayer->ReleaseConstantData();

    // check the constants that they are still not NULL
    CHECK(weightsLayer->m_LayerOutput != nullptr);
    CHECK(biasLayer->m_LayerOutput != nullptr);
}

TEST_CASE("ReleaseFullyConnectedLayerConstantDataTest")
{
    Graph graph;

    // create the layer we're testing
    FullyConnectedDescriptor layerDesc;
    layerDesc.m_BiasEnabled = true;
    layerDesc.m_TransposeWeightMatrix = true;

    auto* const fullyConnectedLayer = graph.AddLayer<FullyConnectedLayer>(layerDesc, "layer");
    auto* const weightsLayer = graph.AddLayer<ConstantLayer>("weights");
    auto* const biasLayer = graph.AddLayer<ConstantLayer>("bias");

    float inputsQScale = 1.0f;
    float outputQScale = 2.0f;

    TensorInfo weightsInfo = TensorInfo({ 7, 20 }, DataType::QAsymmU8, inputsQScale, 0.0, true);
    TensorInfo biasInfo = TensorInfo({ 7 }, GetBiasDataType(DataType::QAsymmU8), inputsQScale, 0.0, true);

    weightsLayer->m_LayerOutput = std::make_shared<ScopedTensorHandle>(weightsInfo);
    biasLayer->m_LayerOutput = std::make_shared<ScopedTensorHandle>(biasInfo);

    weightsLayer->GetOutputSlot(0).SetTensorInfo(weightsInfo);
    biasLayer->GetOutputSlot(0).SetTensorInfo(biasInfo);

    // create extra layers
    Layer* const input = graph.AddLayer<InputLayer>(0, "input");
    Layer* const output = graph.AddLayer<OutputLayer>(0, "output");

    // connect up
    Connect(input, fullyConnectedLayer, TensorInfo({ 3, 1, 4, 5 }, DataType::QAsymmU8, inputsQScale));
    weightsLayer->GetOutputSlot().Connect(fullyConnectedLayer->GetInputSlot(1));
    biasLayer->GetOutputSlot().Connect(fullyConnectedLayer->GetInputSlot(2));
    Connect(fullyConnectedLayer, output, TensorInfo({ 3, 7 }, DataType::QAsymmU8, outputQScale));

    // check the constants that they are not NULL
    CHECK(weightsLayer->m_LayerOutput != nullptr);
    CHECK(biasLayer->m_LayerOutput != nullptr);

    // free up the constants.
    fullyConnectedLayer->ReleaseConstantData();

    // check the constants that they are still not NULL
    CHECK(weightsLayer->m_LayerOutput != nullptr);
    CHECK(biasLayer->m_LayerOutput != nullptr);
}

}