Release 18.02

Change-Id: Id3c11dc5ee94ef664374a988fcc6901e9a232fa6

1 files changed, 116 insertions, 0 deletions

diff --git a/include/armnn/IRuntime.hpp b/include/armnn/IRuntime.hpp
new file mode 100644
index 0000000000..a1a3f0fda9
--- /dev/null
+++ b/include/armnn/IRuntime.hpp
@@ -0,0 +1,116 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// See LICENSE file in the project root for full license information.
+//
+#pragma once
+
+#include <memory>
+
+#include "Types.hpp"
+#include "Tensor.hpp"
+#include "INetwork.hpp"
+#include "TypesUtils.hpp"
+
+namespace armnn
+{
+
+using NetworkId = int;
+
+class IClTunedParameters;
+
+class IRuntime;
+using IRuntimePtr = std::unique_ptr<IRuntime, void(*)(IRuntime* runtime)>;
+
+class IRuntime
+{
+public:
+    struct CreationOptions
+    {
+        Compute m_DefaultComputeDevice;
+        bool m_UseCpuRefAsFallback;
+        /// If set, uses the CL tuned parameters from the given object when executing CL workloads.
+        /// It will also be updated with new tuned parameters if it is configured to do so.
+        IClTunedParameters* m_ClTunedParameters;
+
+        CreationOptions(Compute defaultComputeDevice)
+            : m_DefaultComputeDevice(defaultComputeDevice)
+            , m_UseCpuRefAsFallback(true)
+            , m_ClTunedParameters(nullptr)
+        {
+        }
+    };
+
+    static IRuntime* CreateRaw(const CreationOptions& options);
+    static IRuntimePtr Create(const CreationOptions& options);
+    static void Destroy(IRuntime* runtime);
+
+    /// Load a complete network into the IRuntime.
+    /// @param [out] networkIdOut Unique identifier for the network is returned in this reference.
+    /// @param [in] network Complete network to load into the IRuntime.
+    /// The runtime takes ownership of the network once passed in.
+    /// @return armnn::Status
+    virtual Status LoadNetwork(NetworkId& networkIdOut, IOptimizedNetworkPtr network) = 0;
+
+    virtual TensorInfo GetInputTensorInfo(NetworkId networkId, LayerBindingId layerId) const = 0;
+    virtual TensorInfo GetOutputTensorInfo(NetworkId networkId, LayerBindingId layerId) const = 0;
+
+    // Evaluate network using input in inputTensors, outputs filled into outputTensors
+    virtual Status EnqueueWorkload(NetworkId networkId,
+                           const InputTensors& inputTensors,
+                           const OutputTensors& outputTensors) = 0;
+
+    /// Unload a network from the IRuntime.
+    /// At the moment this only removes the network from the m_Impl->m_Network.
+    /// This might need more work in the future to be AndroidNN compliant.
+    /// @param [in] networkId Unique identifier for the network to be unloaded. Generated in LoadNetwork().
+    /// @return armnn::Status
+    virtual Status UnloadNetwork(NetworkId networkId) = 0;
+
+    virtual const DeviceSpec& GetDeviceSpec() const = 0;
+
+protected:
+    ~IRuntime() {}
+};
+
+using IClTunedParametersPtr = std::unique_ptr<IClTunedParameters, void(*)(IClTunedParameters* params)>;
+
+/// Manages a set of Open CL parameters which have been tuned for maximum performance.
+/// Pass an instance of this object to the IRuntime::Create() method (via IRuntime::CreationOptions) to use it
+/// for all CL workload execution.
+///
+/// Can be created in two modes:
+///     - In UseTunedParameters mode the parameters stored in this object are used to execute CL workloads.
+///     - In UpdateTunedParameters mode, additionally, whenever a CL workload is executed for the first time the
+///       optimum parameters will be found and stored in this object. WARNING - This tuning can be slow.
+///
+/// The parameters can be loaded from and saved to a file so that you first run a slow initial read-write
+/// execution, save the parameters for later and then run fast read-only executions using the optimised parameters.
+class IClTunedParameters
+{
+public:
+    enum class Mode
+    {
+        UseTunedParameters,
+        UpdateTunedParameters
+    };
+
+    /// Creates an IClTunedParameters with the given mode.
+    /// @{
+    static IClTunedParameters* CreateRaw(Mode mode);
+    static IClTunedParametersPtr Create(Mode mode);
+    /// @}
+    static void Destroy(IClTunedParameters* params);
+
+    /// Loads an existing set of tuned parameters from the given file.
+    /// If there is an error loading the file, an armnn::Exception is thrown.
+    virtual void Load(const char* filename) = 0;
+
+    /// Saves the current set of tuned parameters to the given file.
+    /// If there is an error saving to the file, an armnn::Exception is thrown.
+    virtual void Save(const char* filename) const = 0;
+
+protected:
+    virtual ~IClTunedParameters() {};
+};
+
+}