hvxservice/1.0/HexagonOperationsPrepare.cpp

/*
 * Copyright (C) 2017 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.
 */

#define LOG_TAG "[email protected]"

#include "HexagonModel.h"
#include "HexagonOperations.h"
#include "OperationsUtils.h"

namespace android {
namespace hardware {
namespace neuralnetworks {
namespace V1_0 {
namespace implementation {
namespace hexagon {

using android::nn::Shape;

namespace {
namespace float32 {

bool add(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs, HexagonModel* model) {
    HEXAGON_SOFT_ASSERT_EQ(3, ins.size(), "Need 3 inputs for float32::add");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for float32::add");

    // get parameters
    const hexagon_nn_input& in1 = model->getTensor(ins[0]);
    const hexagon_nn_input& in2 = model->getTensor(ins[1]);

    const op_type act = model->getFloatActivation(ins[2]);

    // add node to graph
    return model->addFusedFloatOperation(OP_Add_f, NN_PAD_NA, {}, act, {in1, in2}, outs);
}

bool average_pool_2d(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
                     HexagonModel* model) {
    HEXAGON_SOFT_ASSERT(ins.size() == 10 || ins.size() == 7,
                        "Need 7 or 10 inputs for float32::average_pool_2d");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for float32::average_pool_2d");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);

    // setup parameters
    hexagon_nn_padding_type pad;
    int32_t stride_width;
    int32_t stride_height;
    int32_t filter_width;
    int32_t filter_height;
    op_type act;

    // get parameters
    if (ins.size() == 10) {
        const int32_t padding_left = model->getScalar<int32_t>(ins[1]);
        const int32_t padding_right = model->getScalar<int32_t>(ins[2]);
        const int32_t padding_top = model->getScalar<int32_t>(ins[3]);
        const int32_t padding_bottom = model->getScalar<int32_t>(ins[4]);
        stride_width = model->getScalar<int32_t>(ins[5]);
        stride_height = model->getScalar<int32_t>(ins[6]);
        filter_width = model->getScalar<int32_t>(ins[7]);
        filter_height = model->getScalar<int32_t>(ins[8]);
        act = model->getFloatActivation(ins[9]);

        const Shape inputShape = model->getShape(ins[0]);
        pad = getPadding(inputShape.dimensions[2], inputShape.dimensions[1], stride_width,
                         stride_height, filter_width, filter_height, padding_left, padding_right,
                         padding_top, padding_bottom);
        HEXAGON_SOFT_ASSERT_NE(pad, NN_PAD_NA, "Unknown padding");
    } else {
        pad = model->getPadding(ins[1]);
        stride_width = model->getScalar<int32_t>(ins[2]);
        stride_height = model->getScalar<int32_t>(ins[3]);
        filter_width = model->getScalar<int32_t>(ins[4]);
        filter_height = model->getScalar<int32_t>(ins[5]);
        act = model->getFloatActivation(ins[6]);
    }

    const hexagon_nn_input window = model->createShape(1, filter_height, filter_width, 1);
    const hexagon_nn_input stride = model->createShape(1, stride_height, stride_width, 1);

    // add node to graph
    return model->addFloatOperationWithActivation(OP_AvgPool_f, pad, act, {input, window, stride},
                                                  outs);
}

bool concatenation(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
                   HexagonModel* model) {
    HEXAGON_SOFT_ASSERT_LE(3, ins.size(), "Need at least 3 inputs for float32::concatenation");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for float32::concatenation");

    const size_t numInputTensors = ins.size() - 1;

    // get parameters
    std::vector<hexagon_nn_input> inputs(numInputTensors + 1);
    for (size_t i = 0; i < numInputTensors; ++i) {
        inputs[i + 1] = model->getTensor(ins[i]);
    }

    // axis being concatenated
    const int32_t axis = model->getScalar<int32_t>(ins[numInputTensors]);
    const int32_t dims = model->getShape(ins[0]).dimensions.size();
    inputs[0] = model->createScalar<int32_t>(axis + (4 - dims));

    // add node to graph
    return model->addBasicOperation(OP_Concat_f, NN_PAD_NA, inputs, outs);
}

bool conv_2d(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
             HexagonModel* model) {
    HEXAGON_SOFT_ASSERT(ins.size() == 10 || ins.size() == 7,
                        "Need 7 or 10 inputs for float32::conv_2d");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for float32::conv_2d");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);
    const hexagon_nn_input filter = model->createConvFilterTensor(ins[1]);
    const hexagon_nn_input& bias = model->getTensor(ins[2]);

    // setup parameters
    hexagon_nn_padding_type pad;
    int32_t stride_width;
    int32_t stride_height;
    op_type act;

    // get parameters
    if (ins.size() == 10) {
        const int32_t padding_left = model->getScalar<int32_t>(ins[3]);
        const int32_t padding_right = model->getScalar<int32_t>(ins[4]);
        const int32_t padding_top = model->getScalar<int32_t>(ins[5]);
        const int32_t padding_bottom = model->getScalar<int32_t>(ins[6]);
        stride_width = model->getScalar<int32_t>(ins[7]);
        stride_height = model->getScalar<int32_t>(ins[8]);
        act = model->getFloatActivation(ins[9]);

        const Shape inputShape = model->getShape(ins[0]);
        const Shape filterShape = model->getShape(ins[1]);
        pad = getPadding(inputShape.dimensions[2], inputShape.dimensions[1], stride_width,
                         stride_height, filterShape.dimensions[2], filterShape.dimensions[1],
                         padding_left, padding_right, padding_top, padding_bottom);
        HEXAGON_SOFT_ASSERT_NE(pad, NN_PAD_NA, "Unknown padding");
    } else {
        pad = model->getPadding(ins[3]);
        stride_width = model->getScalar<int32_t>(ins[4]);
        stride_height = model->getScalar<int32_t>(ins[5]);
        act = model->getFloatActivation(ins[6]);
    }

    const hexagon_nn_input stride = model->createShape(1, stride_height, stride_width, 1);

    // add node to graph
    return model->addFusedFloatOperation(OP_Conv2d_f, pad, bias, act, {input, filter, stride},
                                         outs);
}

bool depthwise_conv_2d(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
                       HexagonModel* model) {
    HEXAGON_SOFT_ASSERT(ins.size() == 11 || ins.size() == 8,
                        "Need 8 or 11 inputs for float32::depthwise_conv_2d");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for float32::depthwise_conv_2d");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);
    const hexagon_nn_input& bias = model->getTensor(ins[2]);

    const Shape filterShape = model->getShape(ins[1]);

    // setup parameters
    hexagon_nn_padding_type pad;
    int32_t stride_width;
    int32_t stride_height;
    int32_t depth_multiplier;
    op_type act;

    // get parameters
    if (ins.size() == 11) {
        const int32_t padding_left = model->getScalar<int32_t>(ins[3]);
        const int32_t padding_right = model->getScalar<int32_t>(ins[4]);
        const int32_t padding_top = model->getScalar<int32_t>(ins[5]);
        const int32_t padding_bottom = model->getScalar<int32_t>(ins[6]);
        stride_width = model->getScalar<int32_t>(ins[7]);
        stride_height = model->getScalar<int32_t>(ins[8]);
        depth_multiplier = model->getScalar<int32_t>(ins[9]);
        act = model->getFloatActivation(ins[10]);

        const Shape inputShape = model->getShape(ins[0]);
        const Shape filterShape = model->getShape(ins[1]);
        pad = getPadding(inputShape.dimensions[2], inputShape.dimensions[1], stride_width,
                         stride_height, filterShape.dimensions[2], filterShape.dimensions[1],
                         padding_left, padding_right, padding_top, padding_bottom);
        HEXAGON_SOFT_ASSERT_NE(pad, NN_PAD_NA, "Unknown padding");
    } else {
        pad = model->getPadding(ins[3]);
        stride_width = model->getScalar<int32_t>(ins[4]);
        stride_height = model->getScalar<int32_t>(ins[5]);
        depth_multiplier = model->getScalar<int32_t>(ins[6]);
        act = model->getFloatActivation(ins[7]);
    }

    const hexagon_nn_input filter = model->createDepthwiseFilterTensor(ins[1], depth_multiplier);
    const hexagon_nn_input stride = model->createShape(1, stride_height, stride_width, 1);

    // add node to graph
    return model->addFusedFloatOperation(OP_DepthwiseConv2d_f, pad, bias, act,
                                         {input, filter, stride}, outs);
}

bool fully_connected(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
                     HexagonModel* model) {
    HEXAGON_SOFT_ASSERT_EQ(4, ins.size(), "Need 4 inputs for float32::fully_connected");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for float32::fully_connected");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);
    const hexagon_nn_input& weights = model->createFullyConnectedWeightTensor(ins[1]);
    const hexagon_nn_input& bias = model->getTensor(ins[2]);

    const op_type act = model->getFloatActivation(ins[3]);

    // add node to graph
    return model->addFusedFloatOperation(OP_MatMul_f, NN_PAD_NA, bias, act, {input, weights}, outs);
}

bool l2_pool_2d(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
                HexagonModel* model) {
    HEXAGON_SOFT_ASSERT(ins.size() == 10 || ins.size() == 7,
                        "Need 7 or 10 inputs for float32::l2_pool_2d");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for float32::l2_pool_2d");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);

    // setup parameters
    hexagon_nn_padding_type pad;
    int32_t stride_width;
    int32_t stride_height;
    int32_t filter_width;
    int32_t filter_height;
    op_type act;

    // get parameters
    if (ins.size() == 10) {
        const int32_t padding_left = model->getScalar<int32_t>(ins[1]);
        const int32_t padding_right = model->getScalar<int32_t>(ins[2]);
        const int32_t padding_top = model->getScalar<int32_t>(ins[3]);
        const int32_t padding_bottom = model->getScalar<int32_t>(ins[4]);
        stride_width = model->getScalar<int32_t>(ins[5]);
        stride_height = model->getScalar<int32_t>(ins[6]);
        filter_width = model->getScalar<int32_t>(ins[7]);
        filter_height = model->getScalar<int32_t>(ins[8]);
        act = model->getFloatActivation(ins[9]);

        const Shape inputShape = model->getShape(ins[0]);
        pad = getPadding(inputShape.dimensions[2], inputShape.dimensions[1], stride_width,
                         stride_height, filter_width, filter_height, padding_left, padding_right,
                         padding_top, padding_bottom);
        HEXAGON_SOFT_ASSERT_NE(pad, NN_PAD_NA, "Unknown padding");
    } else {
        pad = model->getPadding(ins[1]);
        stride_width = model->getScalar<int32_t>(ins[2]);
        stride_height = model->getScalar<int32_t>(ins[3]);
        filter_width = model->getScalar<int32_t>(ins[4]);
        filter_height = model->getScalar<int32_t>(ins[5]);
        act = model->getFloatActivation(ins[6]);
    }

    const hexagon_nn_input window = model->createShape(1, filter_height, filter_width, 1);
    const hexagon_nn_input stride = model->createShape(1, stride_height, stride_width, 1);

    // add node to graph
    return model->addFloatOperationWithActivation(OP_L2Pool_f, pad, act, {input, window, stride},
                                                  outs);
}

bool local_response_normalization(const std::vector<uint32_t>& ins,
                                  const std::vector<uint32_t>& outs, HexagonModel* model) {
    HEXAGON_SOFT_ASSERT_EQ(5, ins.size(),
                           "Need 5 inputs for float32::local_response_normalization");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(),
                           "Need 1 output for float32::local_response_normalization");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);
    const hexagon_nn_input& bias = model->getTensor(ins[2]);
    const hexagon_nn_input& alpha = model->getTensor(ins[3]);
    const hexagon_nn_input& beta = model->getTensor(ins[4]);

    // create value that's [1, 1, 1, radius] with value of 1.0f
    const int32_t radius = model->getScalar<int32_t>(ins[1]);
    const hexagon_nn_input window = model->createTensor<float>(1, 1, 1, radius * 2 + 1, {1.0f});

    // add node to graph
    return model->addBasicOperation(OP_LRN_f, NN_PAD_NA, {input, window, bias, alpha, beta}, outs);
}

bool logistic(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
              HexagonModel* model) {
    HEXAGON_SOFT_ASSERT_EQ(1, ins.size(), "Need 1 input for float32::logistic");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for float32::logistic");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);

    // add node to graph
    return model->addBasicOperation(OP_Sigmoid_f, NN_PAD_NA, {input}, outs);
}

bool max_pool_2d(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
                 HexagonModel* model) {
    HEXAGON_SOFT_ASSERT(ins.size() == 10 || ins.size() == 7,
                        "Need 7 or 10 inputs for float32::max_pool_2d");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for float32::max_pool_2d");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);

    // setup parameters
    hexagon_nn_padding_type pad;
    int32_t stride_width;
    int32_t stride_height;
    int32_t filter_width;
    int32_t filter_height;
    op_type act;

    // get parameters
    if (ins.size() == 10) {
        const int32_t padding_left = model->getScalar<int32_t>(ins[1]);
        const int32_t padding_right = model->getScalar<int32_t>(ins[2]);
        const int32_t padding_top = model->getScalar<int32_t>(ins[3]);
        const int32_t padding_bottom = model->getScalar<int32_t>(ins[4]);
        stride_width = model->getScalar<int32_t>(ins[5]);
        stride_height = model->getScalar<int32_t>(ins[6]);
        filter_width = model->getScalar<int32_t>(ins[7]);
        filter_height = model->getScalar<int32_t>(ins[8]);
        act = model->getFloatActivation(ins[9]);

        const Shape inputShape = model->getShape(ins[0]);
        pad = getPadding(inputShape.dimensions[2], inputShape.dimensions[1], stride_width,
                         stride_height, filter_width, filter_height, padding_left, padding_right,
                         padding_top, padding_bottom);
        HEXAGON_SOFT_ASSERT_NE(pad, NN_PAD_NA, "Unknown padding");
    } else {
        pad = model->getPadding(ins[1]);
        stride_width = model->getScalar<int32_t>(ins[2]);
        stride_height = model->getScalar<int32_t>(ins[3]);
        filter_width = model->getScalar<int32_t>(ins[4]);
        filter_height = model->getScalar<int32_t>(ins[5]);
        act = model->getFloatActivation(ins[6]);
    }

    const hexagon_nn_input window = model->createShape(1, filter_height, filter_width, 1);
    const hexagon_nn_input stride = model->createShape(1, stride_height, stride_width, 1);

    // add node to graph
    return model->addFloatOperationWithActivation(OP_MaxPool_f, pad, act, {input, window, stride},
                                                  outs);
}

bool mul(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs, HexagonModel* model) {
    HEXAGON_SOFT_ASSERT_EQ(3, ins.size(), "Need 3 inputs for float32::mul");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for float32::mul");

    // get parameters
    const hexagon_nn_input& in1 = model->getTensor(ins[0]);
    const hexagon_nn_input& in2 = model->getTensor(ins[1]);

    const op_type act = model->getFloatActivation(ins[2]);

    // add node to graph
    return model->addFusedFloatOperation(OP_Mul_f, NN_PAD_NA, {}, act, {in1, in2}, outs);
}

bool relu(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
          HexagonModel* model) {
    HEXAGON_SOFT_ASSERT_EQ(1, ins.size(), "Need 1 input for float32::relu");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for float32::relu");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);

    // add node to graph
    return model->addBasicOperation(OP_Relu_f, NN_PAD_NA, {input}, outs);
}

bool relu1(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
           HexagonModel* model) {
    HEXAGON_SOFT_ASSERT_EQ(1, ins.size(), "Need 1 input for float32::relu1");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for float32::relu1");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);
    const hexagon_nn_input min = model->createScalar(-1.0f);
    const hexagon_nn_input max = model->createScalar(1.0f);

    // add node to graph
    return model->addBasicOperation(OP_Clamp_f, NN_PAD_NA, {input, min, max}, outs);
}

bool relu6(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
           HexagonModel* model) {
    HEXAGON_SOFT_ASSERT_EQ(1, ins.size(), "Need 1 input for float32::relu6");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for float32::relu6");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);
    const hexagon_nn_input max = model->createScalar(6.0f);

    // add node to graph
    return model->addBasicOperation(OP_ReluX_f, NN_PAD_NA, {input, max}, outs);
}

bool reshape(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
             HexagonModel* model) {
    HEXAGON_SOFT_ASSERT_EQ(2, ins.size(), "Need 2 inputs for float32::reshape");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for float32::reshape");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);
    const hexagon_nn_input& newdims = model->getTensor(ins[1]);

    // add node to graph
    return model->addBasicOperation(OP_Reshape, NN_PAD_NA, {input, newdims}, outs);
}

bool resize_bilinear(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
                     HexagonModel* model) {
    HEXAGON_SOFT_ASSERT_EQ(3, ins.size(), "Need 3 inputs for float32::resize_bilinear");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for float32::resize_bilinear");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);

    const int32_t width = model->getScalar<int32_t>(ins[1]);
    const int32_t height = model->getScalar<int32_t>(ins[2]);

    const hexagon_nn_input newdim = model->createValues<int32_t>({height, width});

    // add node to graph
    return model->addBasicOperation(OP_ResizeBilinear_f, NN_PAD_NA, {input, newdim}, outs);
}

bool softmax(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
             HexagonModel* model) {
    HEXAGON_SOFT_ASSERT_EQ(2, ins.size(), "Need 2 inputs for float32::softmax");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for float32::softmax");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);
    const hexagon_nn_input& beta = model->getTensor(ins[1]);

    // add node to graph
    return model->addBasicOperation(OP_Softmax_f, NN_PAD_NA, {input, beta}, outs);
}

bool tanh(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
          HexagonModel* model) {
    HEXAGON_SOFT_ASSERT_EQ(1, ins.size(), "Need 1 input for float32::tanh");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for float32::tanh");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);

    // add node to graph
    return model->addBasicOperation(OP_Tanh_f, NN_PAD_NA, {input}, outs);
}

}  // namespace float32

namespace quant8_asym {

bool add(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs, HexagonModel* model) {
    HEXAGON_SOFT_ASSERT_EQ(3, ins.size(), "Need 3 inputs for quant8_asym::add");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for quant8_asym::add");

    // get parameters
    const hexagon_nn_input& in1 = model->getTensor(ins[0]);
    const hexagon_nn_input& in2 = model->getTensor(ins[1]);

    const op_type act = model->getQuantizedActivation(ins[2]);

    const hexagon_nn_input& in1_min = model->getQuantizationMin(ins[0]);
    const hexagon_nn_input& in1_max = model->getQuantizationMax(ins[0]);
    const hexagon_nn_input& in2_min = model->getQuantizationMin(ins[1]);
    const hexagon_nn_input& in2_max = model->getQuantizationMax(ins[1]);

    // add node to graph
    return model->addFusedQuant8Operation(OP_QuantizedAdd_8p8to32, NN_PAD_NA, {}, act,
                                          {in1, in2, in1_min, in1_max, in2_min, in2_max}, outs);
}

bool average_pool_2d(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
                     HexagonModel* model) {
    HEXAGON_SOFT_ASSERT(ins.size() == 10 || ins.size() == 7,
                        "Need 7 or 10 inputs for quant8_asym::average_pool_2d");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for quant8_asym::average_pool_2d");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);

    // setup parameters
    hexagon_nn_padding_type pad;
    int32_t stride_width;
    int32_t stride_height;
    int32_t filter_width;
    int32_t filter_height;
    op_type act;

    // get parameters
    if (ins.size() == 10) {
        const int32_t padding_left = model->getScalar<int32_t>(ins[1]);
        const int32_t padding_right = model->getScalar<int32_t>(ins[2]);
        const int32_t padding_top = model->getScalar<int32_t>(ins[3]);
        const int32_t padding_bottom = model->getScalar<int32_t>(ins[4]);
        stride_width = model->getScalar<int32_t>(ins[5]);
        stride_height = model->getScalar<int32_t>(ins[6]);
        filter_width = model->getScalar<int32_t>(ins[7]);
        filter_height = model->getScalar<int32_t>(ins[8]);
        act = model->getQuantizedActivation(ins[9]);

        const Shape inputShape = model->getShape(ins[0]);
        pad = getPadding(inputShape.dimensions[2], inputShape.dimensions[1], stride_width,
                         stride_height, filter_width, filter_height, padding_left, padding_right,
                         padding_top, padding_bottom);
        HEXAGON_SOFT_ASSERT_NE(pad, NN_PAD_NA, "Unknown padding");
    } else {
        pad = model->getPadding(ins[1]);
        stride_width = model->getScalar<int32_t>(ins[2]);
        stride_height = model->getScalar<int32_t>(ins[3]);
        filter_width = model->getScalar<int32_t>(ins[4]);
        filter_height = model->getScalar<int32_t>(ins[5]);
        act = model->getQuantizedActivation(ins[6]);
    }

    const hexagon_nn_input& in_min = model->getQuantizationMin(ins[0]);
    const hexagon_nn_input& in_max = model->getQuantizationMax(ins[0]);
    const hexagon_nn_input window = model->createShape(1, filter_height, filter_width, 1);
    const hexagon_nn_input stride = model->createShape(1, stride_height, stride_width, 1);

    // add node to graph
    return model->addQuant8OperationWithActivation(OP_QuantizedAvgPool_8, pad, act,
                                                   {input, in_min, in_max, window, stride}, outs);
}

bool concatenation(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
                   HexagonModel* model) {
    HEXAGON_SOFT_ASSERT_LE(3, ins.size(), "Need at least 3 inputs for quant8_asym::concatenation");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for quant8_asym::concatenation");

    const size_t numInputTensors = ins.size() - 1;

    // get parameters
    std::vector<hexagon_nn_input> inputs(numInputTensors * 3 + 1);
    for (size_t i = 0; i < numInputTensors; ++i) {
        inputs[i + 1 + numInputTensors * 0] = model->getTensor(ins[i]);
        inputs[i + 1 + numInputTensors * 1] = model->getQuantizationMin(ins[i]);
        inputs[i + 1 + numInputTensors * 2] = model->getQuantizationMax(ins[i]);
    }

    // axis being concatenated
    const int32_t axis = model->getScalar<int32_t>(ins[numInputTensors]);
    const int32_t dims = model->getShape(ins[0]).dimensions.size();
    inputs[0] = model->createScalar<int32_t>(axis + (4 - dims));

    // add node to graph
    return model->addBasicOperation(OP_QuantizedConcat_8, NN_PAD_NA, inputs, outs);
}

bool conv_2d(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
             HexagonModel* model) {
    HEXAGON_SOFT_ASSERT(ins.size() == 10 || ins.size() == 7,
                        "Need 7 or 10 inputs for quant8_asym::conv_2d");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for quant8_asym::conv_2d");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);
    const hexagon_nn_input filter = model->createConvFilterTensor(ins[1]);
    const hexagon_nn_input& bias = model->getTensor(ins[2]);

    // setup parameters
    hexagon_nn_padding_type pad;
    int32_t stride_width;
    int32_t stride_height;
    op_type act;

    // get parameters
    if (ins.size() == 10) {
        const int32_t padding_left = model->getScalar<int32_t>(ins[3]);
        const int32_t padding_right = model->getScalar<int32_t>(ins[4]);
        const int32_t padding_top = model->getScalar<int32_t>(ins[5]);
        const int32_t padding_bottom = model->getScalar<int32_t>(ins[6]);
        stride_width = model->getScalar<int32_t>(ins[7]);
        stride_height = model->getScalar<int32_t>(ins[8]);
        act = model->getQuantizedActivation(ins[9]);

        const Shape inputShape = model->getShape(ins[0]);
        const Shape filterShape = model->getShape(ins[1]);
        pad = getPadding(inputShape.dimensions[2], inputShape.dimensions[1], stride_width,
                         stride_height, filterShape.dimensions[2], filterShape.dimensions[1],
                         padding_left, padding_right, padding_top, padding_bottom);
        HEXAGON_SOFT_ASSERT_NE(pad, NN_PAD_NA, "Unknown padding");
    } else {
        pad = model->getPadding(ins[3]);
        stride_width = model->getScalar<int32_t>(ins[4]);
        stride_height = model->getScalar<int32_t>(ins[5]);
        act = model->getQuantizedActivation(ins[6]);
    }

    const hexagon_nn_input& input_min = model->getQuantizationMin(ins[0]);
    const hexagon_nn_input& input_max = model->getQuantizationMax(ins[0]);
    const hexagon_nn_input& filter_min = model->getQuantizationMin(ins[1]);
    const hexagon_nn_input& filter_max = model->getQuantizationMax(ins[1]);
    const hexagon_nn_input& bias_min = model->getQuantizationMin(ins[2]);
    const hexagon_nn_input& bias_max = model->getQuantizationMax(ins[2]);

    const hexagon_nn_input stride = model->createShape(1, stride_height, stride_width, 1);

    // add node to graph
    return model->addFusedQuant8Operation(
        OP_QuantizedConv2d_8x8to32, pad, {bias, bias_min, bias_max}, act,
        {input, filter, input_min, input_max, filter_min, filter_max, stride}, outs);
}

bool depthwise_conv_2d(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
                       HexagonModel* model) {
    HEXAGON_SOFT_ASSERT(ins.size() == 11 || ins.size() == 8,
                        "Need 8 to 11 inputs for quant8_asym::depthwise_conv_2d");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for quant8_asym::depthwise_conv_2d");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);
    const hexagon_nn_input& bias = model->getTensor(ins[2]);

    // setup parameters
    hexagon_nn_padding_type pad;
    int32_t stride_width;
    int32_t stride_height;
    int32_t depth_multiplier;
    op_type act;

    // get parameters
    if (ins.size() == 11) {
        const int32_t padding_left = model->getScalar<int32_t>(ins[3]);
        const int32_t padding_right = model->getScalar<int32_t>(ins[4]);
        const int32_t padding_top = model->getScalar<int32_t>(ins[5]);
        const int32_t padding_bottom = model->getScalar<int32_t>(ins[6]);
        stride_width = model->getScalar<int32_t>(ins[7]);
        stride_height = model->getScalar<int32_t>(ins[8]);
        depth_multiplier = model->getScalar<int32_t>(ins[9]);
        act = model->getQuantizedActivation(ins[10]);

        const Shape inputShape = model->getShape(ins[0]);
        const Shape filterShape = model->getShape(ins[1]);
        pad = getPadding(inputShape.dimensions[2], inputShape.dimensions[1], stride_width,
                         stride_height, filterShape.dimensions[2], filterShape.dimensions[1],
                         padding_left, padding_right, padding_top, padding_bottom);
        HEXAGON_SOFT_ASSERT_NE(pad, NN_PAD_NA, "Unknown padding");
    } else {
        pad = model->getPadding(ins[3]);
        stride_width = model->getScalar<int32_t>(ins[4]);
        stride_height = model->getScalar<int32_t>(ins[5]);
        depth_multiplier = model->getScalar<int32_t>(ins[6]);
        act = model->getQuantizedActivation(ins[7]);
    }

    const hexagon_nn_input& input_min = model->getQuantizationMin(ins[0]);
    const hexagon_nn_input& input_max = model->getQuantizationMax(ins[0]);
    const hexagon_nn_input& filter_min = model->getQuantizationMin(ins[1]);
    const hexagon_nn_input& filter_max = model->getQuantizationMax(ins[1]);
    const hexagon_nn_input& bias_min = model->getQuantizationMin(ins[2]);
    const hexagon_nn_input& bias_max = model->getQuantizationMax(ins[2]);

    const hexagon_nn_input filter = model->createDepthwiseFilterTensor(ins[1], depth_multiplier);
    const hexagon_nn_input stride = model->createShape(1, stride_height, stride_width, 1);

    // add node to graph
    return model->addFusedQuant8Operation(
        OP_QuantizedDepthwiseConv2d_8x8to32, pad, {bias, bias_min, bias_max}, act,
        {input, filter, input_min, input_max, filter_min, filter_max, stride}, outs);
}

bool dequantize(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
                HexagonModel* model) {
    HEXAGON_SOFT_ASSERT_EQ(1, ins.size(), "Need 1 input for quant8_asym::dequantize");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for quant8_asym::dequantize");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);

    const hexagon_nn_input& input_min = model->getQuantizationMin(ins[0]);
    const hexagon_nn_input& input_max = model->getQuantizationMax(ins[0]);

    // add node to graph
    return model->addBasicOperation(OP_Dequantize, NN_PAD_NA, {input, input_min, input_max}, outs);
}

bool fully_connected(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
                     HexagonModel* model) {
    HEXAGON_SOFT_ASSERT_EQ(4, ins.size(), "Need 4 inputs for quant8::fully_connected");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for quant8::fully_connected");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);
    const hexagon_nn_input& weights = model->createFullyConnectedWeightTensor(ins[1]);
    const hexagon_nn_input& bias = model->getTensor(ins[2]);

    const op_type act = model->getQuantizedActivation(ins[3]);

    const hexagon_nn_input& input_min = model->getQuantizationMin(ins[0]);
    const hexagon_nn_input& input_max = model->getQuantizationMax(ins[0]);
    const hexagon_nn_input& weights_min = model->getQuantizationMin(ins[1]);
    const hexagon_nn_input& weights_max = model->getQuantizationMax(ins[1]);
    const hexagon_nn_input& bias_min = model->getQuantizationMin(ins[2]);
    const hexagon_nn_input& bias_max = model->getQuantizationMax(ins[2]);

    // add node to graph
    return model->addFusedQuant8Operation(
        OP_QuantizedMatMul_8x8to32, NN_PAD_NA, {bias, bias_min, bias_max}, act,
        {input, weights, input_min, input_max, weights_min, weights_max}, outs);
}

bool logistic(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
              HexagonModel* model) {
    HEXAGON_SOFT_ASSERT_EQ(1, ins.size(), "Need 1 input for quant8_asym::logistic");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for quant8_asym::logistic");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);

    const hexagon_nn_input& input_min = model->getQuantizationMin(ins[0]);

    // TFLite uses different max value
    const hexagon_nn_input input_max = model->createQuantizationValue(ins[0], 256);

    // add node to graph
    return model->addBasicOperation(OP_QuantizedSigmoid_8, NN_PAD_NA, {input, input_min, input_max},
                                    outs);
}

bool max_pool_2d(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
                 HexagonModel* model) {
    HEXAGON_SOFT_ASSERT(ins.size() == 10 || ins.size() == 7,
                        "Need 7 or 10 inputs for quant8_asym::max_pool_2d");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for quant8_asym::max_pool_2d");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);

    // setup parameters
    hexagon_nn_padding_type pad;
    int32_t stride_width;
    int32_t stride_height;
    int32_t filter_width;
    int32_t filter_height;
    op_type act;

    // get parameters
    if (ins.size() == 10) {
        const int32_t padding_left = model->getScalar<int32_t>(ins[1]);
        const int32_t padding_right = model->getScalar<int32_t>(ins[2]);
        const int32_t padding_top = model->getScalar<int32_t>(ins[3]);
        const int32_t padding_bottom = model->getScalar<int32_t>(ins[4]);
        stride_width = model->getScalar<int32_t>(ins[5]);
        stride_height = model->getScalar<int32_t>(ins[6]);
        filter_width = model->getScalar<int32_t>(ins[7]);
        filter_height = model->getScalar<int32_t>(ins[8]);
        act = model->getQuantizedActivation(ins[9]);

        const Shape inputShape = model->getShape(ins[0]);
        pad = getPadding(inputShape.dimensions[2], inputShape.dimensions[1], stride_width,
                         stride_height, filter_width, filter_height, padding_left, padding_right,
                         padding_top, padding_bottom);
        HEXAGON_SOFT_ASSERT_NE(pad, NN_PAD_NA, "Unknown padding");
    } else {
        pad = model->getPadding(ins[1]);
        stride_width = model->getScalar<int32_t>(ins[2]);
        stride_height = model->getScalar<int32_t>(ins[3]);
        filter_width = model->getScalar<int32_t>(ins[4]);
        filter_height = model->getScalar<int32_t>(ins[5]);
        act = model->getQuantizedActivation(ins[6]);
    }

    const hexagon_nn_input& input_min = model->getQuantizationMin(ins[0]);
    const hexagon_nn_input& input_max = model->getQuantizationMax(ins[0]);
    const hexagon_nn_input window = model->createShape(1, filter_height, filter_width, 1);
    const hexagon_nn_input stride = model->createShape(1, stride_height, stride_width, 1);

    // add node to graph
    return model->addQuant8OperationWithActivation(
        OP_QuantizedMaxPool_8, pad, act, {input, input_min, input_max, window, stride}, outs);
}

bool mul(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs, HexagonModel* model) {
    HEXAGON_SOFT_ASSERT_EQ(3, ins.size(), "Need 3 inputs for quant8_asym::mul");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for quant8_asym::mul");

    // get parameters
    const hexagon_nn_input& in1 = model->getTensor(ins[0]);
    const hexagon_nn_input& in2 = model->getTensor(ins[1]);

    const op_type act = model->getQuantizedActivation(ins[2]);

    const hexagon_nn_input& in1_min = model->getQuantizationMin(ins[0]);
    const hexagon_nn_input& in1_max = model->getQuantizationMax(ins[0]);
    const hexagon_nn_input& in2_min = model->getQuantizationMin(ins[1]);
    const hexagon_nn_input& in2_max = model->getQuantizationMax(ins[1]);

    // add node to graph
    return model->addFusedQuant8Operation(OP_QuantizedMul_8x8to32, NN_PAD_NA, {}, act,
                                          {in1, in2, in1_min, in1_max, in2_min, in2_max}, outs);
}

bool relu(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
          HexagonModel* model) {
    HEXAGON_SOFT_ASSERT_EQ(1, ins.size(), "Need 1 input for quant8_asym::relu");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for quant8_asym::relu");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);

    const hexagon_nn_input& input_min = model->getQuantizationMin(ins[0]);
    const hexagon_nn_input& input_max = model->getQuantizationMax(ins[0]);

    // add node to graph
    return model->addBasicOperation(OP_QuantizedRelu_8, NN_PAD_NA, {input, input_min, input_max},
                                    outs);
}

bool relu1(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
           HexagonModel* model) {
    HEXAGON_SOFT_ASSERT_EQ(1, ins.size(), "Need 1 input for quant8_asym::relu1");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for quant8_asym::relu1");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);
    const hexagon_nn_input min = model->createScalar(-1.0f);
    const hexagon_nn_input max = model->createScalar(1.0f);

    const hexagon_nn_input& input_min = model->getQuantizationMin(ins[0]);
    const hexagon_nn_input& input_max = model->getQuantizationMax(ins[0]);

    // add node to graph
    return model->addBasicOperation(OP_QuantizedClamp_8, NN_PAD_NA,
                                    {input, input_min, input_max, min, max}, outs);
}

bool relu6(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
           HexagonModel* model) {
    HEXAGON_SOFT_ASSERT_EQ(1, ins.size(), "Need 1 input for quant8_asym::relu6");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for quant8_asym::relu6");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);
    const hexagon_nn_input max = model->createScalar(6.0f);

    const hexagon_nn_input& input_min = model->getQuantizationMin(ins[0]);
    const hexagon_nn_input& input_max = model->getQuantizationMax(ins[0]);

    // add node to graph
    return model->addBasicOperation(OP_QuantizedReluX_8, NN_PAD_NA,
                                    {input, input_min, input_max, max}, outs);
}

bool reshape(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
             HexagonModel* model) {
    HEXAGON_SOFT_ASSERT_EQ(2, ins.size(), "Need 2 inputs for quant8_asym::reshape");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for quant8_asym::reshape");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);
    const hexagon_nn_input& newdims = model->getTensor(ins[1]);

    const hexagon_nn_input& input_min = model->getQuantizationMin(ins[0]);
    const hexagon_nn_input& input_max = model->getQuantizationMax(ins[0]);

    // add node to graph
    return model->addBasicOperation(OP_QuantizedReshape, NN_PAD_NA,
                                    {input, newdims, input_min, input_max}, outs);
}

bool softmax(const std::vector<uint32_t>& ins, const std::vector<uint32_t>& outs,
             HexagonModel* model) {
    HEXAGON_SOFT_ASSERT_EQ(2, ins.size(), "Need 2 inputs for quant8_asym::softmax");
    HEXAGON_SOFT_ASSERT_EQ(1, outs.size(), "Need 1 output for quant8_asym::softmax");

    // get parameters
    const hexagon_nn_input& input = model->getTensor(ins[0]);
    const hexagon_nn_input& beta = model->getTensor(ins[1]);

    const hexagon_nn_input& input_min = model->getQuantizationMin(ins[0]);
    const hexagon_nn_input& input_max = model->getQuantizationMax(ins[0]);

    // add node to graph
    return model->addBasicOperation(OP_QuantizedSoftmax_8, NN_PAD_NA,
                                    {input, input_min, input_max, beta}, outs);
}

}  // namespace quant8_asym

}  // namespace

OperationTable& getOperationPrepareTable() {
    static OperationTable table = {
        // NOTE: the operations that are commented out via inline represent
        // operations that are valid for the Android O NNAPI release, but are
        // currently not implemented in HVX.

        // -------------------------- 32-BIT FLOAT ----------------------------
        // HVX is only performant when running on quantized values. Further, as
        // an optimization, the current HVX driver will convert some floating
        // point tensors into quantized values, perform the operation, and then
        // convert them back to floating point. This results in a loss in
        // precision causing some tests to fail. For these reasons, the FLOAT32
        // operations are being temporarily disabled.
        /*
        {{OperationType::ADD, OperandType::TENSOR_FLOAT32}, float32::add},
        {{OperationType::AVERAGE_POOL_2D, OperandType::TENSOR_FLOAT32}, float32::average_pool_2d},
        {{OperationType::CONCATENATION, OperandType::TENSOR_FLOAT32}, float32::concatenation},
        {{OperationType::CONV_2D, OperandType::TENSOR_FLOAT32}, float32::conv_2d},
        {{OperationType::DEPTHWISE_CONV_2D, OperandType::TENSOR_FLOAT32},
          float32::depthwise_conv_2d},
        //{{OperationType::DEPTH_TO_SPACE, OperandType::TENSOR_FLOAT32}, float32::depth_to_space},
        //{{OperationType::EMBEDDING_LOOKUP, OperandType::TENSOR_FLOAT32},
        //  float32::embedding_lookup},
        //{{OperationType::FLOOR, OperandType::TENSOR_FLOAT32}, float32::floor},
        {{OperationType::FULLY_CONNECTED, OperandType::TENSOR_FLOAT32}, float32::fully_connected},
        //{{OperationType::HASHTABLE_LOOKUP, OperandType::TENSOR_FLOAT32},
        //  float32::hashtable_lookup},
        //{{OperationType::L2_NORMALIZATION, OperandType::TENSOR_FLOAT32},
        //  float32::l2_normalization},
        {{OperationType::L2_POOL_2D, OperandType::TENSOR_FLOAT32}, float32::l2_pool_2d},
        {{OperationType::LOCAL_RESPONSE_NORMALIZATION, OperandType::TENSOR_FLOAT32},
          float32::local_response_normalization},
        {{OperationType::LOGISTIC, OperandType::TENSOR_FLOAT32}, float32::logistic},
        //{{OperationType::LSH_PROJECTION, OperandType::TENSOR_FLOAT32}, float32::lsh_projection},
        //{{OperationType::LSTM, OperandType::TENSOR_FLOAT32}, float32::lstm },
        {{OperationType::MAX_POOL_2D, OperandType::TENSOR_FLOAT32}, float32::max_pool_2d},
        {{OperationType::MUL, OperandType::TENSOR_FLOAT32}, float32::mul},
        {{OperationType::RELU, OperandType::TENSOR_FLOAT32}, float32::relu},
        {{OperationType::RELU1, OperandType::TENSOR_FLOAT32}, float32::relu1},
        {{OperationType::RELU6, OperandType::TENSOR_FLOAT32}, float32::relu6},
        {{OperationType::RESHAPE, OperandType::TENSOR_FLOAT32}, float32::reshape},
        {{OperationType::RESIZE_BILINEAR, OperandType::TENSOR_FLOAT32}, float32::resize_bilinear},
        //{{OperationType::RNN, OperandType::TENSOR_FLOAT32}, float32::rnn},
        {{OperationType::SOFTMAX, OperandType::TENSOR_FLOAT32}, float32::softmax},
        //{{OperationType::SPACE_TO_DEPTH, OperandType::TENSOR_FLOAT32}, float32::space_to_depth},
        //{{OperationType::SVDF, OperandType::TENSOR_FLOAT32}, float32::svdf },
        {{OperationType::TANH, OperandType::TENSOR_FLOAT32}, float32::tanh},
        */

        // -------------------- QUANTIZED 8-BIT ASYMMETRICAL ------------------
        {{OperationType::ADD, OperandType::TENSOR_QUANT8_ASYMM}, quant8_asym::add},
        {{OperationType::AVERAGE_POOL_2D, OperandType::TENSOR_QUANT8_ASYMM},
         quant8_asym::average_pool_2d},
        {{OperationType::CONCATENATION, OperandType::TENSOR_QUANT8_ASYMM},
         quant8_asym::concatenation},
        {{OperationType::CONV_2D, OperandType::TENSOR_QUANT8_ASYMM}, quant8_asym::conv_2d},
        {{OperationType::DEPTHWISE_CONV_2D, OperandType::TENSOR_QUANT8_ASYMM},
         quant8_asym::depthwise_conv_2d},
        //{{OperationType::DEPTH_TO_SPACE, OperandType::TENSOR_QUANT8_ASYMM},
        //  quant8_asym::depth_to_space},
        {{OperationType::DEQUANTIZE, OperandType::TENSOR_QUANT8_ASYMM}, quant8_asym::dequantize},
        //{{OperationType::EMBEDDING_LOOKUP, OperandType::TENSOR_QUANT8_ASYMM},
        //  quant8_asym::embedding_lookup},
        {{OperationType::FULLY_CONNECTED, OperandType::TENSOR_QUANT8_ASYMM},
         quant8_asym::fully_connected},
        //{{OperationType::HASHTABLE_LOOKUP, OperandType::TENSOR_QUANT8_ASYMM},
        //  quant8_asym::hashtable_lookup},
        {{OperationType::LOGISTIC, OperandType::TENSOR_QUANT8_ASYMM}, quant8_asym::logistic},
        //{{OperationType::LSH_PROJECTION, OperandType::TENSOR_QUANT8_ASYMM},
        //  quant8_asym::lsh_projection},
        {{OperationType::MAX_POOL_2D, OperandType::TENSOR_QUANT8_ASYMM}, quant8_asym::max_pool_2d},
        {{OperationType::MUL, OperandType::TENSOR_QUANT8_ASYMM}, quant8_asym::mul},
        {{OperationType::RELU, OperandType::TENSOR_QUANT8_ASYMM}, quant8_asym::relu},
        {{OperationType::RELU1, OperandType::TENSOR_QUANT8_ASYMM}, quant8_asym::relu1},
        {{OperationType::RELU6, OperandType::TENSOR_QUANT8_ASYMM}, quant8_asym::relu6},
        {{OperationType::RESHAPE, OperandType::TENSOR_QUANT8_ASYMM}, quant8_asym::reshape},
        {{OperationType::SOFTMAX, OperandType::TENSOR_QUANT8_ASYMM}, quant8_asym::softmax},
        //{{OperationType::SPACE_TO_DEPTH, OperandType::TENSOR_QUANT8_ASYMM},
        //  quant8_asym::space_to_depth},
    };

    // The following functions are normally used by float32, but those
    // operations have been temporarily disabled. Void explicitly marks them as
    // unused, and prevents the compiler from throwing an error.
    (void)float32::add;
    (void)float32::average_pool_2d;
    (void)float32::concatenation;
    (void)float32::conv_2d;
    (void)float32::depthwise_conv_2d;
    (void)float32::fully_connected;
    (void)float32::l2_pool_2d;
    (void)float32::local_response_normalization;
    (void)float32::logistic;
    (void)float32::max_pool_2d;
    (void)float32::mul;
    (void)float32::relu;
    (void)float32::relu1;
    (void)float32::relu6;
    (void)float32::reshape;
    (void)float32::resize_bilinear;
    (void)float32::softmax;
    (void)float32::tanh;

    return table;
}

}  // namespace hexagon
}  // namespace implementation
}  // namespace V1_0
}  // namespace neuralnetworks
}  // namespace hardware
}  // namespace android