blob: d2753ace0759f989c81f1d871a120e4f5bfc17ed [file] [log] [blame]
/*
* 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 "android.hardware.neuralnetworks@1.0-impl-hvx"
#include "HexagonController.h"
#define LOAD_HEXAGON_FUNCTION(name) \
mFn_##name = loadFunction<hexagon_nn_controller_##name##_fn>("hexagon_nn_controller_" #name);
#define CLOSE_HEXAGON_FUNCTION(name) mFn_##name = nullptr;
#define FOR_EACH_FUNCTION(MACRO) \
MACRO(init) \
MACRO(getlog) \
MACRO(snpprint) \
MACRO(set_debug_level) \
MACRO(prepare) \
MACRO(append_node) \
MACRO(append_const_node) \
MACRO(execute_new) \
MACRO(execute) \
MACRO(teardown) \
MACRO(get_perfinfo) \
MACRO(reset_perfinfo) \
MACRO(version) \
MACRO(last_execution_cycles) \
MACRO(GetHexagonBinaryVersion) \
MACRO(PrintLog) \
MACRO(op_name_to_id) \
MACRO(op_id_to_name) \
MACRO(disable_dcvs) \
MACRO(set_powersave_level) \
MACRO(config) \
MACRO(get_dsp_offset) \
MACRO(boost) \
MACRO(slow)
#define CONTROLLER_CHECK(function, ...) \
if (mFn_##function == nullptr) { \
return -1; \
} \
int err = mFn_##function(__VA_ARGS__); \
if (err != 0) { \
return err; \
} \
return 0;
namespace android {
namespace hardware {
namespace neuralnetworks {
namespace V1_0 {
namespace implementation {
namespace hexagon {
const char Controller::kFilename[] = "libhexagon_nn_controller.so";
Controller::Controller() {
openNnlib();
}
Controller::~Controller() {
closeNnlib();
}
bool Controller::openNnlib() {
mHandle = dlopen(kFilename, RTLD_LAZY | RTLD_LOCAL);
HEXAGON_SOFT_ASSERT_NE(mHandle, 0,
"FAILED TO LOAD LIBRARY " /* << kFilename << ": " << dlerror()*/);
FOR_EACH_FUNCTION(LOAD_HEXAGON_FUNCTION)
return true;
}
bool Controller::closeNnlib() {
FOR_EACH_FUNCTION(CLOSE_HEXAGON_FUNCTION)
if (mHandle != nullptr) {
int err = dlclose(mHandle);
mHandle = nullptr;
HEXAGON_SOFT_ASSERT_EQ(err, 0, "FAILED TO CLOSE LIBRARY " << kFilename);
}
return true;
}
bool Controller::resetNnlib() {
return closeNnlib() && openNnlib();
}
Controller& Controller::getInstance() {
static Controller instance{};
return instance;
}
int Controller::init(hexagon_nn_nn_id* g) {
CONTROLLER_CHECK(init, g);
}
int Controller::getlog(hexagon_nn_nn_id id, unsigned char* buf, uint32_t length) {
CONTROLLER_CHECK(getlog, id, buf, length);
}
int Controller::snpprint(hexagon_nn_nn_id id, unsigned char* buf, uint32_t length) {
CONTROLLER_CHECK(snpprint, id, buf, length);
}
int Controller::set_debug_level(hexagon_nn_nn_id id, int level) {
CONTROLLER_CHECK(set_debug_level, id, level);
}
int Controller::prepare(hexagon_nn_nn_id id) {
CONTROLLER_CHECK(prepare, id);
}
int Controller::append_node(hexagon_nn_nn_id id, uint32_t node_id, op_type operation,
hexagon_nn_padding_type padding, const hexagon_nn_input* inputs,
uint32_t num_inputs, const hexagon_nn_output* outputs,
uint32_t num_outputs) {
CONTROLLER_CHECK(append_node, id, node_id, operation, padding, inputs, num_inputs, outputs,
num_outputs);
}
int Controller::append_const_node(hexagon_nn_nn_id id, uint32_t node_id, uint32_t batches,
uint32_t height, uint32_t width, uint32_t depth,
const uint8_t* data, uint32_t data_len) {
CONTROLLER_CHECK(append_const_node, id, node_id, batches, height, width, depth, data, data_len);
}
int Controller::execute_new(hexagon_nn_nn_id id, const hexagon_nn_tensordef* inputs,
uint32_t n_inputs, hexagon_nn_tensordef* outputs, uint32_t n_outputs) {
CONTROLLER_CHECK(execute_new, id, inputs, n_inputs, outputs, n_outputs);
}
int Controller::execute(hexagon_nn_nn_id id, uint32_t batches_in, uint32_t height_in,
uint32_t width_in, uint32_t depth_in, const uint8_t* data_in,
uint32_t data_len_in, uint32_t* batches_out, uint32_t* height_out,
uint32_t* width_out, uint32_t* depth_out, uint8_t* data_out,
uint32_t data_out_max, uint32_t* data_out_size) {
CONTROLLER_CHECK(execute, id, batches_in, height_in, width_in, depth_in, data_in, data_len_in,
batches_out, height_out, width_out, depth_out, data_out, data_out_max,
data_out_size);
}
int Controller::teardown(hexagon_nn_nn_id id) {
CONTROLLER_CHECK(teardown, id);
}
int Controller::get_perfinfo(hexagon_nn_nn_id id, hexagon_nn_perfinfo* info_out,
unsigned int info_out_len, unsigned int* n_items_out) {
CONTROLLER_CHECK(get_perfinfo, id, info_out, info_out_len, n_items_out);
}
int Controller::reset_perfinfo(hexagon_nn_nn_id id, uint32_t event) {
CONTROLLER_CHECK(reset_perfinfo, id, event);
}
int Controller::version(int* ver) {
CONTROLLER_CHECK(version, ver);
}
int Controller::last_execution_cycles(hexagon_nn_nn_id id, unsigned int* cycles_lo,
unsigned int* cycles_hi) {
CONTROLLER_CHECK(last_execution_cycles, id, cycles_lo, cycles_hi);
}
int Controller::GetHexagonBinaryVersion(int* ver) {
CONTROLLER_CHECK(GetHexagonBinaryVersion, ver);
}
int Controller::PrintLog(const uint8_t* data_in, unsigned int data_in_len) {
CONTROLLER_CHECK(PrintLog, data_in, data_in_len);
}
int Controller::op_name_to_id(const char* name, unsigned int* id) {
CONTROLLER_CHECK(op_name_to_id, name, id);
}
int Controller::op_id_to_name(const unsigned int id, char* name, int name_len) {
CONTROLLER_CHECK(op_id_to_name, id, name, name_len);
}
int Controller::disable_dcvs() {
CONTROLLER_CHECK(disable_dcvs);
}
int Controller::set_powersave_level(unsigned int level) {
CONTROLLER_CHECK(set_powersave_level, level);
}
int Controller::config() {
CONTROLLER_CHECK(config);
}
unsigned int Controller::get_dsp_offset() {
CONTROLLER_CHECK(get_dsp_offset);
}
int Controller::boost(int bus_usage) {
CONTROLLER_CHECK(boost, bus_usage);
}
int Controller::slow() {
CONTROLLER_CHECK(slow);
}
} // namespace hexagon
} // namespace implementation
} // namespace V1_0
} // namespace neuralnetworks
} // namespace hardware
} // namespace android