C++ API Reference for Intel® Data Analytics Acceleration Library 2018 Update 3

subtensor.h
1 /* file: subtensor.h */
2 /*******************************************************************************
3 * Copyright 2014-2018 Intel Corporation.
4 *
5 * This software and the related documents are Intel copyrighted materials, and
6 * your use of them is governed by the express license under which they were
7 * provided to you (License). Unless the License provides otherwise, you may not
8 * use, modify, copy, publish, distribute, disclose or transmit this software or
9 * the related documents without Intel's prior written permission.
10 *
11 * This software and the related documents are provided as is, with no express
12 * or implied warranties, other than those that are expressly stated in the
13 * License.
14 *******************************************************************************/
15 
16 /*
17 //++
18 // Declaration and implementation of the base class for numeric n-cubes.
19 //--
20 */
21 
22 
23 #ifndef __SUBTENSOR_H__
24 #define __SUBTENSOR_H__
25 
26 #include "services/error_handling.h"
27 #include "services/daal_memory.h"
28 #include "data_management/data/numeric_types.h"
29 #include "data_management/data/tensor.h"
30 
31 namespace daal
32 {
33 namespace data_management
34 {
35 
36 namespace interface1
37 {
46 template<typename DataType>
47 class DAAL_EXPORT SubtensorDescriptor
48 {
49 public:
51  SubtensorDescriptor();
52 
54  ~SubtensorDescriptor();
55 
60  inline DataType* getPtr() const
61  {
62  if(_rawPtr)
63  {
64  return (DataType *)_rawPtr;
65  }
66  return _ptr.get();
67  }
68 
73  inline services::SharedPtr<DataType> getSharedPtr() const
74  {
75  if(_rawPtr)
76  {
77  return services::SharedPtr<DataType>(services::reinterpretPointerCast<DataType, byte>(*_pPtr), (DataType *)_rawPtr);
78  }
79  return _ptr;
80  }
85  inline size_t getNumberOfDims() const { return _tensorNDims-_nFixedDims; }
86 
91  inline size_t* getSubtensorDimSizes() const { return _dimNums+_nFixedDims; }
92 
97  inline const TensorOffsetLayout *getLayout() const { return _layout; }
98 
103  inline bool getInplaceFlag() const { return _inplaceFlag; }
104 
108  inline void reset()
109  {
110  _pPtr = NULL;
111  _rawPtr = NULL;
112  }
113 
114 public:
120  inline void setPtr( DataType *ptr )
121  {
122  _ptr = services::SharedPtr<DataType>(ptr, services::EmptyDeleter());
123  _inplaceFlag = true;
124  }
125 
126  inline void setPtr( services::SharedPtr<byte>* pPtr, byte * rawPtr )
127  {
128  _pPtr = pPtr;
129  _rawPtr = rawPtr;
130  _inplaceFlag = true;
131  }
132 
136  inline bool resizeBuffer()
137  {
138  if ( _subtensorSize > _capacity )
139  {
140  freeBuffer();
141 
142  _buffer = services::SharedPtr<DataType>((DataType *)daal::services::daal_malloc(_subtensorSize * sizeof(DataType)), services::ServiceDeleter());
143 
144  if ( _buffer != 0 )
145  {
146  _capacity = _subtensorSize;
147  }
148  else
149  {
150  return false;
151  }
152 
153  }
154 
155  _ptr = _buffer;
156  _inplaceFlag = false;
157 
158  return true;
159  }
160 
172  size_t setDetails( size_t tensorNDims, const size_t *tensorDimNums,
173  size_t nFixedDims, const size_t *fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum, int rwFlag )
174  {
175  if (tensorDimNums == 0 || (nFixedDims > 0 && fixedDimNums == 0) || nFixedDims > tensorNDims)
176  {
177  return 0;
178  }
179 
180  _rwFlag = rwFlag;
181 
182  if( _tensorNDims != tensorNDims )
183  {
184  if( _dimNums != _tensorNDimsBuffer )
185  {
186  daal::services::daal_free( _dimNums );
187  }
188 
189  if( tensorNDims>10 )
190  {
191  _dimNums = (size_t*)daal::services::daal_malloc( tensorNDims * sizeof(size_t) );
192  }
193  else
194  {
195  _dimNums = _tensorNDimsBuffer;
196  }
197 
198  if( !_dimNums )
199  {
200  _tensorNDims = 0;
201  return 0;
202  }
203 
204  _tensorNDims = tensorNDims;
205  }
206 
207  _nFixedDims = nFixedDims;
208  for( size_t i = 0; i < _nFixedDims; i++ )
209  {
210  _dimNums[i] = fixedDimNums[i];
211  }
212 
213  _subtensorSize = 1;
214 
215  if( _nFixedDims != _tensorNDims )
216  {
217  _rangeDimIdx = rangeDimIdx;
218  _dimNums[_nFixedDims] = rangeDimNum;
219  _subtensorSize *= rangeDimNum;
220  }
221 
222  for( size_t i = _nFixedDims+1; i < _tensorNDims; i++ )
223  {
224  _dimNums[i] = tensorDimNums[i];
225  _subtensorSize *= tensorDimNums[i];
226  }
227 
228  return _subtensorSize;
229  }
230 
235  inline bool saveOffsetLayout( const TensorOffsetLayout &layout )
236  {
237  if( !_layout )
238  {
239  _layout = const_cast<TensorOffsetLayout *>(&layout);
240  _layoutOwnFlag = false;
241  }
242  return true;
243  }
244 
249  inline bool saveOffsetLayoutCopy( const TensorOffsetLayout &layout )
250  {
251  if( !_layout )
252  {
253  _layout = new TensorOffsetLayout(layout);
254  if (!_layout)
255  {
256  return false;
257  }
258  _layoutOwnFlag = true;
259  }
260  return true;
261  }
262 
267  inline size_t getSize() const { return _subtensorSize; }
268 
273  inline size_t getFixedDims() const { return _nFixedDims; }
274 
279  inline size_t *getFixedDimNums() const { return _dimNums; }
280 
285  inline size_t getRangeDimIdx() const { return _rangeDimIdx; }
286 
291  inline size_t getRangeDimNum() const
292  {
293  if( _nFixedDims != _tensorNDims )
294  {
295  return _dimNums[_nFixedDims];
296  }
297  return 1;
298  }
299 
304  inline size_t getRWFlag() const { return _rwFlag; }
305 
306 protected:
310  void freeBuffer()
311  {
312  _buffer = services::SharedPtr<DataType>();
313  _capacity = 0;
314  }
315 
316 private:
317  services::SharedPtr<DataType> _ptr; /*<! Pointer to the buffer */
318  services::SharedPtr<DataType> _buffer; /*<! Pointer to the buffer */
319  size_t _capacity; /*<! Buffer size in bytes */
320 
321  size_t _tensorNDims;
322  size_t _nFixedDims;
323  size_t _rangeDimIdx;
324  size_t *_dimNums;
325 
326  size_t _tensorNDimsBuffer[10];
327 
328  size_t _subtensorSize;
329 
330  int _rwFlag; /*<! Buffer size in bytes */
331  TensorOffsetLayout *_layout;
332  bool _layoutOwnFlag;
333  bool _inplaceFlag;
334  services::SharedPtr<byte> *_pPtr;
335  byte *_rawPtr;
336 };
339 }
340 
341 using interface1::SubtensorDescriptor;
342 
343 }
344 } // namespace daal
345 
346 #endif
daal::data_management::interface1::SubtensorDescriptor::getRangeDimNum
size_t getRangeDimNum() const
Definition: subtensor.h:291
daal
Definition: algorithm_base_common.h:31
daal::data_management::interface1::SubtensorDescriptor::getFixedDims
size_t getFixedDims() const
Definition: subtensor.h:273
daal::data_management::interface1::SubtensorDescriptor::getRangeDimIdx
size_t getRangeDimIdx() const
Definition: subtensor.h:285
daal::data_management::interface1::SubtensorDescriptor::getNumberOfDims
size_t getNumberOfDims() const
Definition: subtensor.h:85
daal::data_management::interface1::SubtensorDescriptor::saveOffsetLayoutCopy
bool saveOffsetLayoutCopy(const TensorOffsetLayout &layout)
Definition: subtensor.h:249
daal::data_management::interface1::SubtensorDescriptor::getSize
size_t getSize() const
Definition: subtensor.h:267
daal::data_management::interface1::SubtensorDescriptor::getInplaceFlag
bool getInplaceFlag() const
Definition: subtensor.h:103
daal::data_management::interface1::SubtensorDescriptor::getPtr
DataType * getPtr() const
Definition: subtensor.h:60
daal::data_management::interface1::SubtensorDescriptor::freeBuffer
void freeBuffer()
Definition: subtensor.h:310
daal::data_management::interface1::SubtensorDescriptor::getSharedPtr
services::SharedPtr< DataType > getSharedPtr() const
Definition: subtensor.h:73
daal::data_management::interface1::SubtensorDescriptor::getSubtensorDimSizes
size_t * getSubtensorDimSizes() const
Definition: subtensor.h:91
daal::data_management::interface1::SubtensorDescriptor::reset
void reset()
Definition: subtensor.h:108
daal::services::daal_malloc
DAAL_EXPORT void * daal_malloc(size_t size, size_t alignment=DAAL_MALLOC_DEFAULT_ALIGNMENT)
daal::data_management::interface1::SubtensorDescriptor::setPtr
void setPtr(DataType *ptr)
Definition: subtensor.h:120
daal::data_management::interface1::SubtensorDescriptor::getRWFlag
size_t getRWFlag() const
Definition: subtensor.h:304
daal::services::daal_free
DAAL_EXPORT void daal_free(void *ptr)
daal::data_management::interface1::SubtensorDescriptor::saveOffsetLayout
bool saveOffsetLayout(const TensorOffsetLayout &layout)
Definition: subtensor.h:235
daal::data_management::interface1::TensorOffsetLayout
Class for a data management component responsible for representation of data layout in the HomogenTen...
Definition: tensor.h:189
daal::data_management::interface1::SubtensorDescriptor::getLayout
const TensorOffsetLayout * getLayout() const
Definition: subtensor.h:97
daal::data_management::interface1::SubtensorDescriptor
Class with descriptor of the subtensor retrieved from Tensor getSubTensor function.
Definition: subtensor.h:47
daal::data_management::interface1::SubtensorDescriptor::setDetails
size_t setDetails(size_t tensorNDims, const size_t *tensorDimNums, size_t nFixedDims, const size_t *fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum, int rwFlag)
Definition: subtensor.h:172
daal::data_management::interface1::SubtensorDescriptor::resizeBuffer
bool resizeBuffer()
Definition: subtensor.h:136
daal::data_management::interface1::SubtensorDescriptor::getFixedDimNums
size_t * getFixedDimNums() const
Definition: subtensor.h:279

For more complete information about compiler optimizations, see our Optimization Notice.