inference-engine/src/gna_plugin/gna_mem_requests.hpp

   1 // Copyright (C) 2018-2019 Intel Corporation
   2 // SPDX-License-Identifier: Apache-2.0
   3 //
   4
   5 #pragma once
   6 #include <list>
   7 #include <vector>
   8 #include <algorithm>
   9 #include <functional>
  10
  11 namespace GNAPluginNS {
  12
  13 enum rType {
  14     REQUEST_STORE,
  15     REQUEST_ALLOCATE,
  16     REQUEST_BIND,
  17     REQUEST_INITIALIZER,
  18 };
  19 /**
  20  * @brief region of firmware data
  21  */
  22 enum rRegion {
  23     REGION_RO,
  24     REGION_RW,
  25     REGION_AUTO,
  26 };
  27
  28 struct MemRequest {
  29     rType _type;
  30     rRegion  _region;
  31     void *_ptr_out;
  32     const void *_ptr_in = nullptr;
  33     std::function<void(void * data, size_t size)> _initializer;
  34     // holds arbitrary value
  35     std::vector<uint8_t> _data;
  36     uint8_t _element_size;
  37     size_t _num_elements;
  38     size_t _alignment;
  39     size_t _offset;
  40     // expansion in bytes due to large depended layers
  41     size_t _padding = 0;
  42     MemRequest(rRegion region,
  43                 rType req,
  44                 void *ptr_out,
  45                 const void *ptr_in,
  46                 uint8_t element_size = 0,
  47                 size_t num_elements = 0,
  48                 size_t alignment = 1,
  49                 size_t offset = 0) : _region(region),
  50                                      _type(req),
  51                                      _ptr_out(ptr_out),
  52                                      _ptr_in(ptr_in),
  53                                      _element_size(element_size),
  54                                      _num_elements(num_elements),
  55                                      _alignment(alignment),
  56                                      _offset(offset) {}
  57
  58     /**
  59      * Store value only request
  60      * @tparam T
  61      * @param req
  62      * @param ptr_out
  63      * @param element
  64      * @param num_elements
  65      * @param alignment
  66      */
  67     template<class T>
  68     MemRequest(rRegion region,
  69                 void *ptr_out,
  70                 T element,
  71                 size_t num_elements,
  72                 size_t alignment = 1) : _region(region),
  73                                         _type(REQUEST_STORE),
  74                                         _ptr_out(ptr_out),
  75                                         _element_size(sizeof(T)),
  76                                         _num_elements(num_elements),
  77                                         _alignment(alignment) {
  78         _data.resize(sizeof(T));
  79         std::copy(reinterpret_cast<uint8_t *>(&element), reinterpret_cast<uint8_t *>(&element) + sizeof(T), _data.begin());
  80     }
  81 /**
  82      * Store initializer request
  83      * @param req
  84      * @param ptr_out
  85      * @param element
  86      * @param num_elements
  87      * @param alignment
  88      */
  89     MemRequest(rRegion region,
  90                void   *ptr_out,
  91                size_t  regionSize,
  92                std::function<void(void * data, size_t size)> initializer,
  93                size_t  alignment = 1) : _region(region),
  94                                         _type(REQUEST_INITIALIZER),
  95                                         _ptr_out(ptr_out),
  96                                         _element_size(1),
  97                                         _num_elements(regionSize),
  98                                         _alignment(alignment),
  99                                         _initializer(initializer) {
 100     }
 101 };
 102
 103 /**
 104  * Adapter for requests submission and actual request queue
 105  */
 106 class GNAMemRequestsQueue {
 107  public:
 108     virtual ~GNAMemRequestsQueue() {}
 109
 110     /**
 111      * @brief register initialiser to access memory once it is actually allocated
 112      * @param ptr_out
 113      * @param ptr_in
 114      * @param num_bytes
 115      * @param alignment
 116      */
 117     void push_initializer(void *ptr_out, size_t num_bytes, std::function<void(void * data, size_t size)> initializer, size_t alignment = 1) {
 118         futureHeap().push_back({regionType(), ptr_out, num_bytes, initializer, alignment});
 119     }
 120
 121     void push_ptr(void *ptr_out, const void *ptr_in, size_t num_bytes, size_t alignment = 1) {
 122         futureHeap().push_back({regionType(), REQUEST_STORE, ptr_out, ptr_in, 1, num_bytes, alignment});
 123     }
 124
 125     /**
 126      * copy input to intermediate buffer
 127      * @param ptr_out
 128      * @param ptr_in
 129      * @param num_bytes
 130      */
 131     void push_local_ptr(void *ptr_out, const void *ptr_in, size_t num_bytes, size_t alignment = 1) {
 132         localStorage().emplace_back(reinterpret_cast<const uint8_t *>(ptr_in),
 133                                     reinterpret_cast<const uint8_t *>(ptr_in) + num_bytes);
 134         futureHeap().push_back({regionType(), REQUEST_STORE, ptr_out, &localStorage().back().front(), 1, num_bytes, alignment});
 135     }
 136
 137     /**
 138      *
 139      * @param ptr_out
 140      * @param num_bytes
 141      */
 142     void reserve_ptr(void *ptr_out, size_t num_bytes)  {
 143         futureHeap().push_back({regionType(), REQUEST_ALLOCATE, ptr_out, nullptr, 1, num_bytes});
 144     }
 145
 146     /**
 147      *
 148      * @param source
 149      * @param dest - source is binded to dest pointer after allocation
 150      * @param offset - offset in bytes in sourse that will be set in dest
 151      * @param num_bytes - bind can request for bigger buffer that originally allocated via reserve(),
 152      *      if that happens - reserved request parameters will be updated bero commiting memory
 153      */
 154     void bind_ptr(void *source, const void *dest, size_t offset = 0, size_t num_bytes = 0)  {
 155         futureHeap().push_back({regionType(), REQUEST_BIND, source, dest, 1, num_bytes, 1, offset});
 156     }
 157     /**
 158      * @brief allocates buffer and set all its values to T value
 159      */
 160     template<class T>
 161     void push_value(void *ptr_out, T value, size_t num_elements, size_t alignment = 1) {
 162         futureHeap().push_back({regionType(), ptr_out, value, num_elements, alignment});
 163     }
 164
 165     /**
 166      * @brief interface for actual queue storage
 167      */
 168     virtual rRegion regionType() const = 0;
 169     virtual std::vector<MemRequest> & futureHeap()  = 0;
 170     virtual std::list<std::vector<char>> &localStorage() = 0;
 171 };
 172
 173
 174
 175 }  // namespace GNAPluginNS