diff options
Diffstat (limited to 'runtime/contrib/logging')
-rw-r--r-- | runtime/contrib/logging/CMakeLists.txt | 12 | ||||
-rw-r--r-- | runtime/contrib/logging/include/operand.def | 12 | ||||
-rw-r--r-- | runtime/contrib/logging/include/operation.def | 15 | ||||
-rw-r--r-- | runtime/contrib/logging/src/nnapi_logging.cc | 399 |
4 files changed, 438 insertions, 0 deletions
diff --git a/runtime/contrib/logging/CMakeLists.txt b/runtime/contrib/logging/CMakeLists.txt new file mode 100644 index 000000000..b200bf89a --- /dev/null +++ b/runtime/contrib/logging/CMakeLists.txt @@ -0,0 +1,12 @@ +if(NOT BUILD_LOGGING) + return() +endif(NOT BUILD_LOGGING) + +file(GLOB_RECURSE NNAPI_LOGGING_SRCS "src/*.cc") + +nnas_find_package(Boost REQUIRED) + +add_library(neuralnetworks SHARED ${NNAPI_LOGGING_SRCS}) +target_include_directories(neuralnetworks PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include) +target_include_directories(neuralnetworks PRIVATE ${Boost_INCLUDE_DIRS}) +target_link_libraries(neuralnetworks PUBLIC nnfw-nnapi-header) diff --git a/runtime/contrib/logging/include/operand.def b/runtime/contrib/logging/include/operand.def new file mode 100644 index 000000000..c570cf026 --- /dev/null +++ b/runtime/contrib/logging/include/operand.def @@ -0,0 +1,12 @@ +// Extracted from tensorflow/contrib/lite/nnapi/NeuralNetworksShim.h +// +// NNAPI_OPERAND(NAME, CODE) +#ifndef NNAPI_OPERAND +#error NNAPI_OPERAND should be defined +#endif +NNAPI_OPERAND(ANEURALNETWORKS_FLOAT32, 0) +NNAPI_OPERAND(ANEURALNETWORKS_INT32, 1) +NNAPI_OPERAND(ANEURALNETWORKS_UINT32, 2) +NNAPI_OPERAND(ANEURALNETWORKS_TENSOR_FLOAT32, 3) +NNAPI_OPERAND(ANEURALNETWORKS_TENSOR_INT32, 4) +NNAPI_OPERAND(ANEURALNETWORKS_TENSOR_QUANT8_ASYMM, 5) diff --git a/runtime/contrib/logging/include/operation.def b/runtime/contrib/logging/include/operation.def new file mode 100644 index 000000000..cace360d7 --- /dev/null +++ b/runtime/contrib/logging/include/operation.def @@ -0,0 +1,15 @@ +// Extracted from tensorflow/contrib/lite/nnapi/NeuralNetworksShim.h +// +// NNAPI_OPERATION(NAME, CODE) +#ifndef NNAPI_OPERATION +#error NNAPI_OPERATION should be defined +#endif +NNAPI_OPERATION(ANEURALNETWORKS_AVERAGE_POOL_2D, 1) +NNAPI_OPERATION(ANEURALNETWORKS_CONCATENATION, 2) +NNAPI_OPERATION(ANEURALNETWORKS_CONV_2D, 3) +NNAPI_OPERATION(ANEURALNETWORKS_DEPTHWISE_CONV_2D, 4) +NNAPI_OPERATION(ANEURALNETWORKS_FULLY_CONNECTED, 9) +NNAPI_OPERATION(ANEURALNETWORKS_MAX_POOL_2D, 17) +NNAPI_OPERATION(ANEURALNETWORKS_RESHAPE, 22) +NNAPI_OPERATION(ANEURALNETWORKS_RESIZE_BILINEAR, 23) +NNAPI_OPERATION(ANEURALNETWORKS_SOFTMAX, 25) diff --git a/runtime/contrib/logging/src/nnapi_logging.cc b/runtime/contrib/logging/src/nnapi_logging.cc new file mode 100644 index 000000000..14f2369ec --- /dev/null +++ b/runtime/contrib/logging/src/nnapi_logging.cc @@ -0,0 +1,399 @@ +#include <NeuralNetworks.h> +#include <NeuralNetworksEx.h> + +#include <stdexcept> +#include <iostream> + +#include <string> +#include <map> + +#include <cassert> + +#include <boost/format.hpp> + +namespace +{ + +class OperationCodeResolver +{ +public: + OperationCodeResolver(); + +public: + std::string resolve(int code) const; + +private: + void setName(int code, const std::string &name); + +private: + std::map<int, std::string> _table; + +public: + static const OperationCodeResolver &access() + { + static const OperationCodeResolver resolver; + + return resolver; + } +}; + +OperationCodeResolver::OperationCodeResolver() +{ +#define NNAPI_OPERATION(NAME, CODE) setName(CODE, #NAME); +#include "operation.def" +#undef NNAPI_OPERATION +} + +void OperationCodeResolver::setName(int code, const std::string &name) +{ + assert(_table.find(code) == _table.end()); + _table[code] = name; +} + +std::string OperationCodeResolver::resolve(int code) const +{ + auto it = _table.find(code); + + if (it == _table.end()) + { + return boost::str(boost::format("unknown(%d)") % code); + } + + return it->second; +} + +class OperandCodeResolver +{ +public: + OperandCodeResolver(); + +public: + std::string resolve(int code) const; + +private: + void setName(int code, const std::string &name); + +private: + std::map<int, std::string> _table; + +public: + static const OperandCodeResolver &access() + { + static const OperandCodeResolver resolver; + + return resolver; + } +}; + +OperandCodeResolver::OperandCodeResolver() +{ +#define NNAPI_OPERAND(NAME, CODE) setName(CODE, #NAME); +#include "operand.def" +#undef NNAPI_OPERAND +} + +void OperandCodeResolver::setName(int code, const std::string &name) +{ + assert(_table.find(code) == _table.end()); + _table[code] = name; +} + +std::string OperandCodeResolver::resolve(int code) const +{ + auto it = _table.find(code); + + if (it == _table.end()) + { + return boost::str(boost::format("unknown(%d)") % code); + } + + return it->second; +} +} + +// +// Asynchronous Event +// +struct ANeuralNetworksEvent +{ +}; + +int ANeuralNetworksEvent_wait(ANeuralNetworksEvent *event) { return ANEURALNETWORKS_NO_ERROR; } + +void ANeuralNetworksEvent_free(ANeuralNetworksEvent *event) { delete event; } + +// +// Memory +// +struct ANeuralNetworksMemory +{ + // 1st approach - Store all the data inside ANeuralNetworksMemory object + // 2nd approach - Store metadata only, and defer data loading as much as possible +}; + +int ANeuralNetworksMemory_createFromFd(size_t size, int protect, int fd, size_t offset, + ANeuralNetworksMemory **memory) +{ + *memory = new ANeuralNetworksMemory; + + std::cout << __FUNCTION__ << "() --> (memory: " << *memory << ")" << std::endl; + + return ANEURALNETWORKS_NO_ERROR; +} + +void ANeuralNetworksMemory_free(ANeuralNetworksMemory *memory) +{ + std::cout << __FUNCTION__ << "(" << memory << ")" << std::endl; + delete memory; +} + +// +// Model +// +struct ANeuralNetworksModel +{ + // ANeuralNetworksModel should be a factory for Graph IR (a.k.a ISA Frontend) + // TODO Record # of operands + uint32_t numOperands; + + ANeuralNetworksModel() : numOperands(0) + { + // DO NOTHING + } +}; + +int ANeuralNetworksModel_create(ANeuralNetworksModel **model) +{ + *model = new ANeuralNetworksModel; + + std::cout << __FUNCTION__ << "(" << model << ") --> (model: " << *model << ")" << std::endl; + + return ANEURALNETWORKS_NO_ERROR; +} + +void ANeuralNetworksModel_free(ANeuralNetworksModel *model) +{ + std::cout << __FUNCTION__ << "(" << model << ")" << std::endl; + + delete model; +} + +int ANeuralNetworksModel_addOperand(ANeuralNetworksModel *model, + const ANeuralNetworksOperandType *type) +{ + std::cout << __FUNCTION__ << "(model: " << model + << ", type: " << ::OperandCodeResolver::access().resolve(type->type) << ")" + << std::endl; + + auto id = model->numOperands; + + std::cout << " id: " << id << std::endl; + std::cout << " rank: " << type->dimensionCount << std::endl; + for (uint32_t dim = 0; dim < type->dimensionCount; ++dim) + { + std::cout << " dim(" << dim << "): " << type->dimensions[dim] << std::endl; + } + + model->numOperands += 1; + + return ANEURALNETWORKS_NO_ERROR; +} + +int ANeuralNetworksModel_setOperandValue(ANeuralNetworksModel *model, int32_t index, + const void *buffer, size_t length) +{ + std::cout << __FUNCTION__ << "(model: " << model << ", index: " << index << ")" << std::endl; + + // TODO Implement this! + // NOTE buffer becomes invalid after ANeuralNetworksModel_setOperandValue returns + + return ANEURALNETWORKS_NO_ERROR; +} + +int ANeuralNetworksModel_setOperandValueFromMemory(ANeuralNetworksModel *model, int32_t index, + const ANeuralNetworksMemory *memory, + size_t offset, size_t length) +{ + std::cout << __FUNCTION__ << "(model: " << model << ", index: " << index << ")" << std::endl; + + // TODO Implement this! + + return ANEURALNETWORKS_NO_ERROR; +} + +int ANeuralNetworksModel_addOperation(ANeuralNetworksModel *model, + ANeuralNetworksOperationType type, uint32_t inputCount, + const uint32_t *inputs, uint32_t outputCount, + const uint32_t *outputs) +{ + std::cout << __FUNCTION__ << "(model: " << model + << ", type: " << ::OperationCodeResolver::access().resolve(type) + << ", inputCount: " << inputCount << ", outputCount: " << outputCount << ")" + << std::endl; + + for (uint32_t input = 0; input < inputCount; ++input) + { + std::cout << " input(" << input << "): " << inputs[input] << std::endl; + } + for (uint32_t output = 0; output < outputCount; ++output) + { + std::cout << " output(" << output << "): " << outputs[output] << std::endl; + } + + // TODO Implement this! + + return ANEURALNETWORKS_NO_ERROR; +} + +int ANeuralNetworksModel_addOperationEx(ANeuralNetworksModel *model, + ANeuralNetworksOperationTypeEx type, uint32_t inputCount, + const uint32_t *inputs, uint32_t outputCount, + const uint32_t *outputs) +{ + std::cout << __FUNCTION__ << "(model: " << model << ", type: " << type + << ", inputCount: " << inputCount << ", outputCount: " << outputCount << ")" + << std::endl; + + for (uint32_t input = 0; input < inputCount; ++input) + { + std::cout << " input(" << input << "): " << inputs[input] << std::endl; + } + for (uint32_t output = 0; output < outputCount; ++output) + { + std::cout << " output(" << output << "): " << outputs[output] << std::endl; + } + + return ANEURALNETWORKS_NO_ERROR; +} + +int ANeuralNetworksModel_identifyInputsAndOutputs(ANeuralNetworksModel *model, uint32_t inputCount, + const uint32_t *inputs, uint32_t outputCount, + const uint32_t *outputs) +{ + std::cout << __FUNCTION__ << "(model: " << model << ")" << std::endl; + + for (uint32_t input = 0; input < inputCount; ++input) + { + std::cout << " input(" << input << "): " << inputs[input] << std::endl; + } + for (uint32_t output = 0; output < outputCount; ++output) + { + std::cout << " output(" << output << "): " << outputs[output] << std::endl; + } + + // TODO Implement this! + // NOTE It seems that this function identifies the input and output of the whole model + + return ANEURALNETWORKS_NO_ERROR; +} + +int ANeuralNetworksModel_finish(ANeuralNetworksModel *model) +{ + std::cout << __FUNCTION__ << "(model: " << model << ")" << std::endl; + + // TODO Implement this! + + return ANEURALNETWORKS_NO_ERROR; +} + +// +// Compilation +// +struct ANeuralNetworksCompilation +{ + // ANeuralNetworksCompilation should hold a compiled IR +}; + +int ANeuralNetworksCompilation_create(ANeuralNetworksModel *model, + ANeuralNetworksCompilation **compilation) +{ + *compilation = new ANeuralNetworksCompilation; + + std::cout << __FUNCTION__ << "(model: " << model << ") --> (compilation: " << *compilation << ")" + << std::endl; + + return ANEURALNETWORKS_NO_ERROR; +} + +int ANeuralNetworksCompilation_finish(ANeuralNetworksCompilation *compilation) +{ + std::cout << __FUNCTION__ << "(compilation: " << compilation << ")" << std::endl; + + return ANEURALNETWORKS_NO_ERROR; +} + +// +// Execution +// +struct ANeuralNetworksExecution +{ + // ANeuralNetworksExecution corresponds to NPU::Interp::Session +}; + +int ANeuralNetworksExecution_create(ANeuralNetworksCompilation *compilation, + ANeuralNetworksExecution **execution) +{ + *execution = new ANeuralNetworksExecution; + + std::cout << __FUNCTION__ << "(compilation: " << compilation << ") --> (execution: " << *execution + << ")" << std::endl; + + return ANEURALNETWORKS_NO_ERROR; +} + +// ANeuralNetworksExecution_setInput and ANeuralNetworksExecution_setOutput specify HOST buffer for +// input/output +int ANeuralNetworksExecution_setInput(ANeuralNetworksExecution *execution, int32_t index, + const ANeuralNetworksOperandType *type, const void *buffer, + size_t length) +{ + std::cout << __FUNCTION__ << "(execution: " << execution << ", type: "; + + if (type == nullptr) + std::cout << "nullptr)" << std::endl; + else + std::cout << ::OperandCodeResolver::access().resolve(type->type) << ")" << std::endl; + + // Q: Should we transfer input from HOST to DEVICE here, or in + // ANeuralNetworksExecution_startCompute? + + return ANEURALNETWORKS_NO_ERROR; +} + +int ANeuralNetworksExecution_setOutput(ANeuralNetworksExecution *execution, int32_t index, + const ANeuralNetworksOperandType *type, void *buffer, + size_t length) +{ + std::cout << __FUNCTION__ << "(execution: " << execution << ", type: "; + + if (type == nullptr) + std::cout << "nullptr)" << std::endl; + else + std::cout << ::OperandCodeResolver::access().resolve(type->type) << ")" << std::endl; + + return ANEURALNETWORKS_NO_ERROR; +} + +int ANeuralNetworksExecution_startCompute(ANeuralNetworksExecution *execution, + ANeuralNetworksEvent **event) +{ + *event = new ANeuralNetworksEvent; + + std::cout << __FUNCTION__ << "(execution: " << execution << ") --> (event: " << *event << ")" + << std::endl; + + return ANEURALNETWORKS_NO_ERROR; +} + +void ANeuralNetworksExecution_free(ANeuralNetworksExecution *execution) +{ + std::cout << __FUNCTION__ << "(execution: " << execution << ")" << std::endl; + + delete execution; +} + +void ANeuralNetworksCompilation_free(ANeuralNetworksCompilation *compilation) +{ + std::cout << __FUNCTION__ << "(compilation: " << compilation << ")" << std::endl; + delete compilation; +} |