android-15.0.0_r3/s

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

#include "ShimPreparedModel.h"

#include <aidl/android/hardware/neuralnetworks/BnBurst.h>
#include <aidl/android/hardware/neuralnetworks/BnExecution.h>
#include <aidl/android/hardware/neuralnetworks/BnFencedExecutionCallback.h>
#include <aidl/android/hardware/neuralnetworks/ErrorStatus.h>
#include <aidl/android/hardware/neuralnetworks/OutputShape.h>
#include <aidl/android/hardware/neuralnetworks/RequestMemoryPool.h>
#include <android-base/chrono_utils.h>
#include <android-base/logging.h>
#include <android-base/scopeguard.h>
#include <android/binder_auto_utils.h>
#include <nnapi/TypeUtils.h>
#include <nnapi/hal/aidl/Conversions.h>
#include <nnapi/hal/aidl/Utils.h>

#include <algorithm>
#include <chrono>
#include <limits>
#include <memory>
#include <thread>
#include <unordered_map>
#include <utility>
#include <vector>

#include "ShimConverter.h"
#include "ShimUtils.h"

namespace aidl::android::hardware::neuralnetworks {

ErrorStatus ShimPreparedModel::parseInputs(
        const Request& request, bool measure, int64_t deadlineNs, int64_t loopTimeoutDurationNs,
        ::android::nn::sl_wrapper::Execution* execution,
        std::vector<std::shared_ptr<::android::nn::sl_wrapper::Memory>>* requestMemoryPools,
        const std::vector<TokenValuePair>& executionHints,
        const std::vector<ExtensionNameAndPrefix>& extensionNameToPrefix) {
    for (const auto& requestPool : request.pools) {
        switch (requestPool.getTag()) {
            case RequestMemoryPool::pool: {
                const auto& memoryPool = requestPool.get<RequestMemoryPool::pool>();
                std::shared_ptr<::android::nn::sl_wrapper::Memory> mem =
                        convertFromHAL(mNnapi.get(), memoryPool);
                if (!mem) {
                    LOG(ERROR) << "Failed to convert request HAL memory pools into SL memory";
                    return ErrorStatus::INVALID_ARGUMENT;
                }

                requestMemoryPools->push_back(mem);
                break;
            }
            case RequestMemoryPool::token: {
                int token = requestPool.get<RequestMemoryPool::token>();

                auto memory = mBufferTracker->get(static_cast<uint32_t>(token));
                if (memory == nullptr) {
                    return ErrorStatus::INVALID_ARGUMENT;
                }

                requestMemoryPools->push_back(memory);
                break;
            }
        }
    }

    // enable input and output padding
    const auto enablePaddingResult = execution->enableInputAndOutputPadding(true);
    if (enablePaddingResult != Result::NO_ERROR) {
        return convertResultToErrorStatus(enablePaddingResult);
    }

    const auto& model = mMainAndReferencedModels[0];

    if (request.inputs.size() > model.getInputs().size()) {
        return ErrorStatus::INVALID_ARGUMENT;
    }

    // set inputs
    for (int i = 0; i < request.inputs.size(); ++i) {
        const auto& input = request.inputs[i];
        ::android::nn::wrapper::OperandType operandType = model.getOperands()[model.getInputs()[i]];
        if (!input.hasNoValue) {
            if (input.dimensions.size() > 0) {
                operandType.updateDimensions(::android::nn::toUnsigned(input.dimensions).value());
            }
            auto result = execution->setInputFromMemory(
                    i, requestMemoryPools->at(input.location.poolIndex).get(),
                    input.location.offset, input.location.length, &operandType.operandType);
            if (result != Result::NO_ERROR) {
                return convertResultToErrorStatus(result);
            }
        } else {
            auto result = execution->setInput(i, nullptr, 0);
            if (result != Result::NO_ERROR) {
                return convertResultToErrorStatus(result);
            }
        }
    }

    if (request.outputs.size() > model.getOutputs().size()) {
        return ErrorStatus::INVALID_ARGUMENT;
    }
    // set outputs
    for (int i = 0; i < request.outputs.size(); ++i) {
        const auto& output = request.outputs[i];
        ::android::nn::wrapper::OperandType operandType =
                model.getOperands()[model.getOutputs()[i]];

        if (!output.hasNoValue) {
            if (output.dimensions.size() > 0) {
                operandType.updateDimensions(::android::nn::toUnsigned(output.dimensions).value());
            }
            auto result = execution->setOutputFromMemory(
                    i, requestMemoryPools->at(output.location.poolIndex).get(),
                    output.location.offset, output.location.length, &operandType.operandType);
            if (result != Result::NO_ERROR) {
                return convertResultToErrorStatus(result);
            }
        } else {
            auto result = execution->setOutput(i, nullptr, 0);
            if (result != Result::NO_ERROR) {
                return convertResultToErrorStatus(result);
            }
        }
    }

    if (measure) {
        execution->setMeasureTiming(true);
    }

    if (deadlineNs > -1) {
        std::chrono::time_point<::android::base::boot_clock> deadlinePoint(
                std::chrono::nanoseconds{deadlineNs});
        const auto currentTime = ::android::base::boot_clock::now();
        const auto timeoutDuration = std::chrono::nanoseconds(deadlinePoint - currentTime);
        if (timeoutDuration <= std::chrono::nanoseconds::zero()) {
            return ErrorStatus::MISSED_DEADLINE_TRANSIENT;
        } else {
            auto result = execution->setTimeout(std::max<uint64_t>(1, timeoutDuration.count()));
            if (result != Result::NO_ERROR) {
                return convertResultToErrorStatus(result);
            }
        }
    }

    if (loopTimeoutDurationNs > 0) {
        execution->setLoopTimeout(loopTimeoutDurationNs);
    }

    if (!executionHints.empty() || !extensionNameToPrefix.empty()) {
        std::unordered_map<uint16_t, std::string> prefixToName;
        for (const auto [name, prefix] : extensionNameToPrefix) {
            prefixToName.emplace(prefix, name);
        }

        for (const auto& [token, value] : executionHints) {
            const auto uToken = static_cast<uint32_t>(token);
            const auto prefix = ::android::nn::getExtensionPrefix(uToken);
            const auto attributeCodeWithinExtension = ::android::nn::getTypeWithinExtension(uToken);

            const auto it = prefixToName.find(prefix);
            if (it == prefixToName.end()) {
                return ErrorStatus::INVALID_ARGUMENT;
            }
            const std::string& extensionName = it->second;

            const auto result = execution->addExtensionAttribute(
                    extensionName, attributeCodeWithinExtension, value);
            if (result != Result::NO_ERROR) {
                return convertResultToErrorStatus(result);
            }
        }
    }

    return ErrorStatus::NONE;
}

class ShimFencedExecutionCallback : public BnFencedExecutionCallback {
   public:
    ShimFencedExecutionCallback(
            std::shared_ptr<::android::nn::sl_wrapper::Execution> execution, Event e,
            std::vector<std::shared_ptr<::android::nn::sl_wrapper::Memory>> memoryPools,
            bool measureTiming)
        : mMemoryPools(std::move(memoryPools)),
          mExecution(std::move(execution)),
          mEvent(std::move(e)),
          mMeasureTiming(measureTiming) {}

    ndk::ScopedAStatus getExecutionInfo(Timing* timingLaunched, Timing* timingFenced,
                                        ErrorStatus* errorStatus) override {
        auto status = mEvent.wait();
        *errorStatus = convertResultToErrorStatus(status);

        if (mMeasureTiming) {
            uint64_t duration;
            constexpr int64_t int64cap = std::numeric_limits<int64_t>::max();
            // Special value used for "no measurements"
            constexpr uint64_t uint64cap = std::numeric_limits<uint64_t>::max();
            auto result = mExecution->getDuration(Duration::ON_HARDWARE, &duration);
            SLW2SAS_RETURN_IF_ERROR(result);
            timingLaunched->timeOnDeviceNs = (duration == uint64cap) ? -1
                                             : (duration > int64cap)
                                                     ? int64cap
                                                     : static_cast<int64_t>(duration);

            result = mExecution->getDuration(Duration::IN_DRIVER, &duration);
            SLW2SAS_RETURN_IF_ERROR(result);
            timingLaunched->timeInDriverNs = (duration == uint64cap) ? -1
                                             : (duration > int64cap)
                                                     ? int64cap
                                                     : static_cast<int64_t>(duration);

            result = mExecution->getDuration(Duration::FENCED_ON_HARDWARE, &duration);
            SLW2SAS_RETURN_IF_ERROR(result);
            timingFenced->timeOnDeviceNs = (duration == uint64cap) ? -1
                                           : (duration > int64cap) ? int64cap
                                                                   : static_cast<int64_t>(duration);

            result = mExecution->getDuration(Duration::FENCED_IN_DRIVER, &duration);
            SLW2SAS_RETURN_IF_ERROR(result);
            timingFenced->timeInDriverNs = (duration == uint64cap) ? -1
                                           : (duration > int64cap) ? int64cap
                                                                   : static_cast<int64_t>(duration);
        } else {
            timingFenced->timeOnDeviceNs = -1;
            timingFenced->timeInDriverNs = -1;
            timingLaunched->timeOnDeviceNs = -1;
            timingLaunched->timeInDriverNs = -1;
        }

        return ndk::ScopedAStatus::ok();
    }

   private:
    std::vector<std::shared_ptr<::android::nn::sl_wrapper::Memory>> mMemoryPools;
    std::shared_ptr<::android::nn::sl_wrapper::Execution> mExecution;
    ::android::nn::wrapper::Event mEvent;
    bool mMeasureTiming;
};

static ndk::ScopedAStatus executeFencedInternal(
        const std::shared_ptr<const NnApiSupportLibrary>& nnapi,
        const std::shared_ptr<::android::nn::sl_wrapper::Execution>& execution,
        std::vector<std::shared_ptr<::android::nn::sl_wrapper::Memory>> requestMemoryPools,
        const std::vector<ndk::ScopedFileDescriptor>& waitFor, int64_t durationNs,
        bool measureTiming, FencedExecutionResult* fencedExecutionResult) {
    CHECK(execution != nullptr);
    CHECK(fencedExecutionResult != nullptr);

    std::vector<const ANeuralNetworksEvent*> deps(waitFor.size());
    auto createResult = Result::NO_ERROR;
    std::transform(waitFor.begin(), waitFor.end(), deps.begin(),
                   [&](const ::ndk::ScopedFileDescriptor& e) {
                       ANeuralNetworksEvent* r = nullptr;
                       if (createResult == Result::NO_ERROR) {
                           createResult = static_cast<Result>(
                                   nnapi->getFL5()->ANeuralNetworksEvent_createFromSyncFenceFd(
                                           e.get(), &r));
                       }
                       return r;
                   });

    const auto guard = ::android::base::make_scope_guard([nnapi, deps] {
        for (auto& dep : deps) {
            if (dep != nullptr) {
                nnapi->getFL5()->ANeuralNetworksEvent_free(const_cast<ANeuralNetworksEvent*>(dep));
            }
        }
    });

    SLW2SAS_RETURN_IF_ERROR(createResult);

    Event e(nnapi.get());
    auto result = execution->startComputeWithDependencies(deps, durationNs, &e);
    SLW2SAS_RETURN_IF_ERROR(result);

    int syncFence = -1;
    fencedExecutionResult->syncFence = ndk::ScopedFileDescriptor(
            (e.getSyncFenceFd(&syncFence) == Result::NO_ERROR) ? syncFence : -1);
    fencedExecutionResult->callback = ndk::SharedRefBase::make<ShimFencedExecutionCallback>(
            execution, std::move(e), requestMemoryPools, measureTiming);

    return ndk::ScopedAStatus::ok();
}

::ndk::ScopedAStatus ShimPreparedModel::executeFencedCommon(
        const Request& request, const std::vector<::ndk::ScopedFileDescriptor>& waitFor,
        bool measureTiming, int64_t deadlineNs, int64_t loopTimeoutDurationNs, int64_t durationNs,
        const std::vector<TokenValuePair>& executionHints,
        const std::vector<ExtensionNameAndPrefix>& extensionNameToPrefix,
        FencedExecutionResult* fencedExecutionResult) {
    CHECK(fencedExecutionResult != nullptr);

    if (deadlineNs < -1) {
        LOG(ERROR) << "Invalid deadline value, must be >= -1";
        return ndk::ScopedAStatus::fromServiceSpecificError(
                static_cast<int>(ErrorStatus::INVALID_ARGUMENT));
    }
    auto execution =
            std::make_shared<::android::nn::sl_wrapper::Execution>(mNnapi.get(), &mCompilation);
    std::vector<std::shared_ptr<::android::nn::sl_wrapper::Memory>> requestMemoryPools;
    auto errorStatus =
            parseInputs(request, measureTiming, deadlineNs, loopTimeoutDurationNs, execution.get(),
                        &requestMemoryPools, executionHints, extensionNameToPrefix);
    if (errorStatus != ErrorStatus::NONE) {
        return toAStatus(errorStatus);
    }
    return executeFencedInternal(mNnapi, execution, std::move(requestMemoryPools), waitFor,
                                 durationNs, measureTiming, fencedExecutionResult);
}

::ndk::ScopedAStatus ShimPreparedModel::executeFenced(
        const ::aidl::android::hardware::neuralnetworks::Request& request,
        const std::vector<::ndk::ScopedFileDescriptor>& waitFor, bool measureTiming,
        int64_t deadlineNs, int64_t loopTimeoutDurationNs, int64_t durationNs,
        FencedExecutionResult* fencedExecutionResult) {
    return executeFencedCommon(request, waitFor, measureTiming, deadlineNs, loopTimeoutDurationNs,
                               durationNs, /*executionHints=*/{}, /*extensionNameToPrefix=*/{},
                               fencedExecutionResult);
}

static ndk::ScopedAStatus executeSynchronouslyInternal(
        const std::shared_ptr<::android::nn::sl_wrapper::Execution>& execution, bool measureTiming,
        int numOutputs, ExecutionResult* executionResult) {
    CHECK(execution != nullptr);
    CHECK(executionResult != nullptr);

    auto result = execution->compute();
    auto errorStatus = convertResultToErrorStatus(result);

    std::vector<OutputShape> outputShapes;
    outputShapes.reserve(numOutputs);
    bool sufficientSize = true;
    for (int i = 0; i < numOutputs; ++i) {
        OutputShape outputShape;
        std::vector<uint32_t> outputDims;
        auto result = execution->getOutputOperandDimensions(i, &outputDims);
        if (result == Result::NO_ERROR) {
            outputShape.isSufficient = true;
            outputShape.dimensions.assign(outputDims.begin(), outputDims.end());
        } else if (result == Result::OUTPUT_INSUFFICIENT_SIZE) {
            sufficientSize = false;
            outputShape.isSufficient = false;
            outputShape.dimensions.assign(outputDims.begin(), outputDims.end());
        } else {
            if (errorStatus == ErrorStatus::NONE) {
                errorStatus = ErrorStatus::GENERAL_FAILURE;
            }
        }
        outputShapes.push_back(std::move(outputShape));
    }

    int64_t timeOnDeviceNs = -1;
    int64_t timeInDriverNs = -1;
    if (measureTiming && errorStatus == ErrorStatus::NONE) {
        uint64_t duration;
        constexpr int64_t int64cap = std::numeric_limits<int64_t>::max();
        // Special value used for "no measurements"
        constexpr uint64_t uint64cap = std::numeric_limits<uint64_t>::max();
        auto result = execution->getDuration(Duration::ON_HARDWARE, &duration);
        SLW2SAS_RETURN_IF_ERROR(result);
        timeOnDeviceNs = (duration == uint64cap) ? -1
                         : (duration > int64cap) ? int64cap
                                                 : static_cast<int64_t>(duration);

        result = execution->getDuration(Duration::IN_DRIVER, &duration);
        SLW2SAS_RETURN_IF_ERROR(result);
        timeInDriverNs = (duration == uint64cap) ? -1
                         : (duration > int64cap) ? int64cap
                                                 : static_cast<int64_t>(duration);
    }

    *executionResult =
            ExecutionResult{sufficientSize,
                            std::move(outputShapes),
                            {.timeOnDeviceNs = timeOnDeviceNs, .timeInDriverNs = timeInDriverNs}};
    if (errorStatus == ErrorStatus::NONE || errorStatus == ErrorStatus::OUTPUT_INSUFFICIENT_SIZE) {
        return ndk::ScopedAStatus::ok();
    }
    return toAStatus(errorStatus);
}

::ndk::ScopedAStatus ShimPreparedModel::executeSynchronouslyCommon(
        const Request& request, bool measureTiming, int64_t deadlineNs,
        int64_t loopTimeoutDurationNs, const std::vector<TokenValuePair>& executionHints,
        const std::vector<ExtensionNameAndPrefix>& extensionNameToPrefix,
        ExecutionResult* executionResult) {
    CHECK(executionResult != nullptr);

    if (deadlineNs < -1) {
        LOG(ERROR) << "Invalid deadline value, must be >= -1";
        return ndk::ScopedAStatus::fromServiceSpecificError(
                static_cast<int>(ErrorStatus::INVALID_ARGUMENT));
    }

    auto execution =
            std::make_shared<::android::nn::sl_wrapper::Execution>(mNnapi.get(), &mCompilation);
    std::vector<std::shared_ptr<::android::nn::sl_wrapper::Memory>> requestMemoryPools;
    auto errorStatus =
            parseInputs(request, measureTiming, deadlineNs, loopTimeoutDurationNs, execution.get(),
                        &requestMemoryPools, executionHints, extensionNameToPrefix);
    if (errorStatus != ErrorStatus::NONE) {
        return toAStatus(errorStatus);
    }
    return executeSynchronouslyInternal(execution, measureTiming, request.outputs.size(),
                                        executionResult);
}

::ndk::ScopedAStatus ShimPreparedModel::executeSynchronously(
        const Request& request, bool measureTiming, int64_t deadlineNs,
        int64_t loopTimeoutDurationNs,
        ::aidl::android::hardware::neuralnetworks::ExecutionResult* executionResult) {
    return executeSynchronouslyCommon(request, measureTiming, deadlineNs, loopTimeoutDurationNs,
                                      /*executionHints=*/{}, /*extensionNameToPrefix=*/{},
                                      executionResult);
}

::ndk::ScopedAStatus ShimPreparedModel::executeSynchronouslyWithConfig(
        const Request& request, const ExecutionConfig& config, int64_t deadlineNs,
        ExecutionResult* executionResult) {
    return executeSynchronouslyCommon(request, config.measureTiming, deadlineNs,
                                      config.loopTimeoutDurationNs, config.executionHints,
                                      config.extensionNameToPrefix, executionResult);
}

::ndk::ScopedAStatus ShimPreparedModel::executeFencedWithConfig(
        const Request& request, const std::vector<ndk::ScopedFileDescriptor>& waitFor,
        const ExecutionConfig& config, int64_t deadlineNs, int64_t durationNs,
        FencedExecutionResult* executionResult) {
    return executeFencedCommon(request, waitFor, config.measureTiming, deadlineNs,
                               config.loopTimeoutDurationNs, durationNs, config.executionHints,
                               config.extensionNameToPrefix, executionResult);
}

// TODO(183397380): make it use ANNBurst object
class ShimBurst : public BnBurst {
   public:
    // Precondition: preparedModel != nullptr
    explicit ShimBurst(std::shared_ptr<ShimPreparedModel> preparedModel);

    ndk::ScopedAStatus executeSynchronously(const Request& request,
                                            const std::vector<int64_t>& memoryIdentifierTokens,
                                            bool measureTiming, int64_t deadlineNs,
                                            int64_t loopTimeoutDurationNs,
                                            ExecutionResult* executionResult) override;
    ndk::ScopedAStatus executeSynchronouslyWithConfig(
            const Request& request, const std::vector<int64_t>& memoryIdentifierTokens,
            const ExecutionConfig& config, int64_t deadlineNs,
            ExecutionResult* executionResult) override;
    ndk::ScopedAStatus releaseMemoryResource(int64_t memoryIdentifierToken) override;

   protected:
    std::atomic_flag mExecutionInFlight = ATOMIC_FLAG_INIT;
    const std::shared_ptr<ShimPreparedModel> kPreparedModel;
};

ndk::ScopedAStatus ShimPreparedModel::configureExecutionBurst(std::shared_ptr<IBurst>* burst) {
    std::shared_ptr<ShimPreparedModel> self = this->template ref<ShimPreparedModel>();
    *burst = ndk::SharedRefBase::make<ShimBurst>(std::move(self));
    return ndk::ScopedAStatus::ok();
}

ShimBurst::ShimBurst(std::shared_ptr<ShimPreparedModel> preparedModel)
    : kPreparedModel(std::move(preparedModel)) {
    CHECK(kPreparedModel != nullptr);
}

ndk::ScopedAStatus ShimBurst::executeSynchronously(
        const Request& request, const std::vector<int64_t>& memoryIdentifierTokens,
        bool measureTiming, int64_t deadlineNs, int64_t loopTimeoutDurationNs,
        ExecutionResult* executionResult) {
    if (request.pools.size() != memoryIdentifierTokens.size()) {
        return toAStatus(ErrorStatus::INVALID_ARGUMENT,
                         "request.pools.size() != memoryIdentifierTokens.size()");
    }
    if (!std::all_of(memoryIdentifierTokens.begin(), memoryIdentifierTokens.end(),
                     [](int64_t token) { return token >= -1; })) {
        return toAStatus(ErrorStatus::INVALID_ARGUMENT, "Invalid memoryIdentifierTokens");
    }

    // Ensure at most one execution is in flight at a time.
    const bool executionAlreadyInFlight = mExecutionInFlight.test_and_set();
    if (executionAlreadyInFlight) {
        return toAStatus(ErrorStatus::GENERAL_FAILURE,
                         "Burst object supports at most one execution at a time");
    }
    const auto guard = ::android::base::make_scope_guard([this] { mExecutionInFlight.clear(); });

    return kPreparedModel->executeSynchronously(request, measureTiming, deadlineNs,
                                                loopTimeoutDurationNs, executionResult);
}

ndk::ScopedAStatus ShimBurst::executeSynchronouslyWithConfig(
        const Request& request, const std::vector<int64_t>& memoryIdentifierTokens,
        const ExecutionConfig& config, int64_t deadlineNs, ExecutionResult* executionResult) {
    if (request.pools.size() != memoryIdentifierTokens.size()) {
        return toAStatus(ErrorStatus::INVALID_ARGUMENT,
                         "request.pools.size() != memoryIdentifierTokens.size()");
    }
    if (!std::all_of(memoryIdentifierTokens.begin(), memoryIdentifierTokens.end(),
                     [](int64_t token) { return token >= -1; })) {
        return toAStatus(ErrorStatus::INVALID_ARGUMENT, "Invalid memoryIdentifierTokens");
    }

    // Ensure at most one execution is in flight at a time.
    const bool executionAlreadyInFlight = mExecutionInFlight.test_and_set();
    if (executionAlreadyInFlight) {
        return toAStatus(ErrorStatus::GENERAL_FAILURE,
                         "Burst object supports at most one execution at a time");
    }
    const auto guard = ::android::base::make_scope_guard([this] { mExecutionInFlight.clear(); });

    return kPreparedModel->executeSynchronouslyWithConfig(request, config, deadlineNs,
                                                          executionResult);
}

ndk::ScopedAStatus ShimBurst::releaseMemoryResource(int64_t memoryIdentifierToken) {
    if (memoryIdentifierToken < -1) {
        return toAStatus(ErrorStatus::INVALID_ARGUMENT, "Invalid memoryIdentifierToken");
    }
    return ndk::ScopedAStatus::ok();
}

class ShimExecution : public BnExecution {
   public:
    explicit ShimExecution(
            std::shared_ptr<const NnApiSupportLibrary> nnapi,
            std::shared_ptr<::android::nn::sl_wrapper::Execution> execution,
            std::vector<std::shared_ptr<::android::nn::sl_wrapper::Memory>> requestMemoryPools,
            bool measureTiming, int numberOfOutputs);

    ndk::ScopedAStatus executeSynchronously(int64_t deadlineNs,
                                            ExecutionResult* executionResult) override;
    ndk::ScopedAStatus executeFenced(const std::vector<ndk::ScopedFileDescriptor>& waitFor,
                                     int64_t deadlineNs, int64_t durationNs,
                                     FencedExecutionResult* fencedExecutionResult) override;

   protected:
    std::atomic_flag mExecutionInFlight = ATOMIC_FLAG_INIT;
    std::shared_ptr<const NnApiSupportLibrary> mNnapi;
    std::shared_ptr<::android::nn::sl_wrapper::Execution> mExecution;
    const std::vector<std::shared_ptr<::android::nn::sl_wrapper::Memory>> kRequestMemoryPools;
    const bool kMeasureTiming;
    const int kNumberOfOutputs;
};

ndk::ScopedAStatus ShimPreparedModel::createReusableExecution(
        const Request& request, const ExecutionConfig& config,
        std::shared_ptr<IExecution>* execution) {
    auto wrapperExecution =
            std::make_shared<::android::nn::sl_wrapper::Execution>(mNnapi.get(), &mCompilation);
    std::vector<std::shared_ptr<::android::nn::sl_wrapper::Memory>> requestMemoryPools;
    auto errorStatus =
            parseInputs(request, config.measureTiming, kNoDeadline, config.loopTimeoutDurationNs,
                        wrapperExecution.get(), &requestMemoryPools, config.executionHints,
                        config.extensionNameToPrefix);
    if (errorStatus != ErrorStatus::NONE) {
        return toAStatus(errorStatus);
    }
    auto result = wrapperExecution->setReusable(true);
    SLW2SAS_RETURN_IF_ERROR(result);

    *execution = ndk::SharedRefBase::make<ShimExecution>(
            mNnapi, std::move(wrapperExecution), std::move(requestMemoryPools),
            config.measureTiming, request.outputs.size());
    return ndk::ScopedAStatus::ok();
}

ShimExecution::ShimExecution(
        std::shared_ptr<const NnApiSupportLibrary> nnapi,
        std::shared_ptr<::android::nn::sl_wrapper::Execution> execution,
        std::vector<std::shared_ptr<::android::nn::sl_wrapper::Memory>> requestMemoryPools,
        bool measureTiming, int numberOfOutputs)
    : mNnapi(std::move(nnapi)),
      mExecution(std::move(execution)),
      kRequestMemoryPools(std::move(requestMemoryPools)),
      kMeasureTiming(measureTiming),
      kNumberOfOutputs(numberOfOutputs) {}

ndk::ScopedAStatus ShimExecution::executeSynchronously(int64_t deadlineNs,
                                                       ExecutionResult* executionResult) {
    if (deadlineNs < -1) {
        LOG(ERROR) << "Invalid deadline value, must be >= -1";
        return ndk::ScopedAStatus::fromServiceSpecificError(
                static_cast<int>(ErrorStatus::INVALID_ARGUMENT));
    }

    // Ensure at most one execution is in flight at a time.
    const bool executionAlreadyInFlight = mExecutionInFlight.test_and_set();
    if (executionAlreadyInFlight) {
        return toAStatus(ErrorStatus::GENERAL_FAILURE,
                         "Execution object supports at most one execution at a time");
    }
    const auto guard = ::android::base::make_scope_guard([this] { mExecutionInFlight.clear(); });

    return executeSynchronouslyInternal(mExecution, kMeasureTiming, kNumberOfOutputs,
                                        executionResult);
}

ndk::ScopedAStatus ShimExecution::executeFenced(
        const std::vector<ndk::ScopedFileDescriptor>& waitFor, int64_t deadlineNs,
        int64_t durationNs, FencedExecutionResult* fencedExecutionResult) {
    if (deadlineNs < -1) {
        LOG(ERROR) << "Invalid deadline value, must be >= -1";
        return ndk::ScopedAStatus::fromServiceSpecificError(
                static_cast<int>(ErrorStatus::INVALID_ARGUMENT));
    }

    // Ensure at most one execution is in flight at a time.
    const bool executionAlreadyInFlight = mExecutionInFlight.test_and_set();
    if (executionAlreadyInFlight) {
        return toAStatus(ErrorStatus::GENERAL_FAILURE,
                         "Execution object supports at most one execution at a time");
    }
    const auto guard = ::android::base::make_scope_guard([this] { mExecutionInFlight.clear(); });

    return executeFencedInternal(mNnapi, mExecution, kRequestMemoryPools, waitFor, durationNs,
                                 kMeasureTiming, fencedExecutionResult);
}

}  // namespace aidl::android::hardware::neuralnetworks