109     static std::shared_ptr<DriverDevice> create(SharedDevice device);
114     const std::string& getName() const override { return kInterface->getName(); }  in getName()
115     const std::string& getVersionString() const override { return kInterface->getVersionString(); }  in getVersionString()
118     const std::vector<Extension>& getSupportedExtensions() const override {  in getSupportedExtensions()
121     std::vector<bool> getSupportedOperations(const MetaModel& metaModel) const override;
138     std::pair<uint32_t, uint32_t> getNumberOfCacheFilesNeeded() const override {  in getNumberOfCacheFilesNeeded()
155     std::pair<int, std::shared_ptr<RuntimePreparedModel>> prepareModel(
158             const std::optional<CacheToken>& maybeToken,
159             const std::vector<TokenValuePair>& metaData,
160             const std::vector<ExtensionNameAndPrefix>& extensionNameAndPrefix) const override;
162     std::pair<int, std::unique_ptr<RuntimeMemory>> allocate(const MemoryDescriptor& desc,
168     GeneralResult<std::vector<bool>> getSupportedOperationsImpl(const MetaModel& metaModel) const;
193     std::tuple<int, std::vector<OutputShape>, Timing> execute(
194             const std::vector<ModelArgumentInfo>& inputs,
195             const std::vector<ModelArgumentInfo>& outputs,
196             const std::vector<const RuntimeMemory*>& memories, const SharedBurst& burstController,
199             const std::vector<TokenValuePair>& metaData) const override;
201     std::tuple<int, int, ExecuteFencedInfoCallback, Timing> executeFenced(
202             const std::vector<ModelArgumentInfo>& inputs,
203             const std::vector<ModelArgumentInfo>& outputs,
204             const std::vector<const RuntimeMemory*>& memories, const std::vector<int>& waitFor,
208             const std::vector<TokenValuePair>& metaData) const override;
210     std::pair<int, std::shared_ptr<RuntimeExecution>> createReusableExecution(
211             const std::vector<ModelArgumentInfo>& inputs,
212             const std::vector<ModelArgumentInfo>& outputs,
213             const std::vector<const RuntimeMemory*>& memories, MeasureTiming measure,
215             const std::vector<TokenValuePair>& metaData) const override;
239                     std::vector<const RuntimeMemory*> memories, MeasureTiming measure,  in DriverExecution()
241                     const std::vector<TokenValuePair>& metaData)  in DriverExecution()
242         : kExecution(std::move(execution)),  in DriverExecution()
243           kRequest(std::move(request)),  in DriverExecution()
244           kMemories(std::move(memories)),  in DriverExecution()
246           kLoopTimeoutDuration(std::move(loopTimeoutDuration)),  in DriverExecution()
252     std::tuple<int, std::vector<OutputShape>, Timing> compute(
255     std::tuple<int, int, ExecuteFencedInfoCallback, Timing> computeFenced(
256             const std::vector<int>& waitFor, const OptionalTimePoint& deadline,
264     const std::vector<const RuntimeMemory*> kMemories;
267     mutable std::map<const IBurst*, SharedExecution> mCachedBurstExecutions;
273     std::vector<TokenValuePair> kMetaData;
276 DriverDevice::DriverDevice(SharedDevice device) : kInterface(std::move(device)) {  in DriverDevice()
286 std::shared_ptr<DriverDevice> DriverDevice::create(SharedDevice device) {  in create()
292     return std::make_shared<DriverDevice>(std::move(device));  in create()
322 GeneralResult<std::vector<bool>> DriverDevice::getSupportedOperationsImpl(  in getSupportedOperationsImpl()
331     const std::vector<bool> supported = NN_TRY(kInterface->getSupportedOperations(sliceModel));  in getSupportedOperationsImpl()
340     std::vector<bool> remappedSupported(operationCount, false);  in getSupportedOperationsImpl()
349 std::vector<bool> DriverDevice::getSupportedOperations(const MetaModel& metaModel) const {  in getSupportedOperations()
357         return std::vector<bool>(model.main.operations.size(), false);  in getSupportedOperations()
360     std::vector<bool>& supportedOperations = result.value();  in getSupportedOperations()
366     const uint32_t baseAccumulator = std::hash<std::string>{}(getName());  in getSupportedOperations()
375         auto accumulateOperands = [&model, &accumulator](const std::vector<uint32_t>& operands) {  in getSupportedOperations()
402 static GeneralResult<SharedHandle> createCacheHandle(const std::string& filename,  in createCacheHandle()
411     return std::make_shared<const Handle>(std::move(fd));  in createCacheHandle()
416 static GeneralResult<std::vector<SharedHandle>> createCacheHandleVec(  in createCacheHandleVec()
417         uint32_t numCacheFiles, const std::string& baseFilename, bool createIfNotExist) {  in createCacheHandleVec()
419     std::vector<SharedHandle> handles;  in createCacheHandleVec()
422         std::string filename = baseFilename + std::to_string(i);  in createCacheHandleVec()
433         const std::pair<uint32_t, uint32_t>& numCacheFiles, bool createIfNotExist) {  in getCacheHandles()
434     if (const auto* cacheHandles = std::get_if<CacheHandles>(&cacheInfo.variant)) {  in getCacheHandles()
450     std::string filename(kByteSizeOfCacheToken * 2 + 1, '0');  in getCacheHandles()
456     const auto& cacheDir = std::get<CacheDir>(cacheInfo.variant);  in getCacheHandles()
458     std::string cacheFileName = cacheDir + filename;  in getCacheHandles()
462     std::vector<SharedHandle> modelCache =  in getCacheHandles()
466     std::vector<SharedHandle> dataCache =  in getCacheHandles()
470             .modelCache = std::move(modelCache),  in getCacheHandles()
471             .dataCache = std::move(dataCache),  in getCacheHandles()
484 std::pair<int, std::shared_ptr<RuntimePreparedModel>> DriverDevice::prepareModel(  in prepareModel()
487         const std::optional<CacheToken>& maybeToken, const std::vector<TokenValuePair>& metaData,  in prepareModel()
488         const std::vector<ExtensionNameAndPrefix>& extensionNameAndPrefix) const {  in prepareModel()
495                     std::make_shared<DriverPreparedModel>(this, std::move(result).value())};  in prepareModel()
509             cache = std::move(result).value();  in prepareModel()
530     SharedPreparedModel preparedModel = std::move(result).value();  in prepareModel()
534             std::make_shared<DriverPreparedModel>(this, std::move(preparedModel))};  in prepareModel()
537 std::pair<int, std::unique_ptr<RuntimeMemory>> DriverDevice::allocate(const MemoryDescriptor& desc,  in allocate()
540     std::vector<SharedPreparedModel> preparedModels(desc.preparedModels.size());  in allocate()
541     std::transform(desc.preparedModels.begin(), desc.preparedModels.end(), preparedModels.begin(),  in allocate()
554     return MemoryFromDevice::create(std::move(result).value());  in allocate()
557 static Request createDriverRequest(const std::vector<ModelArgumentInfo>& inputs,  in createDriverRequest()
558                                    const std::vector<ModelArgumentInfo>& outputs,  in createDriverRequest()
559                                    const std::vector<const RuntimeMemory*>& memories) {  in createDriverRequest()
562     std::transform(inputs.begin(), inputs.end(), std::back_inserter(request.inputs),  in createDriverRequest()
565     std::transform(outputs.begin(), outputs.end(), std::back_inserter(request.outputs),  in createDriverRequest()
568     std::transform(memories.begin(), memories.end(), std::back_inserter(request.pools),  in createDriverRequest()
579 std::tuple<int, std::vector<OutputShape>, Timing> DriverPreparedModel::execute(  in execute()
580         const std::vector<ModelArgumentInfo>& inputs, const std::vector<ModelArgumentInfo>& outputs,  in execute()
581         const std::vector<const RuntimeMemory*>& memories, const SharedBurst& burstController,  in execute()
584         const std::vector<TokenValuePair>& metaData) const {  in execute()
591     ExecutionResult<std::pair<std::vector<OutputShape>, Timing>> result;  in execute()
598             if (const auto* maybeMemory = std::get_if<SharedMemory>(&pool)) {  in execute()
613     std::vector<OutputShape> outputShapes;  in execute()
618         std::tie(outputShapes, timing) = std::move(result).value();  in execute()
620         auto [message, code, returnedOutputShapes] = std::move(result).error();  in execute()
626             outputShapes = std::move(returnedOutputShapes);  in execute()
628         return {n, std::move(outputShapes), timing};  in execute()
632     return {ANEURALNETWORKS_NO_ERROR, std::move(outputShapes), timing};  in execute()
635 std::tuple<int, int, ExecuteFencedInfoCallback, Timing> DriverPreparedModel::executeFenced(  in executeFenced()
636         const std::vector<ModelArgumentInfo>& inputs, const std::vector<ModelArgumentInfo>& outputs,  in executeFenced()
637         const std::vector<const RuntimeMemory*>& memories, const std::vector<int>& waitFor,  in executeFenced()
641         const std::vector<TokenValuePair>& metaData) const {  in executeFenced()
643     CHECK(std::all_of(waitFor.begin(), waitFor.end(), [](int fd) { return fd >= 0; }));  in executeFenced()
649     std::vector<SyncFence> waitForHandles;  in executeFenced()
673         std::tie(syncFence, executeFencedInfoCallback) = std::move(result).value();  in executeFenced()
695         std::tie(std::ignore, timing) = result.value();  in executeFenced()
711 std::pair<int, std::shared_ptr<RuntimeExecution>> DriverPreparedModel::createReusableExecution(  in createReusableExecution()
712         const std::vector<ModelArgumentInfo>& inputs, const std::vector<ModelArgumentInfo>& outputs,  in createReusableExecution()
713         const std::vector<const RuntimeMemory*>& memories, MeasureTiming measure,  in createReusableExecution()
715         const std::vector<TokenValuePair>& metaData) const {  in createReusableExecution()
727     auto execution = std::make_shared<DriverExecution>(  in createReusableExecution()
728             std::move(result).value(), std::move(request), memories, measure, loopTimeoutDuration,  in createReusableExecution()
730     return {ANEURALNETWORKS_NO_ERROR, std::move(execution)};  in createReusableExecution()
733 std::tuple<int, std::vector<OutputShape>, Timing> DriverExecution::compute(  in compute()
746                 if (const auto* maybeMemory = std::get_if<SharedMemory>(&pool)) {  in compute()
760             execution = std::move(createResult).value();  in compute()
773         auto [message, code, returnedOutputShapes] = std::move(result).error();  in compute()
779             return {n, std::move(returnedOutputShapes), {}};  in compute()
785     auto [outputShapes, timing] = std::move(result).value();  in compute()
786     return {ANEURALNETWORKS_NO_ERROR, std::move(outputShapes), timing};  in compute()
789 std::tuple<int, int, ExecuteFencedInfoCallback, Timing> DriverExecution::computeFenced(  in computeFenced()
790         const std::vector<int>& waitFor, const OptionalTimePoint& deadline,  in computeFenced()
793     CHECK(std::all_of(waitFor.begin(), waitFor.end(), [](int fd) { return fd >= 0; }));  in computeFenced()
795     std::vector<SyncFence> waitForHandles;  in computeFenced()
817         std::tie(syncFence, executeFencedInfoCallback) = std::move(result).value();  in computeFenced()
837         std::tie(std::ignore, timing) = result.value();  in computeFenced()
863     static std::shared_ptr<CpuDevice> get() {  in get()
864         static std::shared_ptr<CpuDevice> instance(new CpuDevice);  in get()
868     const std::string& getName() const override { return kName; }  in getName()
869     const std::string& getVersionString() const override { return kVersionString; }  in getVersionString()
872     const std::vector<Extension>& getSupportedExtensions() const override {  in getSupportedExtensions()
875     std::vector<bool> getSupportedOperations(const MetaModel& metaModel) const override;
888     std::pair<uint32_t, uint32_t> getNumberOfCacheFilesNeeded() const override {  in getNumberOfCacheFilesNeeded()
894     std::pair<int, std::shared_ptr<RuntimePreparedModel>> prepareModel(
897             const std::optional<CacheToken>& maybeToken,
898             const std::vector<TokenValuePair>& metaData,
899             const std::vector<ExtensionNameAndPrefix>& extensionNameAndPrefix) const override;
901     std::pair<int, std::unique_ptr<RuntimeMemory>> allocate(const MemoryDescriptor& desc,
907     const std::string kName = "nnapi-reference";
909     const std::string kVersionString = build::GetBuildNumber();
911     const std::string kVersionString = "UNKNOWN";
917     const std::vector<Extension> kSupportedExtensions{/* No extensions. */};
926     static std::pair<int, std::shared_ptr<RuntimePreparedModel>> create(Model model);
931     std::tuple<int, std::vector<OutputShape>, Timing> execute(
932             const std::vector<ModelArgumentInfo>& inputs,
933             const std::vector<ModelArgumentInfo>& outputs,
934             const std::vector<const RuntimeMemory*>& memories, const SharedBurst& burstController,
937             const std::vector<TokenValuePair>& metaData) const override;
941     std::tuple<int, int, ExecuteFencedInfoCallback, Timing> executeFenced(
942             const std::vector<ModelArgumentInfo>& inputs,
943             const std::vector<ModelArgumentInfo>& outputs,
944             const std::vector<const RuntimeMemory*>& memories, const std::vector<int>& waitFor,
948             const std::vector<TokenValuePair>& metaData) const override;
950     std::pair<int, std::shared_ptr<RuntimeExecution>> createReusableExecution(
951             const std::vector<ModelArgumentInfo>& inputs,
952             const std::vector<ModelArgumentInfo>& outputs,
953             const std::vector<const RuntimeMemory*>& memories, MeasureTiming measure,
955             const std::vector<TokenValuePair>& metaData) const override;
962     CpuPreparedModel(Model model, std::vector<RunTimePoolInfo> poolInfos)  in CpuPreparedModel()
963         : mModel(std::move(model)), mModelPoolInfos(std::move(poolInfos)) {}  in CpuPreparedModel()
966     const std::vector<RunTimePoolInfo>& getModelPoolInfos() const { return mModelPoolInfos; }  in getModelPoolInfos()
974     const std::vector<RunTimePoolInfo> mModelPoolInfos;
980                  std::vector<RunTimePoolInfo> requestPoolInfos,  in CpuExecution()
983           kRequest(std::move(request)),  in CpuExecution()
984           kRequestPoolInfos(std::move(requestPoolInfos)),  in CpuExecution()
985           kLoopTimeoutDuration(std::move(loopTimeoutDuration)) {}  in CpuExecution()
987     std::tuple<int, std::vector<OutputShape>, Timing> compute(
990     std::tuple<int, int, ExecuteFencedInfoCallback, Timing> computeFenced(
991             const std::vector<int>& waitFor, const OptionalTimePoint& deadline,
997     std::vector<RunTimePoolInfo> kRequestPoolInfos;
1001 std::vector<bool> CpuDevice::getSupportedOperations(const MetaModel& metaModel) const {  in getSupportedOperations()
1004     std::vector<bool> result(count, false);  in getSupportedOperations()
1026 std::pair<int, std::shared_ptr<RuntimePreparedModel>> CpuDevice::prepareModel(  in prepareModel()
1029         const std::optional<CacheToken>& maybeToken,  in prepareModel()
1030         const std::vector<TokenValuePair>& /*metaData*/,  in prepareModel()
1031         const std::vector<ExtensionNameAndPrefix>& /*extensionNameAndPrefix*/) const {  in prepareModel()
1055 std::pair<int, std::unique_ptr<RuntimeMemory>> CpuDevice::allocate(const MemoryDescriptor& desc,  in allocate()
1065 std::pair<int, std::shared_ptr<RuntimePreparedModel>> CpuPreparedModel::create(Model model) {  in create()
1066     std::vector<RunTimePoolInfo> poolInfos;  in create()
1071     std::shared_ptr<RuntimePreparedModel> preparedModel =  in create()
1072             std::make_shared<CpuPreparedModel>(std::move(model), std::move(poolInfos));  in create()
1073     return {ANEURALNETWORKS_NO_ERROR, std::move(preparedModel)};  in create()
1076 static std::tuple<int, std::vector<OutputShape>, Timing> computeOnCpu(  in computeOnCpu()
1078         const std::vector<RunTimePoolInfo>& modelPoolInfos,  in computeOnCpu()
1079         const std::vector<RunTimePoolInfo>& requestPoolInfos, const OptionalTimePoint& deadline,  in computeOnCpu()
1094 std::tuple<int, int, ExecuteFencedInfoCallback, Timing> CpuPreparedModel::executeFenced(  in executeFenced()
1095         const std::vector<ModelArgumentInfo>& inputs, const std::vector<ModelArgumentInfo>& outputs,  in executeFenced()
1096         const std::vector<const RuntimeMemory*>& memories, const std::vector<int>& waitFor,  in executeFenced()
1099         const std::vector<TokenValuePair>& /*metaData*/) const {  in executeFenced()
1126 static std::tuple<int, Request, std::vector<RunTimePoolInfo>> createCpuRequest(  in createCpuRequest()
1127         const std::vector<ModelArgumentInfo>& inputs, const std::vector<ModelArgumentInfo>& outputs,  in createCpuRequest()
1128         const std::vector<const RuntimeMemory*>& memories) {  in createCpuRequest()
1129     std::vector<RunTimePoolInfo> requestPoolInfos;  in createCpuRequest()
1132         if (std::optional<RunTimePoolInfo> poolInfo = mem->getRunTimePoolInfo()) {  in createCpuRequest()
1140             [&requestPoolInfos](const std::vector<ModelArgumentInfo>& argumentInfos) {  in createCpuRequest()
1141                 std::vector<DataLocation> ptrArgsLocations;  in createCpuRequest()
1155     const std::vector<DataLocation> inputPtrArgsLocations = fixPointerArguments(inputs);  in createCpuRequest()
1156     const std::vector<DataLocation> outputPtrArgsLocations = fixPointerArguments(outputs);  in createCpuRequest()
1161     return {ANEURALNETWORKS_NO_ERROR, std::move(request), std::move(requestPoolInfos)};  in createCpuRequest()
1171 std::tuple<int, std::vector<OutputShape>, Timing> CpuPreparedModel::execute(  in execute()
1172         const std::vector<ModelArgumentInfo>& inputs, const std::vector<ModelArgumentInfo>& outputs,  in execute()
1173         const std::vector<const RuntimeMemory*>& memories, const SharedBurst& /*burstController*/,  in execute()
1176         const std::vector<TokenValuePair>& /*metaData*/) const {  in execute()
1183     std::vector<RunTimePoolInfo> requestPoolInfos;  in execute()
1184     std::tie(nCreateRequest, request, requestPoolInfos) =  in execute()
1194         std::tuple<int, std::vector<OutputShape>, Timing> result = {};  in execute()
1195         std::thread([this, &request, &requestPoolInfos, &deadline, &loopTimeoutDuration, &result] {  in execute()
1206 std::pair<int, std::shared_ptr<RuntimeExecution>> CpuPreparedModel::createReusableExecution(  in createReusableExecution()
1207         const std::vector<ModelArgumentInfo>& inputs, const std::vector<ModelArgumentInfo>& outputs,  in createReusableExecution()
1208         const std::vector<const RuntimeMemory*>& memories, MeasureTiming /*measure*/,  in createReusableExecution()
1210         const std::vector<TokenValuePair>& /*metaData*/) const {  in createReusableExecution()
1215     auto execution = std::make_shared<CpuExecution>(  in createReusableExecution()
1216             *this, std::move(request), std::move(requestPoolInfos), loopTimeoutDuration);  in createReusableExecution()
1217     return {ANEURALNETWORKS_NO_ERROR, std::move(execution)};  in createReusableExecution()
1220 std::tuple<int, std::vector<OutputShape>, Timing> CpuExecution::compute(  in compute()
1230         std::tuple<int, std::vector<OutputShape>, Timing> result = {};  in compute()
1231         std::thread([this, &deadline, &result] {  in compute()
1243 std::tuple<int, int, ExecuteFencedInfoCallback, Timing> CpuExecution::computeFenced(  in computeFenced()
1244         const std::vector<int>& waitFor, const OptionalTimePoint& deadline,  in computeFenced()
1280 std::shared_ptr<Device> DeviceManager::getCpuDevice() {  in getCpuDevice()
1284 std::shared_ptr<Device> DeviceManager::forTest_makeDriverDevice(const SharedDevice& device) {  in forTest_makeDriverDevice()
1292 std::vector<std::shared_ptr<DriverDevice>> getDriverDevices(  in getDriverDevices()
1297     std::vector<std::shared_ptr<DriverDevice>> driverDevices;  in getDriverDevices()
1300         driverDevices.push_back(DriverDevice::create(std::move(device)));  in getDriverDevices()
1308 std::vector<std::shared_ptr<DriverDevice>> getDriverDevices(  in getDriverDevices()
1311     std::vector<std::shared_ptr<DriverDevice>> driverDevices;  in getDriverDevices()
1314         driverDevices.push_back(DriverDevice::create(std::move(device)));  in getDriverDevices()
1328     std::string patternStr = base::GetProperty("debug.nn.enabled-devices", ".*");  in findAvailableDevices()
1330     const std::regex pattern(patternStr);  in findAvailableDevices()
1337         if (!std::regex_match(driverDevice->getName(), pattern)) {  in findAvailableDevices()
1345         mDevices.push_back(std::move(driverDevice));  in findAvailableDevices()
1357         mDevices.push_back(std::move(driverDevice));  in registerDevice()