1 files changed, 61 insertions, 1 deletions
diff --git a/ArmnnPreparedModel.hpp b/ArmnnPreparedModel.hpp
index 89f6226f..d1c830d4 100644
--- a/ArmnnPreparedModel.hpp
+++ b/ArmnnPreparedModel.hpp
@@ -38,7 +38,8 @@ public:
                        armnn::IRuntime* runtime,
                        const HalModel& model,
                        const std::string& requestInputsAndOutputsDumpDir,
-                       const bool gpuProfilingEnabled);
+                       const bool gpuProfilingEnabled,
+                       const bool asyncModelExecutionEnabled = false);
 
     virtual ~ArmnnPreparedModel();
 
@@ -56,9 +57,65 @@ public:
     bool ExecuteWithDummyInputs();
 
 private:
+
+    template<typename CallbackContext>
+    class ArmnnThreadPoolCallback : public armnn::IAsyncExecutionCallback
+    {
+    public:
+        ArmnnThreadPoolCallback(ArmnnPreparedModel<HalVersion>* model,
+                                std::shared_ptr<std::vector<::android::nn::RunTimePoolInfo>>& pMemPools,
+                                std::shared_ptr<armnn::InputTensors>& inputTensors,
+                                std::shared_ptr<armnn::OutputTensors>& outputTensors,
+                                CallbackContext callbackContext) :
+                m_Model(model),
+                m_MemPools(pMemPools),
+                m_InputTensors(inputTensors),
+                m_OutputTensors(outputTensors),
+                m_CallbackContext(callbackContext)
+        {}
+
+        void Notify(armnn::Status status, armnn::InferenceTimingPair timeTaken) override;
+
+        // Retrieve the ArmNN Status from the AsyncExecutionCallback that has been notified
+        virtual armnn::Status GetStatus() const override
+        {
+            return armnn::Status::Success;
+        }
+
+        // Block the calling thread until the AsyncExecutionCallback object allows it to proceed
+        virtual void Wait() const override
+        {}
+
+        // Retrieve the start time before executing the inference
+        virtual armnn::HighResolutionClock GetStartTime() const override
+        {
+            return std::chrono::high_resolution_clock::now();
+        }
+
+        // Retrieve the time after executing the inference
+        virtual armnn::HighResolutionClock GetEndTime() const override
+        {
+            return std::chrono::high_resolution_clock::now();
+        }
+
+        ArmnnPreparedModel<HalVersion>* m_Model;
+        std::shared_ptr<std::vector<::android::nn::RunTimePoolInfo>> m_MemPools;
+        std::shared_ptr<armnn::InputTensors> m_InputTensors;
+        std::shared_ptr<armnn::OutputTensors> m_OutputTensors;
+        CallbackContext m_CallbackContext;
+    };
+
     template <typename TensorBindingCollection>
     void DumpTensorsIfRequired(char const* tensorNamePrefix, const TensorBindingCollection& tensorBindings);
 
+    /// schedule the graph prepared from the request for execution
+    template<typename CallbackContext>
+    void ScheduleGraphForExecution(
+            std::shared_ptr<std::vector<::android::nn::RunTimePoolInfo>>& pMemPools,
+            std::shared_ptr<armnn::InputTensors>& inputTensors,
+            std::shared_ptr<armnn::OutputTensors>& outputTensors,
+            CallbackContext m_CallbackContext);
+
     armnn::NetworkId                                                        m_NetworkId;
     armnn::IRuntime*                                                        m_Runtime;
     HalModel                                                                m_Model;
@@ -68,6 +125,9 @@ private:
     uint32_t                                                                m_RequestCount;
     const std::string&                                                      m_RequestInputsAndOutputsDumpDir;
     const bool                                                              m_GpuProfilingEnabled;
+
+    std::unique_ptr<armnn::IWorkingMemHandle> m_WorkingMemHandle;
+    const bool m_AsyncModelExecutionEnabled;
 };
 
 }