107 lines
4.0 KiB
C++
107 lines
4.0 KiB
C++
/*
|
|
* Copyright (C) 2020 The Android Open Source Project
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#include <android-base/scopeguard.h>
|
|
#include <gtest/gtest.h>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include "Telemetry.h"
|
|
#include "TestNeuralNetworksWrapper.h"
|
|
|
|
using android::nn::telemetry::DataClass;
|
|
using android::nn::test_wrapper::Compilation;
|
|
using android::nn::test_wrapper::Execution;
|
|
using android::nn::test_wrapper::Model;
|
|
using android::nn::test_wrapper::OperandType;
|
|
using android::nn::test_wrapper::Result;
|
|
using android::nn::test_wrapper::Type;
|
|
|
|
namespace {
|
|
|
|
typedef float Matrix3x4[3][4];
|
|
|
|
class TelemetryTest : public ::testing::Test {};
|
|
|
|
TEST_F(TelemetryTest, TestAtomGeneration) {
|
|
std::atomic_uint executions = 0;
|
|
std::atomic_uint compilations = 0;
|
|
|
|
android::nn::telemetry::registerTelemetryCallbacks(
|
|
[&compilations](const android::nn::telemetry::DiagnosticCompilationInfo*) {
|
|
compilations++;
|
|
},
|
|
[&executions](const android::nn::telemetry::DiagnosticExecutionInfo*) {
|
|
executions++;
|
|
});
|
|
|
|
Model modelAdd2;
|
|
OperandType matrixType(Type::TENSOR_FLOAT32, {3, 4});
|
|
OperandType scalarType(Type::INT32, {});
|
|
auto a = modelAdd2.addOperand(&matrixType);
|
|
auto b = modelAdd2.addOperand(&matrixType);
|
|
auto c = modelAdd2.addOperand(&matrixType);
|
|
auto d = modelAdd2.addConstantOperand(&scalarType, ANEURALNETWORKS_FUSED_NONE);
|
|
modelAdd2.addOperation(ANEURALNETWORKS_ADD, {a, b, d}, {c});
|
|
modelAdd2.identifyInputsAndOutputs({a, b}, {c});
|
|
ASSERT_TRUE(modelAdd2.isValid());
|
|
modelAdd2.finish();
|
|
|
|
Matrix3x4 matrix;
|
|
memset(&matrix, 0, sizeof(matrix));
|
|
Compilation compilation(&modelAdd2);
|
|
compilation.finish();
|
|
Execution execution(&compilation);
|
|
ASSERT_EQ(execution.setInput(0, matrix, sizeof(Matrix3x4)), Result::NO_ERROR);
|
|
ASSERT_EQ(execution.setInput(1, matrix, sizeof(Matrix3x4)), Result::NO_ERROR);
|
|
ASSERT_EQ(execution.setOutput(0, matrix, sizeof(Matrix3x4)), Result::NO_ERROR);
|
|
ASSERT_EQ(execution.compute(), Result::NO_ERROR);
|
|
ASSERT_EQ(executions, 1u);
|
|
ASSERT_EQ(compilations, 1u);
|
|
|
|
android::nn::telemetry::clearTelemetryCallbacks();
|
|
}
|
|
|
|
TEST_F(TelemetryTest, TestEvalDataClass) {
|
|
std::vector<std::pair<DataClass, std::vector<android::nn::OperandType>>> data = {
|
|
{DataClass::FLOAT32, {android::nn::OperandType::TENSOR_FLOAT32}},
|
|
{DataClass::FLOAT32,
|
|
{android::nn::OperandType::TENSOR_FLOAT32, android::nn::OperandType::FLOAT32}},
|
|
{DataClass::FLOAT32,
|
|
{android::nn::OperandType::FLOAT32, android::nn::OperandType::TENSOR_FLOAT32}},
|
|
{DataClass::OTHER, {android::nn::OperandType::FLOAT32}},
|
|
{DataClass::UNKNOWN, {}},
|
|
{DataClass::FLOAT16,
|
|
{android::nn::OperandType::FLOAT32, android::nn::OperandType::TENSOR_FLOAT16,
|
|
android::nn::OperandType::TENSOR_INT32}},
|
|
{DataClass::MIXED,
|
|
{android::nn::OperandType::FLOAT32, android::nn::OperandType::TENSOR_FLOAT16,
|
|
android::nn::OperandType::TENSOR_FLOAT32}},
|
|
{DataClass::QUANT,
|
|
{android::nn::OperandType::FLOAT32, android::nn::OperandType::TENSOR_QUANT8_ASYMM}},
|
|
};
|
|
|
|
for (auto& pair : data) {
|
|
DataClass result = DataClass::UNKNOWN;
|
|
for (auto v : pair.second) {
|
|
result = android::nn::telemetry::evalDataClass(v, result);
|
|
}
|
|
ASSERT_EQ(result, pair.first);
|
|
}
|
|
}
|
|
|
|
} // namespace
|