COMPMID-1023: Import memory for OpenCL

Change-Id: I201bc00a1261814737e6b6878ecfe9904bae0cc1
Reviewed-on: https://eu-gerrit-1.euhpc.arm.com/128212
Tested-by: Jenkins <bsgcomp@arm.com>
Reviewed-by: Anthony Barbier <anthony.barbier@arm.com>

11 files changed, 448 insertions, 56 deletions

diff --git a/arm_compute/runtime/Allocator.h b/arm_compute/runtime/Allocator.h
index cf6f07b211..963c2d8eef 100644
--- a/arm_compute/runtime/Allocator.h
+++ b/arm_compute/runtime/Allocator.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 ARM Limited.
+ * Copyright (c) 2017-2018 ARM Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -26,12 +26,14 @@
 
 #include "arm_compute/runtime/IAllocator.h"
 
+#include "arm_compute/runtime/IMemoryRegion.h"
+
 #include <cstddef>
 
 namespace arm_compute
 {
 /** Default malloc allocator implementation */
-class Allocator : public IAllocator
+class Allocator final : public IAllocator
 {
 public:
     /** Default constructor */
@@ -40,6 +42,7 @@ public:
     // Inherited methods overridden:
     void *allocate(size_t size, size_t alignment) override;
     void free(void *ptr) override;
+    std::unique_ptr<IMemoryRegion> make_region(size_t size, size_t alignment) override;
 };
 } // arm_compute
 #endif /*__ARM_COMPUTE_ALLOCATOR_H__ */
diff --git a/arm_compute/runtime/CL/CLBufferAllocator.h b/arm_compute/runtime/CL/CLBufferAllocator.h
index 05b0363dc3..19a3e627ca 100644
--- a/arm_compute/runtime/CL/CLBufferAllocator.h
+++ b/arm_compute/runtime/CL/CLBufferAllocator.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 ARM Limited.
+ * Copyright (c) 2017-2018 ARM Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -34,7 +34,7 @@
 namespace arm_compute
 {
 /** Default OpenCL cl buffer allocator implementation */
-class CLBufferAllocator : public IAllocator
+class CLBufferAllocator final : public IAllocator
 {
 public:
     /** Default constructor */
@@ -43,6 +43,7 @@ public:
     // Inherited methods overridden:
     void *allocate(size_t size, size_t alignment) override;
     void free(void *ptr) override;
+    std::unique_ptr<IMemoryRegion> make_region(size_t size, size_t alignment) override;
 
 private:
     cl::Context _context;
diff --git a/arm_compute/runtime/CL/CLMemory.h b/arm_compute/runtime/CL/CLMemory.h
new file mode 100644
index 0000000000..edd9de8097
--- /dev/null
+++ b/arm_compute/runtime/CL/CLMemory.h
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_RUNTIME_CL_CLMEMORY_H__
+#define __ARM_COMPUTE_RUNTIME_CL_CLMEMORY_H__
+
+#include "arm_compute/core/CL/OpenCL.h"
+#include "arm_compute/runtime/CL/CLMemoryRegion.h"
+
+#include <cstddef>
+#include <memory>
+
+namespace arm_compute
+{
+/** OpenCL implementation of memory object */
+class CLMemory
+{
+public:
+    /** Default Constructor */
+    CLMemory();
+    /** Default Constructor
+     *
+     * @param[in] memory Memory to be imported
+     */
+    CLMemory(std::shared_ptr<ICLMemoryRegion> memory);
+    /** Default Constructor
+     *
+     * @note Ownership of the memory is not transferred to this object.
+     *       Thus management (allocate/free) should be done by the client.
+     *
+     * @param[in] memory Memory to be imported
+     */
+    CLMemory(ICLMemoryRegion *memory);
+    /** Allow instances of this class to be copied */
+    CLMemory(const CLMemory &) = default;
+    /** Allow instances of this class to be copy assigned */
+    CLMemory &operator=(const CLMemory &) = default;
+    /** Allow instances of this class to be moved */
+    CLMemory(CLMemory &&) noexcept = default;
+    /** Allow instances of this class to be move assigned */
+    CLMemory &operator=(CLMemory &&) noexcept = default;
+    /** Region accessor
+     *
+     * @return Memory region
+     */
+    ICLMemoryRegion *region();
+    /** Region accessor
+     *
+     * @return Memory region
+     */
+    ICLMemoryRegion *region() const;
+
+private:
+    /** Creates empty region */
+    void create_empty_region();
+
+private:
+    ICLMemoryRegion                 *_region;
+    std::shared_ptr<ICLMemoryRegion> _region_owned;
+};
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_RUNTIME_CL_CLMEMORY_H__ */
diff --git a/arm_compute/runtime/CL/CLMemoryRegion.h b/arm_compute/runtime/CL/CLMemoryRegion.h
new file mode 100644
index 0000000000..01dd54e391
--- /dev/null
+++ b/arm_compute/runtime/CL/CLMemoryRegion.h
@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_RUNTIME_CL_CL_MEMORY_REGION_H__
+#define __ARM_COMPUTE_RUNTIME_CL_CL_MEMORY_REGION_H__
+
+#include "arm_compute/core/CL/OpenCL.h"
+#include "arm_compute/runtime/IMemoryRegion.h"
+
+#include <cstddef>
+
+namespace arm_compute
+{
+/** OpenCL memory region interface */
+class ICLMemoryRegion : public IMemoryRegion
+{
+public:
+    /** Constructor
+     *
+     * @param[in] ctx  OpenCL context
+     * @param[in] size Region size
+     */
+    ICLMemoryRegion(cl::Context ctx, size_t size);
+    /** Default Destructor */
+    virtual ~ICLMemoryRegion() = default;
+    /** Prevent instances of this class from being copied (As this class contains pointers) */
+    ICLMemoryRegion(const ICLMemoryRegion &) = delete;
+    /** Default move constructor */
+    ICLMemoryRegion(ICLMemoryRegion &&) = default;
+    /** Prevent instances of this class from being copied (As this class contains pointers) */
+    ICLMemoryRegion &operator=(const ICLMemoryRegion &) = delete;
+    /** Default move assignment operator */
+    ICLMemoryRegion &operator=(ICLMemoryRegion &&) = default;
+    /** Returns the underlying CL buffer
+     *
+     * @return CL memory buffer object
+     */
+    const cl::Buffer &cl_data() const;
+    /** Host/SVM pointer accessor
+     *
+     * @return Host/SVM pointer base
+     */
+    virtual void *ptr() = 0;
+    /** Enqueue a map operation of the allocated buffer on the given queue.
+     *
+     * @param[in,out] q        The CL command queue to use for the mapping operation.
+     * @param[in]     blocking If true, then the mapping will be ready to use by the time
+     *                         this method returns, else it is the caller's responsibility
+     *                         to flush the queue and wait for the mapping operation to have completed before using the returned mapping pointer.
+     *
+     * @return The mapping address.
+     */
+    virtual void *map(cl::CommandQueue &q, bool blocking) = 0;
+    /** Enqueue an unmap operation of the allocated buffer on the given queue.
+     *
+     * @note This method simply enqueue the unmap operation, it is the caller's responsibility to flush the queue and make sure the unmap is finished before
+     *       the memory is accessed by the device.
+     *
+     * @param[in,out] q The CL command queue to use for the mapping operation.
+     */
+    virtual void unmap(cl::CommandQueue &q) = 0;
+
+    // Inherited methods overridden :
+    void *buffer() override;
+    void *buffer() const override;
+    void **handle() override;
+
+protected:
+    cl::Context _ctx;
+    void       *_mapping;
+    cl::Buffer  _mem;
+};
+
+/** OpenCL buffer memory region implementation */
+class CLBufferMemoryRegion final : public ICLMemoryRegion
+{
+public:
+    /** Constructor
+     *
+     * @param[in] ctx   OpenCL context
+     * @param[in] flags Memory flags
+     * @param[in] size  Region size
+     */
+    CLBufferMemoryRegion(cl::Context ctx, cl_mem_flags flags, size_t size);
+
+    // Inherited methods overridden :
+    void *ptr() override;
+    void *map(cl::CommandQueue &q, bool blocking) override;
+    void unmap(cl::CommandQueue &q) override;
+};
+
+/** OpenCL SVM memory region interface */
+class ICLSVMMemoryRegion : public ICLMemoryRegion
+{
+protected:
+    /** Constructor
+     *
+     * @param[in] ctx       OpenCL context
+     * @param[in] flags     Memory flags
+     * @param[in] size      Region size
+     * @param[in] alignment Alignment
+     */
+    ICLSVMMemoryRegion(cl::Context ctx, cl_mem_flags flags, size_t size, size_t alignment);
+    /** Destructor */
+    virtual ~ICLSVMMemoryRegion();
+    /** Prevent instances of this class from being copied (As this class contains pointers) */
+    ICLSVMMemoryRegion(const ICLSVMMemoryRegion &) = delete;
+    /** Default move constructor */
+    ICLSVMMemoryRegion(ICLSVMMemoryRegion &&) = default;
+    /** Prevent instances of this class from being copied (As this class contains pointers) */
+    ICLSVMMemoryRegion &operator=(const ICLSVMMemoryRegion &) = delete;
+    /** Default move assignment operator */
+    ICLSVMMemoryRegion &operator=(ICLSVMMemoryRegion &&) = default;
+
+    // Inherited methods overridden :
+    void *ptr() override;
+
+protected:
+    void *_ptr;
+};
+
+/** OpenCL coarse-grain SVM memory region implementation */
+class CLCoarseSVMMemoryRegion final : public ICLSVMMemoryRegion
+{
+public:
+    /** Constructor
+     *
+     * @param[in] ctx       OpenCL context
+     * @param[in] flags     Memory flags
+     * @param[in] size      Region size
+     * @param[in] alignment Alignment
+     */
+    CLCoarseSVMMemoryRegion(cl::Context ctx, cl_mem_flags flags, size_t size, size_t alignment);
+
+    // Inherited methods overridden :
+    void *map(cl::CommandQueue &q, bool blocking) override;
+    void unmap(cl::CommandQueue &q) override;
+};
+
+/** OpenCL fine-grain SVM memory region implementation */
+class CLFineSVMMemoryRegion final : public ICLSVMMemoryRegion
+{
+public:
+    /** Constructor
+     *
+     * @param[in] ctx       OpenCL context
+     * @param[in] flags     Memory flags
+     * @param[in] size      Region size
+     * @param[in] alignment Alignment
+     */
+    CLFineSVMMemoryRegion(cl::Context ctx, cl_mem_flags flags, size_t size, size_t alignment);
+
+    // Inherited methods overridden :
+    void *map(cl::CommandQueue &q, bool blocking) override;
+    void unmap(cl::CommandQueue &q) override;
+};
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_RUNTIME_CL_CL_MEMORY_REGION_H__ */
diff --git a/arm_compute/runtime/CL/CLTensor.h b/arm_compute/runtime/CL/CLTensor.h
index e05f307621..c47d2be1b0 100644
--- a/arm_compute/runtime/CL/CLTensor.h
+++ b/arm_compute/runtime/CL/CLTensor.h
@@ -45,7 +45,7 @@ public:
      *
      * @return A pointer to the tensor's allocator
      */
-    ITensorAllocator *allocator();
+    CLTensorAllocator *allocator();
     /** Enqueue a map operation of the allocated buffer.
      *
      * @param[in] blocking If true, then the mapping will be ready to use by the time
diff --git a/arm_compute/runtime/CL/CLTensorAllocator.h b/arm_compute/runtime/CL/CLTensorAllocator.h
index 6929d551fb..a372195555 100644
--- a/arm_compute/runtime/CL/CLTensorAllocator.h
+++ b/arm_compute/runtime/CL/CLTensorAllocator.h
@@ -24,10 +24,11 @@
 #ifndef __ARM_COMPUTE_CLTENSORALLOCATOR_H__
 #define __ARM_COMPUTE_CLTENSORALLOCATOR_H__
 
+#include "arm_compute/runtime/CL/CLMemory.h"
 #include "arm_compute/runtime/ITensorAllocator.h"
 
 #include "arm_compute/core/CL/OpenCL.h"
-#include "arm_compute/runtime/CL/SVMMemory.h"
+
 #include <cstdint>
 
 namespace arm_compute
@@ -47,8 +48,6 @@ public:
      * @param[in] owner (Optional) Owner of the allocator.
      */
     CLTensorAllocator(CLTensor *owner = nullptr);
-    /** Default destructor */
-    ~CLTensorAllocator();
     /** Prevent instances of this class from being copied (As this class contains pointers) */
     CLTensorAllocator(const CLTensorAllocator &) = delete;
     /** Prevent instances of this class from being copy assigned (As this class contains pointers) */
@@ -68,8 +67,6 @@ public:
      * @return pointer to the CL data.
      */
     const cl::Buffer &cl_data() const;
-    /** SVM memory */
-    void *svm_ptr();
 
     /** Enqueue a map operation of the allocated buffer on the given queue.
      *
@@ -104,6 +101,19 @@ public:
      *
      */
     void free() override;
+    /** Import an existing memory as a tensor's backing memory
+     *
+     * @warning If the tensor is flagged to be managed by a memory manager,
+     *          this call will lead to an error.
+     * @warning Ownership of memory depends on the way the @ref CLMemory object was constructed
+     * @note    Calling free on a tensor with imported memory will just clear
+     *          the internal pointer value.
+     *
+     * @param[in] memory Memory to import
+     *
+     * @return error status
+     */
+    arm_compute::Status import_memory(CLMemory memory);
     /** Associates the tensor with a memory group
      *
      * @param[in] associated_memory_group Memory group to associate the tensor with
@@ -121,10 +131,8 @@ protected:
 
 private:
     CLMemoryGroup *_associated_memory_group; /**< Registered memory manager */
-    cl::Buffer     _buffer;                  /**< OpenCL buffer containing the tensor data. */
-    uint8_t       *_mapping;                 /**< Pointer to the CPU mapping of the OpenCL buffer. */
+    CLMemory       _memory;                  /**< OpenCL memory */
     CLTensor      *_owner;                   /**< Owner of the allocator */
-    SVMMemory      _svm_memory;              /**< Svm memory */
 };
-}
+} // namespace arm_compute
 #endif /* __ARM_COMPUTE_CLTENSORALLOCATOR_H__ */
diff --git a/arm_compute/runtime/GLES_COMPUTE/GCBufferAllocator.h b/arm_compute/runtime/GLES_COMPUTE/GCBufferAllocator.h
index 8fa13e59a6..674297a63c 100644
--- a/arm_compute/runtime/GLES_COMPUTE/GCBufferAllocator.h
+++ b/arm_compute/runtime/GLES_COMPUTE/GCBufferAllocator.h
@@ -34,7 +34,7 @@
 namespace arm_compute
 {
 /** Default GLES buffer allocator implementation */
-class GCBufferAllocator : public IAllocator
+class GCBufferAllocator final : public IAllocator
 {
 public:
     /** Default constructor */
@@ -43,6 +43,7 @@ public:
     // Inherited methods overridden:
     void *allocate(size_t size, size_t alignment) override;
     void free(void *ptr) override;
+    std::unique_ptr<IMemoryRegion> make_region(size_t size, size_t alignment) override;
 };
 } // namespace arm_compute
 #endif /*__ARM_COMPUTE_GCBUFFERALLOCATOR_H__ */
diff --git a/arm_compute/runtime/IAllocator.h b/arm_compute/runtime/IAllocator.h
index 3edb34a9ea..591ae0bff4 100644
--- a/arm_compute/runtime/IAllocator.h
+++ b/arm_compute/runtime/IAllocator.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 ARM Limited.
+ * Copyright (c) 2017-2018 ARM Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -24,7 +24,10 @@
 #ifndef __ARM_COMPUTE_IALLOCATOR_H__
 #define __ARM_COMPUTE_IALLOCATOR_H__
 
+#include "arm_compute/runtime/IMemoryRegion.h"
+
 #include <cstddef>
+#include <memory>
 
 namespace arm_compute
 {
@@ -34,6 +37,7 @@ class IAllocator
 public:
     /** Default virtual destructor. */
     virtual ~IAllocator() = default;
+    // TODO (COMPMID-1088) : Change allocator and rest interfaces to use IMemoryRegion
     /** Interface to be implemented by the child class to allocate bytes
      *
      * @param[in] size      Size to allocate
@@ -44,6 +48,14 @@ public:
     virtual void *allocate(size_t size, size_t alignment) = 0;
     /** Interface to be implemented by the child class to free the allocated tensor */
     virtual void free(void *ptr) = 0;
+    /** Create self-managed memory region
+     *
+     * @param[in] size      Size of the memory region
+     * @param[in] alignment Alignment of the memory region
+     *
+     * @return The memory region object
+     */
+    virtual std::unique_ptr<IMemoryRegion> make_region(size_t size, size_t alignment) = 0;
 };
 } // arm_compute
 #endif /*__ARM_COMPUTE_IALLOCATOR_H__ */
diff --git a/arm_compute/runtime/CL/SVMMemory.h b/arm_compute/runtime/IMemoryRegion.h
index 9029388c70..4c08b4ab09 100644
--- a/arm_compute/runtime/CL/SVMMemory.h
+++ b/arm_compute/runtime/IMemoryRegion.h
@@ -21,37 +21,63 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-#ifndef __ARM_COMPUTE_SVMMEMORY_H__
-#define __ARM_COMPUTE_SVMMEMORY_H__
+#ifndef __ARM_COMPUTE_RUNTIME_IMEMORY_REGION_H__
+#define __ARM_COMPUTE_RUNTIME_IMEMORY_REGION_H__
+
+#include <cstddef>
 
 namespace arm_compute
 {
-class SVMMemory final
+/** Memory region interface */
+class IMemoryRegion
 {
 public:
-    SVMMemory() = default;
-    SVMMemory(void *ptr, bool fine_grain)
-        : _ptr(ptr), _fine_grain(fine_grain), _size(0)
-    {
-    }
-    void *ptr() const
+    /** Default constructor
+     *
+     * @param[in] size Region size
+     */
+    IMemoryRegion(size_t size)
+        : _size(size)
     {
-        return _ptr;
     }
-    bool fine_grain() const
+    /** Virtual Destructor */
+    virtual ~IMemoryRegion() = default;
+    /** Returns the pointer to the allocated data.
+     *
+     * @return Pointer to the allocated data
+     */
+    virtual void *buffer() = 0;
+    /** Returns the pointer to the allocated data.
+     *
+     * @return Pointer to the allocated data
+     */
+    virtual void *buffer() const = 0;
+    /** Handle of internal memory
+     *
+     * @return Handle of memory
+     */
+    virtual void **handle() = 0;
+    /** Memory region size accessor
+     *
+     * @return Memory region size
+     */
+    size_t size()
     {
-        return _fine_grain;
+        return _size;
     }
-    size_t size() const
+    /** Sets size of region
+     *
+     * @warning This should only be used in correlation with handle
+     *
+     * @param[in] size Size to set
+     */
+    void set_size(size_t size)
     {
-        return _size;
+        _size = size;
     }
-    void *allocate(cl_context context, size_t size, cl_svm_mem_flags flags, cl_uint alignment);
 
-private:
-    void *_ptr{ nullptr };
-    bool   _fine_grain{ false };
-    size_t _size{ 0 };
+protected:
+    size_t _size;
 };
-}
-#endif /* __ARM_COMPUTE_SVMMEMORY_H__ */
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_RUNTIME_IMEMORY_REGION_H__ */
diff --git a/arm_compute/runtime/Memory.h b/arm_compute/runtime/Memory.h
index 98bbb70239..2dadccf254 100644
--- a/arm_compute/runtime/Memory.h
+++ b/arm_compute/runtime/Memory.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 ARM Limited.
+ * Copyright (c) 2017-2018 ARM Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -24,6 +24,8 @@
 #ifndef __ARM_COMPUTE_MEMORY_H__
 #define __ARM_COMPUTE_MEMORY_H__
 
+#include "arm_compute/runtime/IMemoryRegion.h"
+
 #include <cstddef>
 #include <memory>
 
@@ -37,11 +39,9 @@ public:
     Memory();
     /** Default Constructor
      *
-     * @note Ownership of the memory is transferred to this object
-     *
      * @param[in] memory Memory to be imported
      */
-    Memory(std::shared_ptr<uint8_t> memory);
+    Memory(std::shared_ptr<IMemoryRegion> memory);
     /** Default Constructor
      *
      * @note Ownership of the memory is not transferred to this object.
@@ -49,7 +49,7 @@ public:
      *
      * @param[in] memory Memory to be imported
      */
-    Memory(uint8_t *memory);
+    Memory(IMemoryRegion *memory);
     /** Allow instances of this class to be copied */
     Memory(const Memory &) = default;
     /** Allow instances of this class to be copy assigned */
@@ -58,26 +58,24 @@ public:
     Memory(Memory &&) noexcept = default;
     /** Allow instances of this class to be move assigned */
     Memory &operator=(Memory &&) noexcept = default;
-
-    /** Returns the pointer to the allocated data.
+    /** Region accessor
      *
-     * @return Pointer to the allocated data
+     * @return Memory region
      */
-    uint8_t *buffer();
-    /** Returns the pointer to the allocated data.
+    IMemoryRegion *region();
+    /** Region accessor
      *
-     * @return Pointer to the allocated data
+     * @return Memory region
      */
-    uint8_t *buffer() const;
-    /** Handle of internal memory
-     *
-     * @return Handle of memory
-     */
-    uint8_t **handle();
+    IMemoryRegion *region() const;
+
+private:
+    /** Creates empty region */
+    void create_empty_region();
 
 private:
-    uint8_t                 *_memory;
-    std::shared_ptr<uint8_t> _memory_owned;
+    IMemoryRegion                 *_region;
+    std::shared_ptr<IMemoryRegion> _region_owned;
 };
 }
 #endif /* __ARM_COMPUTE_MEMORY_H__ */
diff --git a/arm_compute/runtime/MemoryRegion.h b/arm_compute/runtime/MemoryRegion.h
new file mode 100644
index 0000000000..bf4e1719de
--- /dev/null
+++ b/arm_compute/runtime/MemoryRegion.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2018 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __ARM_COMPUTE_RUNTIME_MEMORY_REGION_H__
+#define __ARM_COMPUTE_RUNTIME_MEMORY_REGION_H__
+
+#include "arm_compute/runtime/IMemoryRegion.h"
+
+#include "arm_compute/core/Error.h"
+
+#include <cstddef>
+
+namespace arm_compute
+{
+/** Memory region CPU implementation */
+class MemoryRegion final : public IMemoryRegion
+{
+public:
+    /** Default constructor
+     *
+     * @param[in] size Region size
+     */
+    MemoryRegion(size_t size)
+        : IMemoryRegion(size), _mem(nullptr), _ptr(nullptr)
+    {
+        if(size != 0)
+        {
+            _mem = std::shared_ptr<uint8_t>(new uint8_t[size](), [](uint8_t *ptr)
+            {
+                delete[] ptr;
+            });
+            _ptr = _mem.get();
+        }
+    }
+    /** Prevent instances of this class from being copied (As this class contains pointers) */
+    MemoryRegion(const MemoryRegion &) = delete;
+    /** Default move constructor */
+    MemoryRegion(MemoryRegion &&) = default;
+    /** Prevent instances of this class from being copied (As this class contains pointers) */
+    MemoryRegion &operator=(const MemoryRegion &) = delete;
+    /** Default move assignment operator */
+    MemoryRegion &operator=(MemoryRegion &&) = default;
+
+    // Inherited methods overridden :
+    void *buffer() final
+    {
+        return _mem.get();
+    }
+    void *buffer() const final
+    {
+        return _mem.get();
+    }
+    void **handle() final
+    {
+        return reinterpret_cast<void **>(&_mem);
+    }
+
+protected:
+    std::shared_ptr<uint8_t> _mem;
+    uint8_t                 *_ptr;
+};
+} // namespace arm_compute
+#endif /* __ARM_COMPUTE_RUNTIME_MEMORY_REGION_H__ */