| /* | |
| * 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 "SampleDriver" | |
| #include "SampleDriver.h" | |
| #include "CpuExecutor.h" | |
| #include "ExecutionBurstServer.h" | |
| #include "HalInterfaces.h" | |
| #include "Tracing.h" | |
| #include "ValidateHal.h" | |
| #include <android-base/logging.h> | |
| #include <hidl/LegacySupport.h> | |
| #include <chrono> | |
| #include <thread> | |
| namespace android { | |
| namespace nn { | |
| namespace sample_driver { | |
| namespace { | |
| using time_point = std::chrono::system_clock::time_point; | |
| auto now() { | |
| return std::chrono::system_clock::now(); | |
| }; | |
| auto microsecondsDuration(decltype(now()) end, decltype(now()) start) { | |
| return std::chrono::duration_cast<std::chrono::microseconds>(end - start).count(); | |
| }; | |
| } // namespace | |
| static const Timing kNoTiming = {.timeOnDevice = UINT64_MAX, .timeInDriver = UINT64_MAX}; | |
| Return<void> SampleDriver::getCapabilities(getCapabilities_cb cb) { | |
| NNTRACE_FULL(NNTRACE_LAYER_DRIVER, NNTRACE_PHASE_INITIALIZATION, | |
| "SampleDriver::getCapabilities"); | |
| return getCapabilities_1_1( | |
| [&](ErrorStatus error, const V1_1::Capabilities& capabilities) { | |
| // TODO(dgross): Do we need to check compliantWithV1_0(capabilities)? | |
| cb(error, convertToV1_0(capabilities)); | |
| }); | |
| } | |
| Return<void> SampleDriver::getVersionString(getVersionString_cb cb) { | |
| NNTRACE_FULL(NNTRACE_LAYER_DRIVER, NNTRACE_PHASE_INITIALIZATION, | |
| "SampleDriver::getVersionString"); | |
| cb(ErrorStatus::NONE, "JUST_AN_EXAMPLE"); | |
| return Void(); | |
| } | |
| Return<void> SampleDriver::getType(getType_cb cb) { | |
| NNTRACE_FULL(NNTRACE_LAYER_DRIVER, NNTRACE_PHASE_INITIALIZATION, "SampleDriver::getType"); | |
| cb(ErrorStatus::NONE, V1_2::DeviceType::CPU); | |
| return Void(); | |
| } | |
| Return<void> SampleDriver::getSupportedExtensions(getSupportedExtensions_cb cb) { | |
| NNTRACE_FULL(NNTRACE_LAYER_DRIVER, NNTRACE_PHASE_INITIALIZATION, | |
| "SampleDriver::getSupportedExtensions"); | |
| cb(ErrorStatus::NONE, {/* No extensions. */}); | |
| return Void(); | |
| } | |
| Return<void> SampleDriver::getSupportedOperations(const V1_0::Model& model, | |
| getSupportedOperations_cb cb) { | |
| NNTRACE_FULL(NNTRACE_LAYER_DRIVER, NNTRACE_PHASE_COMPILATION, | |
| "SampleDriver::getSupportedOperations"); | |
| if (!validateModel(model)) { | |
| VLOG(DRIVER) << "getSupportedOperations"; | |
| std::vector<bool> supported; | |
| cb(ErrorStatus::INVALID_ARGUMENT, supported); | |
| return Void(); | |
| } | |
| return getSupportedOperations_1_2(convertToV1_2(model), cb); | |
| } | |
| Return<void> SampleDriver::getSupportedOperations_1_1(const V1_1::Model& model, | |
| getSupportedOperations_1_1_cb cb) { | |
| NNTRACE_FULL(NNTRACE_LAYER_DRIVER, NNTRACE_PHASE_COMPILATION, | |
| "SampleDriver::getSupportedOperations_1_1"); | |
| if (!validateModel(model)) { | |
| VLOG(DRIVER) << "getSupportedOperations_1_1"; | |
| std::vector<bool> supported; | |
| cb(ErrorStatus::INVALID_ARGUMENT, supported); | |
| return Void(); | |
| } | |
| return getSupportedOperations_1_2(convertToV1_2(model), cb); | |
| } | |
| Return<void> SampleDriver::isCachingSupported(isCachingSupported_cb cb) { | |
| NNTRACE_FULL(NNTRACE_LAYER_DRIVER, NNTRACE_PHASE_INITIALIZATION, | |
| "SampleDriver::isCachingSupported"); | |
| cb(ErrorStatus::NONE, false); | |
| return Void(); | |
| } | |
| static void notify(const sp<V1_0::IPreparedModelCallback>& callback, const ErrorStatus& status, | |
| const sp<SamplePreparedModel>& preparedModel) { | |
| callback->notify(status, preparedModel); | |
| } | |
| static void notify(const sp<V1_2::IPreparedModelCallback>& callback, const ErrorStatus& status, | |
| const sp<SamplePreparedModel>& preparedModel) { | |
| callback->notify_1_2(status, preparedModel); | |
| } | |
| template <typename T_Model, typename T_IPreparedModelCallback> | |
| Return<ErrorStatus> prepareModelBase(const T_Model& model, const SampleDriver* driver, | |
| ExecutionPreference preference, | |
| const sp<T_IPreparedModelCallback>& callback) { | |
| if (callback.get() == nullptr) { | |
| LOG(ERROR) << "invalid callback passed to prepareModelBase"; | |
| return ErrorStatus::INVALID_ARGUMENT; | |
| } | |
| if (VLOG_IS_ON(DRIVER)) { | |
| VLOG(DRIVER) << "prepareModelBase"; | |
| logModelToInfo(model); | |
| } | |
| if (!validateModel(model) || !validateExecutionPreference(preference)) { | |
| notify(callback, ErrorStatus::INVALID_ARGUMENT, nullptr); | |
| return ErrorStatus::INVALID_ARGUMENT; | |
| } | |
| // TODO: make asynchronous later | |
| sp<SamplePreparedModel> preparedModel = new SamplePreparedModel(convertToV1_2(model), driver); | |
| if (!preparedModel->initialize()) { | |
| notify(callback, ErrorStatus::INVALID_ARGUMENT, nullptr); | |
| return ErrorStatus::INVALID_ARGUMENT; | |
| } | |
| notify(callback, ErrorStatus::NONE, preparedModel); | |
| return ErrorStatus::NONE; | |
| } | |
| Return<ErrorStatus> SampleDriver::prepareModel(const V1_0::Model& model, | |
| const sp<V1_0::IPreparedModelCallback>& callback) { | |
| NNTRACE_FULL(NNTRACE_LAYER_DRIVER, NNTRACE_PHASE_COMPILATION, "SampleDriver::prepareModel"); | |
| return prepareModelBase(model, this, ExecutionPreference::FAST_SINGLE_ANSWER, callback); | |
| } | |
| Return<ErrorStatus> SampleDriver::prepareModel_1_1( | |
| const V1_1::Model& model, ExecutionPreference preference, | |
| const sp<V1_0::IPreparedModelCallback>& callback) { | |
| NNTRACE_FULL(NNTRACE_LAYER_DRIVER, NNTRACE_PHASE_COMPILATION, "SampleDriver::prepareModel_1_1"); | |
| return prepareModelBase(model, this, preference, callback); | |
| } | |
| Return<ErrorStatus> SampleDriver::prepareModel_1_2( | |
| const V1_2::Model& model, ExecutionPreference preference, | |
| const sp<V1_2::IPreparedModelCallback>& callback) { | |
| NNTRACE_FULL(NNTRACE_LAYER_DRIVER, NNTRACE_PHASE_COMPILATION, "SampleDriver::prepareModel_1_2"); | |
| return prepareModelBase(model, this, preference, callback); | |
| } | |
| Return<ErrorStatus> SampleDriver::prepareModelFromCache( | |
| const hidl_handle&, const hidl_handle&, const HidlToken&, | |
| const sp<V1_2::IPreparedModelCallback>& callback) { | |
| NNTRACE_FULL(NNTRACE_LAYER_DRIVER, NNTRACE_PHASE_COMPILATION, | |
| "SampleDriver::prepareModelFromCache"); | |
| callback->notify_1_2(ErrorStatus::GENERAL_FAILURE, nullptr); | |
| return ErrorStatus::GENERAL_FAILURE; | |
| } | |
| Return<DeviceStatus> SampleDriver::getStatus() { | |
| NNTRACE_FULL(NNTRACE_LAYER_DRIVER, NNTRACE_PHASE_UNSPECIFIED, | |
| "SampleDriver::getStatus"); | |
| VLOG(DRIVER) << "getStatus()"; | |
| return DeviceStatus::AVAILABLE; | |
| } | |
| int SampleDriver::run() { | |
| android::hardware::configureRpcThreadpool(4, true); | |
| if (registerAsService(mName) != android::OK) { | |
| LOG(ERROR) << "Could not register service"; | |
| return 1; | |
| } | |
| android::hardware::joinRpcThreadpool(); | |
| LOG(ERROR) << "Service exited!"; | |
| return 1; | |
| } | |
| bool SamplePreparedModel::initialize() { | |
| return setRunTimePoolInfosFromHidlMemories(&mPoolInfos, mModel.pools); | |
| } | |
| static Return<void> notify(const sp<V1_0::IExecutionCallback>& callback, const ErrorStatus& status, | |
| const hidl_vec<OutputShape>&, Timing) { | |
| return callback->notify(status); | |
| } | |
| static Return<void> notify(const sp<V1_2::IExecutionCallback>& callback, const ErrorStatus& status, | |
| const hidl_vec<OutputShape>& outputShapes, Timing timing) { | |
| return callback->notify_1_2(status, outputShapes, timing); | |
| } | |
| // TODO(xusongw): Let callback notify actual output shape once dynamic output shape | |
| // is supported in CpuExecutor. | |
| template <typename T_IExecutionCallback> | |
| void asyncExecute(const Request& request, MeasureTiming measure, time_point driverStart, | |
| const Model& model, const SampleDriver& driver, | |
| const std::vector<RunTimePoolInfo>& poolInfos, | |
| const sp<T_IExecutionCallback>& callback) { | |
| NNTRACE_FULL(NNTRACE_LAYER_DRIVER, NNTRACE_PHASE_INPUTS_AND_OUTPUTS, | |
| "SampleDriver::asyncExecute"); | |
| std::vector<RunTimePoolInfo> requestPoolInfos; | |
| if (!setRunTimePoolInfosFromHidlMemories(&requestPoolInfos, request.pools)) { | |
| notify(callback, ErrorStatus::GENERAL_FAILURE, {}, kNoTiming); | |
| return; | |
| } | |
| NNTRACE_FULL_SWITCH(NNTRACE_LAYER_DRIVER, NNTRACE_PHASE_EXECUTION, | |
| "SampleDriver::asyncExecute"); | |
| CpuExecutor executor = driver.getExecutor(); | |
| time_point driverEnd, deviceStart, deviceEnd; | |
| if (measure == MeasureTiming::YES) deviceStart = now(); | |
| int n = executor.run(model, request, poolInfos, requestPoolInfos); | |
| if (measure == MeasureTiming::YES) deviceEnd = now(); | |
| VLOG(DRIVER) << "executor.run returned " << n; | |
| ErrorStatus executionStatus = convertResultCodeToErrorStatus(n); | |
| hidl_vec<OutputShape> outputShapes = executor.getOutputShapes(); | |
| Return<void> returned; | |
| if (measure == MeasureTiming::YES && executionStatus == ErrorStatus::NONE) { | |
| driverEnd = now(); | |
| Timing timing = {.timeOnDevice = uint64_t(microsecondsDuration(deviceEnd, deviceStart)), | |
| .timeInDriver = uint64_t(microsecondsDuration(driverEnd, driverStart))}; | |
| VLOG(DRIVER) << "SampleDriver::asyncExecute timing = " << toString(timing); | |
| returned = notify(callback, executionStatus, outputShapes, timing); | |
| } else { | |
| returned = notify(callback, executionStatus, outputShapes, kNoTiming); | |
| } | |
| if (!returned.isOk()) { | |
| LOG(ERROR) << " hidl callback failed to return properly: " << returned.description(); | |
| } | |
| } | |
| template <typename T_IExecutionCallback> | |
| Return<ErrorStatus> executeBase(const Request& request, MeasureTiming measure, const Model& model, | |
| const SampleDriver& driver, | |
| const std::vector<RunTimePoolInfo>& poolInfos, | |
| const sp<T_IExecutionCallback>& callback) { | |
| NNTRACE_FULL(NNTRACE_LAYER_DRIVER, NNTRACE_PHASE_EXECUTION, "SampleDriver::executeBase"); | |
| VLOG(DRIVER) << "executeBase(" << SHOW_IF_DEBUG(toString(request)) << ")"; | |
| time_point driverStart; | |
| if (measure == MeasureTiming::YES) driverStart = now(); | |
| if (callback.get() == nullptr) { | |
| LOG(ERROR) << "invalid callback passed to executeBase"; | |
| return ErrorStatus::INVALID_ARGUMENT; | |
| } | |
| if (!validateRequest(request, model)) { | |
| notify(callback, ErrorStatus::INVALID_ARGUMENT, {}, kNoTiming); | |
| return ErrorStatus::INVALID_ARGUMENT; | |
| } | |
| // This thread is intentionally detached because the sample driver service | |
| // is expected to live forever. | |
| std::thread([&model, &driver, &poolInfos, request, measure, driverStart, callback] { | |
| asyncExecute(request, measure, driverStart, model, driver, poolInfos, callback); | |
| }) | |
| .detach(); | |
| return ErrorStatus::NONE; | |
| } | |
| Return<ErrorStatus> SamplePreparedModel::execute(const Request& request, | |
| const sp<V1_0::IExecutionCallback>& callback) { | |
| return executeBase(request, MeasureTiming::NO, mModel, *mDriver, mPoolInfos, callback); | |
| } | |
| Return<ErrorStatus> SamplePreparedModel::execute_1_2(const Request& request, MeasureTiming measure, | |
| const sp<V1_2::IExecutionCallback>& callback) { | |
| return executeBase(request, measure, mModel, *mDriver, mPoolInfos, callback); | |
| } | |
| Return<void> SamplePreparedModel::executeSynchronously(const Request& request, | |
| MeasureTiming measure, | |
| executeSynchronously_cb cb) { | |
| NNTRACE_FULL(NNTRACE_LAYER_DRIVER, NNTRACE_PHASE_EXECUTION, | |
| "SampleDriver::executeSynchronously"); | |
| VLOG(DRIVER) << "executeSynchronously(" << SHOW_IF_DEBUG(toString(request)) << ")"; | |
| time_point driverStart, driverEnd, deviceStart, deviceEnd; | |
| if (measure == MeasureTiming::YES) driverStart = now(); | |
| if (!validateRequest(request, mModel)) { | |
| cb(ErrorStatus::INVALID_ARGUMENT, {}, kNoTiming); | |
| return Void(); | |
| } | |
| NNTRACE_FULL_SWITCH(NNTRACE_LAYER_DRIVER, NNTRACE_PHASE_INPUTS_AND_OUTPUTS, | |
| "SampleDriver::executeSynchronously"); | |
| std::vector<RunTimePoolInfo> requestPoolInfos; | |
| if (!setRunTimePoolInfosFromHidlMemories(&requestPoolInfos, request.pools)) { | |
| cb(ErrorStatus::GENERAL_FAILURE, {}, kNoTiming); | |
| return Void(); | |
| } | |
| NNTRACE_FULL_SWITCH(NNTRACE_LAYER_DRIVER, NNTRACE_PHASE_EXECUTION, | |
| "SampleDriver::executeSynchronously"); | |
| CpuExecutor executor = mDriver->getExecutor(); | |
| if (measure == MeasureTiming::YES) deviceStart = now(); | |
| int n = executor.run(mModel, request, mPoolInfos, requestPoolInfos); | |
| if (measure == MeasureTiming::YES) deviceEnd = now(); | |
| VLOG(DRIVER) << "executor.run returned " << n; | |
| ErrorStatus executionStatus = convertResultCodeToErrorStatus(n); | |
| hidl_vec<OutputShape> outputShapes = executor.getOutputShapes(); | |
| if (measure == MeasureTiming::YES && executionStatus == ErrorStatus::NONE) { | |
| driverEnd = now(); | |
| Timing timing = {.timeOnDevice = uint64_t(microsecondsDuration(deviceEnd, deviceStart)), | |
| .timeInDriver = uint64_t(microsecondsDuration(driverEnd, driverStart))}; | |
| VLOG(DRIVER) << "executeSynchronously timing = " << toString(timing); | |
| cb(executionStatus, outputShapes, timing); | |
| } else { | |
| cb(executionStatus, outputShapes, kNoTiming); | |
| } | |
| return Void(); | |
| } | |
| Return<void> SamplePreparedModel::configureExecutionBurst( | |
| const sp<V1_2::IBurstCallback>& callback, | |
| const MQDescriptorSync<V1_2::FmqRequestDatum>& requestChannel, | |
| const MQDescriptorSync<V1_2::FmqResultDatum>& resultChannel, | |
| configureExecutionBurst_cb cb) { | |
| NNTRACE_FULL(NNTRACE_LAYER_DRIVER, NNTRACE_PHASE_EXECUTION, | |
| "SampleDriver::configureExecutionBurst"); | |
| const sp<V1_2::IBurstContext> burst = | |
| createBurstContext(callback, requestChannel, resultChannel, this); | |
| if (burst == nullptr) { | |
| cb(ErrorStatus::GENERAL_FAILURE, {}); | |
| } else { | |
| cb(ErrorStatus::NONE, burst); | |
| } | |
| return Void(); | |
| } | |
| Return<ErrorStatus> SamplePreparedModel::saveToCache(const hidl_handle&, const hidl_handle&, | |
| const HidlToken&) { | |
| NNTRACE_FULL(NNTRACE_LAYER_DRIVER, NNTRACE_PHASE_EXECUTION, "SamplePreparedModel::saveToCache"); | |
| return ErrorStatus::GENERAL_FAILURE; | |
| } | |
| } // namespace sample_driver | |
| } // namespace nn | |
| } // namespace android |