Method Execute

tests/ExecuteNetwork/TfliteExecutor.cpp:227–409

}

std::vector<const void *> TfLiteExecutor::Execute()
{
    TfLiteStatus status;
    std::vector<const void*> results;
    for (unsigned int x = 0; x < m_Params.m_Iterations; x++)
    {
        // Start timer to record inference time in milliseconds.
        const auto start_time = armnn::GetTimeNow();
        // Run the inference
        status = m_TfLiteInterpreter->Invoke();
        if (status != kTfLiteOk)
        {
            LogAndThrow("Failed to execute the inference on the TfLite runtime.. The result was: " +
                        TfLiteStatusToString(status) + ".");
        }
        const auto duration = armnn::GetTimeDuration(start_time);

        // Handle the results.
        for (unsigned int outputIndex = 0; outputIndex < m_TfLiteInterpreter->outputs().size(); ++outputIndex)
        {
            auto tfLiteDelegateOutputId = m_TfLiteInterpreter->outputs()[outputIndex];
            TfLiteIntArray* outputDims = m_TfLiteInterpreter->tensor(tfLiteDelegateOutputId)->dims;
            // If we've been asked to write to a file then set a file output stream. Otherwise, use stdout.
            FILE* outputTensorFile = stdout;
            bool isNumpyOutput = false;
            if (!m_Params.m_OutputTensorFiles.empty())
            {
                isNumpyOutput = m_Params.m_OutputTensorFiles[outputIndex].find(".npy") != std::string::npos;
                outputTensorFile = fopen(m_Params.m_OutputTensorFiles[outputIndex].c_str(), "w");
                if (outputTensorFile == NULL)
                {
                    LogAndThrow("Specified output tensor file, \"" + m_Params.m_OutputTensorFiles[outputIndex] +
                                "\", cannot be created. Defaulting to stdout. Error was: " + std::strerror(errno));
                }
                else
                {
                    ARMNN_LOG(info) << "Writing output " << outputIndex << " of iteration: " << x + 1
                                    << " to file: '" << m_Params.m_OutputTensorFiles[outputIndex] << "'";
                }
            }

            long outputSize = 1;
            for (unsigned int dim = 0; dim < static_cast<unsigned int>(outputDims->size); ++dim)
            {
                outputSize *= outputDims->data[dim];
            }

            // outputDims->data can be a Flexible Array Member (int data[];) in a C extern code in TF common.h
            // TensorShape constructor argument is an unsigned int *
            // so reinterpret_cast is used here to ensure the correct type of data is passed
            armnn::TensorShape shape(static_cast<unsigned int>(outputDims->size),
                                        reinterpret_cast<unsigned int *>(outputDims->data));
            armnn::DataType dataType(GetDataType(*m_TfLiteInterpreter->tensor(tfLiteDelegateOutputId)));

            std::cout << m_TfLiteInterpreter->tensor(tfLiteDelegateOutputId)->name << ": ";
            switch (m_TfLiteInterpreter->tensor(tfLiteDelegateOutputId)->type)
            {
                case kTfLiteFloat32: