Function BuildAndRunNetwork

src/armnn/test/optimizations/FoldPadTests.cpp:1125–1200

This builds and runs the following model Input-> Pad ->(Pool2D | Conv2D ) -> Output

// Input-> Pad ->(Pool2D | Conv2D ) -> Output
//
static bool 
BuildAndRunNetwork
(
    FoldOptimizationTestArgs const   &arg
)
{
    bool ok{false};
    try
    {
        auto network    = INetwork::Create();

        // add input layer
        auto inputLayer = network->AddInputLayer(0, "input");
        {
            const uint32_t  inputShape[]  = {1, arg.tensorH, arg.tensorW, 1};
            TensorInfo      inputInfo(4, inputShape, DataType::Float32);
            inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
        }

        // add pad layer
        PadDescriptor padDesc({ {0, 0},
                                {arg.pad.top, arg.pad.bottom},
                                {arg.pad.left, arg.pad.right},
                                {0, 0}
                            });
        auto padLayer = network->AddPadLayer(padDesc, "Pad");

        {
            uint32_t        padedH      = arg.tensorH + arg.pad.top  + arg.pad.bottom;
            uint32_t        padedW      = arg.tensorW + arg.pad.left + arg.pad.right;
            const uint32_t  padShape[]  = {1, padedH, padedW, 1};
            TensorInfo      padInfo(4, padShape, DataType::Float32);
            padLayer->GetOutputSlot(0).SetTensorInfo(padInfo);
        }
        
         //create the op layer
        IConnectableLayer   *opLayer{ CreateLayer(network, arg, false) };
        TensorInfo          outputInfo(4, arg.outputShape, DataType::Float32);
        opLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
        
        auto outputLayer = network->AddOutputLayer(0,"output");

        // connect the layers
        inputLayer->GetOutputSlot(0).Connect(padLayer->GetInputSlot(0));
        padLayer->GetOutputSlot(0).Connect(opLayer->GetInputSlot(0));
        opLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
        
        // init runtime and load net
        IRuntimePtr          runTime          = IRuntime::Create(IRuntime::CreationOptions());    // default options
        IOptimizedNetworkPtr optimizedNetwork = Optimize(*network, {Compute::TosaRef}, runTime->GetDeviceSpec());
        NetworkId            netid{};
        CHECK(runTime->LoadNetwork(netid, std::move(optimizedNetwork)) == Status::Success);

        // setup input tensor
        TensorInfo inputTensorInfo = runTime->GetInputTensorInfo(netid, 0);
        inputTensorInfo.SetConstant(true);
        InputTensors inTensor{{0, ConstTensor(inputTensorInfo, arg.data.data())}};