| /* |
| * 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 "ModelBuilder" |
| |
| #include "ModelBuilder.h" |
| |
| #include "CompilationBuilder.h" |
| #include "GraphDump.h" |
| #include "Utils.h" |
| #include "ValidateHal.h" |
| |
| #include <map> |
| #include <utility> |
| |
| namespace android { |
| namespace nn { |
| |
| // The maximum number of operands and operations that a model may have. |
| const uint32_t MAX_NUMBER_OF_OPERANDS = 0xFFFFFFFE; |
| const uint32_t MAX_NUMBER_OF_OPERATIONS = 0xFFFFFFFE; |
| |
| bool ModelBuilder::badState(const char* name) { |
| if (mCompletedModel) { |
| LOG(ERROR) << "ANeuralNetworksModel_" << name << " can't modify after model finished"; |
| return true; |
| } |
| if (mInvalidModel) { |
| LOG(ERROR) << "ANeuralNetworksModel_" << name << " can't modify an invalid model"; |
| return true; |
| } |
| return false; |
| } |
| |
| int ModelBuilder::addOperand(const ANeuralNetworksOperandType& type) { |
| if (badState("addOperand")) { |
| return ANEURALNETWORKS_BAD_STATE; |
| } |
| |
| int n = validateOperandType(type, "ANeuralNetworksModel_addOperand", true); |
| if (n != ANEURALNETWORKS_NO_ERROR) { |
| return n; |
| } |
| size_t idx = mOperands.size(); |
| if (idx >= MAX_NUMBER_OF_OPERANDS) { |
| LOG(ERROR) << "ANeuralNetworksModel_addOperand exceed max operands"; |
| return ANEURALNETWORKS_BAD_DATA; |
| } |
| mOperands.push_back({ |
| .type = static_cast<OperandType>(type.type), |
| .dimensions = hidl_vec<uint32_t>(type.dimensions, type.dimensions + type.dimensionCount), |
| .numberOfConsumers = 0, |
| .scale = type.scale, |
| .zeroPoint = type.zeroPoint, |
| .lifetime = OperandLifeTime::TEMPORARY_VARIABLE, |
| .location = {.poolIndex = 0, .offset = 0, .length = 0}, |
| }); |
| return ANEURALNETWORKS_NO_ERROR; |
| } |
| |
| int ModelBuilder::setOperandValue(uint32_t index, const void* buffer, size_t length) { |
| VLOG(MODEL) << __func__ << " for operand " << index << " size " << length; |
| if (badState("setOperandValue")) { |
| return ANEURALNETWORKS_BAD_STATE; |
| } |
| |
| if (index >= operandCount()) { |
| LOG(ERROR) << "ANeuralNetworksModel_setOperandValue setting operand " << index << " of " |
| << operandCount(); |
| return ANEURALNETWORKS_BAD_DATA; |
| } |
| Operand& operand = mOperands[index]; |
| if (buffer == nullptr) { |
| if (length) { |
| LOG(ERROR) << "ANeuralNetworksModel_setOperandValue buffer is nullptr but length is " |
| "not 0"; |
| return ANEURALNETWORKS_BAD_DATA; |
| } |
| operand.lifetime = OperandLifeTime::NO_VALUE; |
| // The location is unused and is set to zeros. |
| operand.location = {.poolIndex = 0, |
| .offset = 0, |
| .length = 0}; |
| } else { |
| if (length > 0xFFFFFFFF) { |
| LOG(ERROR) << "ANeuralNetworksModel_setOperandValue value length of " << length |
| << " exceeds max size"; |
| return ANEURALNETWORKS_BAD_DATA; |
| } |
| uint32_t valueLength = static_cast<uint32_t>(length); |
| uint32_t neededLength = sizeOfData(operand.type, operand.dimensions); |
| if (operand.type != OperandType::OEM && neededLength != valueLength) { |
| LOG(ERROR) << "ANeuralNetworksModel_setOperandValue setting " << valueLength |
| << " bytes when needing " << neededLength; |
| return ANEURALNETWORKS_BAD_DATA; |
| } |
| if (valueLength <= ANEURALNETWORKS_MAX_SIZE_OF_IMMEDIATELY_COPIED_VALUES) { |
| uint32_t existingSize = static_cast<uint32_t>(mSmallOperandValues.size()); |
| uint32_t extraBytes = alignBytesNeeded(existingSize, valueLength); |
| mSmallOperandValues.resize(existingSize + extraBytes + valueLength); |
| operand.lifetime = OperandLifeTime::CONSTANT_COPY; |
| operand.location = { |
| .poolIndex = 0, .offset = existingSize + extraBytes, .length = valueLength}; |
| memcpy(&mSmallOperandValues[operand.location.offset], buffer, valueLength); |
| VLOG(MODEL) << "Copied small value to offset " << operand.location.offset; |
| } else { |
| VLOG(MODEL) << "Saving large value"; |
| operand.lifetime = OperandLifeTime::CONSTANT_REFERENCE; |
| // The values for poolIndex and offset will be set when the model is finished. |
| typedef decltype(operand.location.poolIndex) PoolIndexType; |
| typedef decltype(operand.location.offset) OffsetType; |
| operand.location = {.poolIndex = ~PoolIndexType(0), .offset = ~OffsetType(0), |
| .length = valueLength}; |
| // We keep track of the buffers. We'll allocate the shared memory only |
| // once we know the total size, to avoid needless copies. |
| mLargeOperandValues.push_back(LargeValue{.operandIndex = index, .buffer = buffer}); |
| } |
| } |
| return ANEURALNETWORKS_NO_ERROR; |
| } |
| |
| int ModelBuilder::copyLargeValuesToSharedMemory() { |
| VLOG(MODEL) << __func__ << " has " << mLargeOperandValues.size() << " values."; |
| if (!mLargeOperandValues.empty()) { |
| // Calculate the size of the shared memory needed for all the large values. |
| // Also sets the offset for each value within the memory. |
| size_t poolSize = 0; |
| for (LargeValue& l: mLargeOperandValues) { |
| Operand& operand = mOperands[l.operandIndex]; |
| nnAssert(operand.lifetime == OperandLifeTime::CONSTANT_REFERENCE); |
| poolSize += alignBytesNeeded(poolSize, operand.location.length); |
| operand.location.offset = poolSize; |
| poolSize += operand.location.length; |
| } |
| |
| // Allocated the shared memory. |
| int n = mLargeValueMemory.create(poolSize); |
| if (n != ANEURALNETWORKS_NO_ERROR) { |
| return n; |
| } |
| uint8_t* memoryPointer = nullptr; |
| n = mLargeValueMemory.getPointer(&memoryPointer); |
| if (n != ANEURALNETWORKS_NO_ERROR) { |
| return n; |
| } |
| uint32_t poolIndex = mMemories.add(&mLargeValueMemory); |
| VLOG(MODEL) << "Allocated large value pool of size " << poolSize << " at index " |
| << poolIndex; |
| |
| // Copy the values to this memory. |
| for (LargeValue& l: mLargeOperandValues) { |
| Operand& operand = mOperands[l.operandIndex]; |
| operand.location.poolIndex = poolIndex; |
| memcpy(memoryPointer + operand.location.offset, l.buffer, operand.location.length); |
| } |
| } |
| return ANEURALNETWORKS_NO_ERROR; |
| } |
| |
| int ModelBuilder::setOperandValueFromMemory(uint32_t index, const Memory* memory, uint32_t offset, |
| size_t length) { |
| VLOG(MODEL) << __func__ << " for operand " << index << " offset " << offset << " size " << length; |
| if (badState("setOperandValueFromMemory")) { |
| return ANEURALNETWORKS_BAD_STATE; |
| } |
| |
| if (index >= operandCount()) { |
| LOG(ERROR) << "ANeuralNetworksModel_setOperandValueFromMemory setting operand " << index |
| << " of " << operandCount(); |
| return ANEURALNETWORKS_BAD_DATA; |
| } |
| Operand& operand = mOperands[index]; |
| uint32_t neededLength = sizeOfData(operand.type, operand.dimensions); |
| if (neededLength != length) { |
| LOG(ERROR) << "ANeuralNetworksModel_setOperandValueFromMemory setting " << length |
| << " bytes when needing " << neededLength; |
| return ANEURALNETWORKS_BAD_DATA; |
| } |
| if (!memory->validateSize(offset, length)) { |
| return ANEURALNETWORKS_BAD_DATA; |
| } |
| operand.lifetime = OperandLifeTime::CONSTANT_REFERENCE; |
| operand.location = { |
| .poolIndex = mMemories.add(memory), .offset = offset, .length = neededLength}; |
| return ANEURALNETWORKS_NO_ERROR; |
| } |
| |
| int ModelBuilder::addOperation(ANeuralNetworksOperationType type, uint32_t inputCount, |
| const uint32_t* inputs, uint32_t outputCount, |
| const uint32_t* outputs) { |
| if (badState("addOperation")) { |
| return ANEURALNETWORKS_BAD_STATE; |
| } |
| |
| if (!validCode(kNumberOfOperationTypes, kNumberOfOperationTypesOEM, type)) { |
| LOG(ERROR) << "ANeuralNetworksModel_addOperation invalid operations type " << type; |
| return ANEURALNETWORKS_BAD_DATA; |
| } |
| int n = validateOperation(type, inputCount, inputs, outputCount, outputs, mOperands, |
| HalVersion::LATEST); |
| if (n != ANEURALNETWORKS_NO_ERROR) { |
| return n; |
| } |
| |
| uint32_t operationIndex = operationCount(); |
| if (operationIndex >= MAX_NUMBER_OF_OPERATIONS) { |
| LOG(ERROR) << "ANeuralNetworksModel_addOperation exceed max operations"; |
| return ANEURALNETWORKS_BAD_DATA; |
| } |
| |
| mOperations.push_back({ |
| .type = static_cast<OperationType>(type), |
| .inputs = hidl_vec<uint32_t>(inputs, inputs + inputCount), |
| .outputs = hidl_vec<uint32_t>(outputs, outputs + outputCount), |
| }); |
| for (uint32_t i : mOperations.back().inputs) { |
| mOperands[i].numberOfConsumers++; |
| } |
| mHasOEMOperation |= (mOperations.back().type == OperationType::OEM_OPERATION); |
| |
| return ANEURALNETWORKS_NO_ERROR; |
| } |
| |
| int ModelBuilder::identifyInputsAndOutputs(uint32_t inputCount, const uint32_t* inputs, |
| uint32_t outputCount, const uint32_t* outputs) { |
| if (badState("identifyInputsAndOutputs")) { |
| return ANEURALNETWORKS_BAD_STATE; |
| } |
| |
| int n = validateOperandList(inputCount, inputs, operandCount(), |
| "ANeuralNetworksModel_identifyInputsAndOutputs inputs"); |
| if (n != ANEURALNETWORKS_NO_ERROR) { |
| return n; |
| } |
| n = validateOperandList(outputCount, outputs, operandCount(), |
| "ANeuralNetworksModel_identifyInputsAndOutputs outputs"); |
| if (n != ANEURALNETWORKS_NO_ERROR) { |
| return n; |
| } |
| |
| // Makes a copy of the index list, validates the arguments, and changes |
| // the lifetime info of the corresponding operand. |
| auto setArguments = [&](std::vector<uint32_t>* indexVector, uint32_t indexCount, |
| const uint32_t* indexList, OperandLifeTime lifetime) -> bool { |
| indexVector->resize(indexCount); |
| for (uint32_t i = 0; i < indexCount; i++) { |
| const uint32_t operandIndex = indexList[i]; |
| if (operandIndex >= mOperands.size()) { |
| LOG(ERROR) << "ANeuralNetworksModel_identifyInputsAndOutputs Can't set input or output " |
| "to be " |
| << operandIndex << " as this exceeds the numbe of operands " |
| << mOperands.size(); |
| return false; |
| } |
| (*indexVector)[i] = operandIndex; |
| Operand& operand = mOperands[operandIndex]; |
| if (operand.lifetime != OperandLifeTime::TEMPORARY_VARIABLE) { |
| LOG(ERROR) << "ANeuralNetworksModel_identifyInputsAndOutputs Can't set operand " |
| << operandIndex |
| << " to be an input or output. Check that it's not a constant or " |
| "already an input or output"; |
| return false; |
| } |
| operand.lifetime = lifetime; |
| } |
| return true; |
| }; |
| |
| if (!setArguments(&mInputIndexes, inputCount, inputs, OperandLifeTime::MODEL_INPUT) || |
| !setArguments(&mOutputIndexes, outputCount, outputs, OperandLifeTime::MODEL_OUTPUT)) { |
| return ANEURALNETWORKS_BAD_DATA; |
| } |
| |
| return ANEURALNETWORKS_NO_ERROR; |
| } |
| |
| int ModelBuilder::relaxComputationFloat32toFloat16(bool allow) { |
| if (badState("relaxComputationFloat32toFloat16")) { |
| return ANEURALNETWORKS_BAD_STATE; |
| } |
| |
| mRelaxComputationFloat32toFloat16 = allow; |
| |
| return ANEURALNETWORKS_NO_ERROR; |
| } |
| |
| int ModelBuilder::createCompilation(CompilationBuilder** compilation, |
| const std::vector<std::shared_ptr<Device>>& devices) { |
| if (!mCompletedModel || mInvalidModel) { |
| LOG(ERROR) << "ANeuralNetworksCompilation_create passed an unfinished or invalid model"; |
| *compilation = nullptr; |
| return ANEURALNETWORKS_BAD_STATE; |
| } |
| *compilation = new (std::nothrow) CompilationBuilder(this, devices); |
| return (*compilation ? ANEURALNETWORKS_NO_ERROR : ANEURALNETWORKS_OUT_OF_MEMORY); |
| } |
| |
| int ModelBuilder::finish() { |
| if (mCompletedModel) { |
| LOG(ERROR) << "ANeuralNetworksModel_finish called more than once"; |
| return ANEURALNETWORKS_BAD_STATE; |
| } |
| if (mInvalidModel) { |
| LOG(ERROR) << "ANeuralNetworksModel_finish called on an invalid model"; |
| return ANEURALNETWORKS_BAD_STATE; |
| } |
| |
| int n = copyLargeValuesToSharedMemory(); |
| if (n != ANEURALNETWORKS_NO_ERROR) { |
| return n; |
| } |
| |
| // TODO: Modify validation so that it can be called without creating a HAL Model. |
| // NOTE: Must copyLargeValuesToSharedMemory() before validation; otherwise, |
| // a CONSTANT_REFERENCE operand will not have correct .poolIndex, and |
| // validation will not work properly. |
| Model modelForValidation; |
| setHidlModel(&modelForValidation); |
| if (!validateModel(modelForValidation)) { |
| LOG(ERROR) << "ANeuralNetworksModel_finish called on invalid model"; |
| mInvalidModel = true; |
| return ANEURALNETWORKS_BAD_DATA; |
| } |
| if (VLOG_IS_ON(MODEL)) { |
| graphDump("ModelBuilder::finish", modelForValidation, nullptr); |
| } |
| |
| // We sort the operations so that they will be in the appropriate |
| // order for a single-threaded, op at a time execution. |
| // TODO: we don't need this if we always run the partitioner. |
| sortIntoRunOrder(); |
| mCompletedModel = true; |
| return ANEURALNETWORKS_NO_ERROR; |
| } |
| |
| void ModelBuilder::sortIntoRunOrder() { |
| if (!mSortedOperationIndexMap.empty()) { |
| LOG(ERROR) << "Operations already in run order."; |
| return; |
| } |
| // Tracks the operations that can be executed. |
| std::vector<uint32_t> opsReadyToRun; |
| std::vector<Operation> runOrder; |
| |
| // Tracks how many inputs are needed for each operation to be ready to run. |
| std::multimap<uint32_t, uint32_t> operandToOperations; |
| std::vector<uint32_t> unknownInputCount(operationCount()); |
| for (uint32_t operationIndex = 0; operationIndex < operationCount(); operationIndex++) { |
| uint32_t& count = unknownInputCount[operationIndex]; |
| count = 0; |
| for (uint32_t operandIndex : mOperations[operationIndex].inputs) { |
| auto lifetime = mOperands[operandIndex].lifetime; |
| if (lifetime == OperandLifeTime::TEMPORARY_VARIABLE || |
| lifetime == OperandLifeTime::MODEL_OUTPUT) { |
| count++; |
| operandToOperations.insert( |
| std::pair<uint32_t, uint32_t>(operandIndex, operationIndex)); |
| } |
| } |
| if (count == 0) { |
| opsReadyToRun.push_back(operationIndex); |
| } |
| } |
| |
| while (opsReadyToRun.size() > 0) { |
| // Execute the next op |
| int opIndex = opsReadyToRun.back(); |
| opsReadyToRun.pop_back(); |
| const Operation& operation = mOperations[opIndex]; |
| |
| runOrder.push_back(mOperations[opIndex]); |
| mSortedOperationIndexMap.push_back(opIndex); |
| |
| // Mark all its outputs as known. |
| for (uint32_t operandIndex : operation.outputs) { |
| auto range = operandToOperations.equal_range(operandIndex); |
| for (auto i = range.first; i != range.second; i++) { |
| uint32_t& count = unknownInputCount[i->second]; |
| if (--count == 0) { |
| opsReadyToRun.push_back(i->second); |
| } |
| } |
| } |
| } |
| mOperations = runOrder; |
| } |
| |
| void ModelBuilder::setHidlModel(Model* model) const { |
| model->operands = mOperands; |
| model->operations = mOperations; |
| model->inputIndexes = mInputIndexes; |
| model->outputIndexes = mOutputIndexes; |
| model->operandValues = mSmallOperandValues; |
| model->relaxComputationFloat32toFloat16 = mRelaxComputationFloat32toFloat16; |
| |
| uint32_t count = mMemories.size(); |
| model->pools.resize(count); |
| for (uint32_t i = 0; i < count; i++) { |
| model->pools[i] = mMemories[i]->getHidlMemory(); |
| } |
| } |
| |
| } // namespace nn |
| } // namespace android |