Implement SamplePreparedModel::executeFenced

 - The execution is done synchronously, and empty hidl_handle will be
 returned.

Bug: 148979873
Test: mm
Test: VtsHalNeuralnetworksV1_3TargetTest
Change-Id: I410c9cc1ca9c644385abcba7c9285666c77a76ab
Merged-In: I410c9cc1ca9c644385abcba7c9285666c77a76ab
(cherry picked from commit 34141e48d2c134c96afc3f2bf184637ea6e93872)

3 files changed, 94 insertions, 5 deletions

diff --git a/nn/driver/sample/Android.bp b/nn/driver/sample/Android.bp
index c03ecc680..cec4d6596 100644
--- a/nn/driver/sample/Android.bp
+++ b/nn/driver/sample/Android.bp
@@ -44,6 +44,7 @@ cc_defaults {
         "libhidlmemory",
         "liblog",
         "libnativewindow",
+        "libsync",
         "libtextclassifier_hash",
         "libutils",
     ],
diff --git a/nn/driver/sample/SampleDriver.cpp b/nn/driver/sample/SampleDriver.cpp
index a438c321b..3388207ff 100644
--- a/nn/driver/sample/SampleDriver.cpp
+++ b/nn/driver/sample/SampleDriver.cpp
@@ -20,6 +20,7 @@
 
 #include <android-base/logging.h>
 #include <android-base/properties.h>
+#include <android/sync.h>
 #include <hidl/LegacySupport.h>
 
 #include <algorithm>
@@ -407,14 +408,83 @@ Return<void> SamplePreparedModel::executeSynchronously_1_3(const V1_3::Request&
     return Void();
 }
 
-Return<void> SamplePreparedModel::executeFenced(const hal::Request&, const hidl_vec<hidl_handle>&,
-                                                MeasureTiming, const OptionalTimePoint&,
-                                                const OptionalTimeoutDuration&,
+// The sample driver will finish the execution and then return.
+Return<void> SamplePreparedModel::executeFenced(const hal::Request& request,
+                                                const hidl_vec<hidl_handle>& waitFor,
+                                                MeasureTiming measure,
+                                                const OptionalTimePoint& deadline,
+                                                const OptionalTimeoutDuration& duration,
                                                 executeFenced_cb cb) {
-    // TODO(miaowang): implement me.
-    cb(ErrorStatus::DEVICE_UNAVAILABLE, hidl_handle(nullptr), nullptr);
+    NNTRACE_FULL(NNTRACE_LAYER_DRIVER, NNTRACE_PHASE_EXECUTION,
+                 "SamplePreparedModel::executeFenced");
+    VLOG(DRIVER) << "executeFenced(" << SHOW_IF_DEBUG(toString(request)) << ")";
+
+    time_point driverStart, driverEnd, deviceStart, deviceEnd;
+    if (measure == MeasureTiming::YES) driverStart = now();
+
+    if (duration.getDiscriminator() != OptionalTimeoutDuration::hidl_discriminator::none ||
+        deadline.getDiscriminator() != OptionalTimePoint::hidl_discriminator::none ||
+        !validateRequest(request, mModel)) {
+        cb(ErrorStatus::INVALID_ARGUMENT, hidl_handle(nullptr), nullptr);
+        return Void();
+    }
+
+    // Wait for the dependent events to signal
+    for (const auto& fenceHandle : waitFor) {
+        if (!fenceHandle.getNativeHandle()) {
+            cb(ErrorStatus::INVALID_ARGUMENT, hidl_handle(nullptr), nullptr);
+            return Void();
+        }
+        int syncFenceFd = fenceHandle.getNativeHandle()->data[0];
+        if (sync_wait(syncFenceFd, -1) < 0) {
+            LOG(ERROR) << "sync_wait failed";
+            cb(ErrorStatus::GENERAL_FAILURE, hidl_handle(nullptr), nullptr);
+            return Void();
+        }
+    }
+
+    time_point driverStartAfterFence;
+    if (measure == MeasureTiming::YES) driverStartAfterFence = now();
+
+    NNTRACE_FULL_SWITCH(NNTRACE_LAYER_DRIVER, NNTRACE_PHASE_INPUTS_AND_OUTPUTS,
+                        "SamplePreparedModel::executeFenced");
+    std::vector<RunTimePoolInfo> requestPoolInfos;
+    if (!setRunTimePoolInfosFromMemoryPools(&requestPoolInfos, request.pools)) {
+        cb(ErrorStatus::INVALID_ARGUMENT, hidl_handle(nullptr), nullptr);
+        return Void();
+    }
+
+    NNTRACE_FULL_SWITCH(NNTRACE_LAYER_DRIVER, NNTRACE_PHASE_EXECUTION,
+                        "SamplePreparedModel::executeFenced");
+    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);
+    if (executionStatus != ErrorStatus::NONE) {
+        cb(executionStatus, hidl_handle(nullptr), nullptr);
+        return Void();
+    }
+    Timing timingSinceLaunch = {.timeOnDevice = UINT64_MAX, .timeInDriver = UINT64_MAX};
+    Timing timingAfterFence = {.timeOnDevice = UINT64_MAX, .timeInDriver = UINT64_MAX};
+    if (measure == MeasureTiming::YES) {
+        driverEnd = now();
+        timingSinceLaunch = {
+                .timeOnDevice = uint64_t(microsecondsDuration(deviceEnd, deviceStart)),
+                .timeInDriver = uint64_t(microsecondsDuration(driverEnd, driverStart))};
+        timingAfterFence = {
+                .timeOnDevice = uint64_t(microsecondsDuration(deviceEnd, deviceStart)),
+                .timeInDriver = uint64_t(microsecondsDuration(driverEnd, driverStartAfterFence))};
+        VLOG(DRIVER) << "executeFenced timingSinceLaunch = " << toString(timingSinceLaunch);
+        VLOG(DRIVER) << "executeFenced timingAfterFence = " << toString(timingAfterFence);
+    }
+    sp<SampleFencedExecutionCallback> fencedExecutionCallback =
+            new SampleFencedExecutionCallback(timingSinceLaunch, timingAfterFence, executionStatus);
+    cb(executionStatus, hidl_handle(nullptr), fencedExecutionCallback);
     return Void();
 }
+
 // BurstExecutorWithCache maps hidl_memory when it is first seen, and preserves
 // the mapping until either (1) the memory is freed in the runtime, or (2) the
 // burst object is destroyed. This allows for subsequent executions operating on
diff --git a/nn/driver/sample/SampleDriver.h b/nn/driver/sample/SampleDriver.h
index d67735515..2b5068131 100644
--- a/nn/driver/sample/SampleDriver.h
+++ b/nn/driver/sample/SampleDriver.h
@@ -153,6 +153,24 @@ class SamplePreparedModel : public hal::IPreparedModel {
     const hal::Priority kPriority;
 };
 
+class SampleFencedExecutionCallback : public hal::IFencedExecutionCallback {
+   public:
+    SampleFencedExecutionCallback(hal::Timing timingSinceLaunch, hal::Timing timingAfterFence,
+                                  hal::ErrorStatus error)
+        : kTimingSinceLaunch(timingSinceLaunch),
+          kTimingAfterFence(timingAfterFence),
+          kErrorStatus(error) {}
+    hal::Return<void> getExecutionInfo(getExecutionInfo_cb callback) override {
+        callback(kErrorStatus, kTimingSinceLaunch, kTimingAfterFence);
+        return hal::Void();
+    }
+
+   private:
+    const hal::Timing kTimingSinceLaunch;
+    const hal::Timing kTimingAfterFence;
+    const hal::ErrorStatus kErrorStatus;
+};
+
 }  // namespace sample_driver
 }  // namespace nn
 }  // namespace android