C++ API Reference for Intel® Data Analytics Acceleration Library 2020 Update 1

subtensor.h
1 /* file: subtensor.h */
2 /*******************************************************************************
3 * Copyright 2014-2020 Intel Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *******************************************************************************/
17 
18 /*
19 //++
20 // Declaration and implementation of the base class for numeric n-cubes.
21 //--
22 */
23 
24 
25 #ifndef __SUBTENSOR_H__
26 #define __SUBTENSOR_H__
27 
28 #include "services/error_handling.h"
29 #include "services/daal_memory.h"
30 #include "data_management/data/numeric_types.h"
31 #include "data_management/data/tensor.h"
32 
33 namespace daal
34 {
35 namespace data_management
36 {
37 
38 namespace interface1
39 {
48 template<typename DataType>
49 class DAAL_EXPORT SubtensorDescriptor
50 {
51 public:
53  SubtensorDescriptor();
54 
56  ~SubtensorDescriptor();
57 
62  inline DataType* getPtr() const
63  {
64  if(_rawPtr)
65  {
66  return (DataType *)_rawPtr;
67  }
68  return _ptr.get();
69  }
70 
75  inline services::SharedPtr<DataType> getSharedPtr() const
76  {
77  if(_rawPtr)
78  {
79  return services::SharedPtr<DataType>(services::reinterpretPointerCast<DataType, byte>(*_pPtr), (DataType *)_rawPtr);
80  }
81  return _ptr;
82  }
87  inline size_t getNumberOfDims() const { return _tensorNDims-_nFixedDims; }
88 
93  inline size_t* getSubtensorDimSizes() const { return _dimNums+_nFixedDims; }
94 
99  inline const TensorOffsetLayout *getLayout() const { return _layout; }
100 
105  inline bool getInplaceFlag() const { return _inplaceFlag; }
106 
110  inline void reset()
111  {
112  _pPtr = NULL;
113  _rawPtr = NULL;
114  }
115 
116 public:
122  inline void setPtr( DataType *ptr )
123  {
124  _ptr = services::SharedPtr<DataType>(ptr, services::EmptyDeleter());
125  _inplaceFlag = true;
126  }
127 
128  inline void setPtr( services::SharedPtr<byte>* pPtr, byte * rawPtr )
129  {
130  _pPtr = pPtr;
131  _rawPtr = rawPtr;
132  _inplaceFlag = true;
133  }
134 
138  inline bool resizeBuffer()
139  {
140  if ( _subtensorSize > _capacity )
141  {
142  freeBuffer();
143 
144  _buffer = services::SharedPtr<DataType>((DataType *)daal::services::daal_malloc(_subtensorSize * sizeof(DataType)), services::ServiceDeleter());
145 
146  if ( _buffer != 0 )
147  {
148  _capacity = _subtensorSize;
149  }
150  else
151  {
152  return false;
153  }
154 
155  }
156 
157  _ptr = _buffer;
158  _inplaceFlag = false;
159 
160  return true;
161  }
162 
174  size_t setDetails( size_t tensorNDims, const size_t *tensorDimNums,
175  size_t nFixedDims, const size_t *fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum, int rwFlag )
176  {
177  if (tensorDimNums == 0 || (nFixedDims > 0 && fixedDimNums == 0) || nFixedDims > tensorNDims)
178  {
179  return 0;
180  }
181 
182  _rwFlag = rwFlag;
183 
184  if( _tensorNDims != tensorNDims )
185  {
186  if( _dimNums != _tensorNDimsBuffer )
187  {
188  daal::services::daal_free( _dimNums );
189  }
190 
191  if( tensorNDims>10 )
192  {
193  _dimNums = (size_t*)daal::services::daal_malloc( tensorNDims * sizeof(size_t) );
194  }
195  else
196  {
197  _dimNums = _tensorNDimsBuffer;
198  }
199 
200  if( !_dimNums )
201  {
202  _tensorNDims = 0;
203  return 0;
204  }
205 
206  _tensorNDims = tensorNDims;
207  }
208 
209  _nFixedDims = nFixedDims;
210  for( size_t i = 0; i < _nFixedDims; i++ )
211  {
212  _dimNums[i] = fixedDimNums[i];
213  }
214 
215  _subtensorSize = 1;
216 
217  if( _nFixedDims != _tensorNDims )
218  {
219  _rangeDimIdx = rangeDimIdx;
220  _dimNums[_nFixedDims] = rangeDimNum;
221  _subtensorSize *= rangeDimNum;
222  }
223 
224  for( size_t i = _nFixedDims+1; i < _tensorNDims; i++ )
225  {
226  _dimNums[i] = tensorDimNums[i];
227  _subtensorSize *= tensorDimNums[i];
228  }
229 
230  return _subtensorSize;
231  }
232 
237  inline bool saveOffsetLayout( const TensorOffsetLayout &layout )
238  {
239  if( !_layout )
240  {
241  _layout = const_cast<TensorOffsetLayout *>(&layout);
242  _layoutOwnFlag = false;
243  }
244  return true;
245  }
246 
251  inline bool saveOffsetLayoutCopy( const TensorOffsetLayout &layout )
252  {
253  if( !_layout )
254  {
255  _layout = new TensorOffsetLayout(layout);
256  if (!_layout)
257  {
258  return false;
259  }
260  _layoutOwnFlag = true;
261  }
262  return true;
263  }
264 
269  inline size_t getSize() const { return _subtensorSize; }
270 
275  inline size_t getFixedDims() const { return _nFixedDims; }
276 
281  inline size_t *getFixedDimNums() const { return _dimNums; }
282 
287  inline size_t getRangeDimIdx() const { return _rangeDimIdx; }
288 
293  inline size_t getRangeDimNum() const
294  {
295  if( _nFixedDims != _tensorNDims )
296  {
297  return _dimNums[_nFixedDims];
298  }
299  return 1;
300  }
301 
306  inline size_t getRWFlag() const { return _rwFlag; }
307 
308 protected:
312  void freeBuffer()
313  {
314  _buffer = services::SharedPtr<DataType>();
315  _capacity = 0;
316  }
317 
318 private:
319  services::SharedPtr<DataType> _ptr; /*<! Pointer to the buffer */
320  services::SharedPtr<DataType> _buffer; /*<! Pointer to the buffer */
321  size_t _capacity; /*<! Buffer size in bytes */
322 
323  size_t _tensorNDims;
324  size_t _nFixedDims;
325  size_t _rangeDimIdx;
326  size_t *_dimNums;
327 
328  size_t _tensorNDimsBuffer[10];
329 
330  size_t _subtensorSize;
331 
332  int _rwFlag; /*<! Buffer size in bytes */
333  TensorOffsetLayout *_layout;
334  bool _layoutOwnFlag;
335  bool _inplaceFlag;
336  services::SharedPtr<byte> *_pPtr;
337  byte *_rawPtr;
338 };
341 }
342 
343 using interface1::SubtensorDescriptor;
344 
345 }
346 } // namespace daal
347 
348 #endif
daal::data_management::interface1::SubtensorDescriptor::getPtr
DataType * getPtr() const
Definition: subtensor.h:62
daal::data_management::interface1::SubtensorDescriptor::getRangeDimIdx
size_t getRangeDimIdx() const
Definition: subtensor.h:287
daal::data_management::interface1::SubtensorDescriptor::saveOffsetLayout
bool saveOffsetLayout(const TensorOffsetLayout &layout)
Definition: subtensor.h:237
daal::data_management::interface1::SubtensorDescriptor::getRangeDimNum
size_t getRangeDimNum() const
Definition: subtensor.h:293
daal::data_management::interface1::SubtensorDescriptor::reset
void reset()
Definition: subtensor.h:110
daal::data_management::interface1::SubtensorDescriptor::getFixedDimNums
size_t * getFixedDimNums() const
Definition: subtensor.h:281
daal::data_management::interface1::SubtensorDescriptor::getLayout
const TensorOffsetLayout * getLayout() const
Definition: subtensor.h:99
daal::data_management::interface1::SubtensorDescriptor::saveOffsetLayoutCopy
bool saveOffsetLayoutCopy(const TensorOffsetLayout &layout)
Definition: subtensor.h:251
daal::data_management::interface1::SubtensorDescriptor::getInplaceFlag
bool getInplaceFlag() const
Definition: subtensor.h:105
daal::data_management::interface1::SubtensorDescriptor::getNumberOfDims
size_t getNumberOfDims() const
Definition: subtensor.h:87
daal::data_management::interface1::TensorOffsetLayout
Class for a data management component responsible for representation of data layout in the HomogenTen...
Definition: tensor.h:205
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:174
daal::services::daal_malloc
DAAL_EXPORT void * daal_malloc(size_t size, size_t alignment=DAAL_MALLOC_DEFAULT_ALIGNMENT)
daal::data_management::interface1::SubtensorDescriptor
Class with descriptor of the subtensor retrieved from Tensor getSubTensor function.
Definition: subtensor.h:49
daal::data_management::interface1::SubtensorDescriptor::getSubtensorDimSizes
size_t * getSubtensorDimSizes() const
Definition: subtensor.h:93
daal::services::daal_free
DAAL_EXPORT void daal_free(void *ptr)
daal::data_management::interface1::SubtensorDescriptor::getFixedDims
size_t getFixedDims() const
Definition: subtensor.h:275
daal::data_management::interface1::SubtensorDescriptor::setPtr
void setPtr(DataType *ptr)
Definition: subtensor.h:122
daal::data_management::interface1::SubtensorDescriptor::getSharedPtr
services::SharedPtr< DataType > getSharedPtr() const
Definition: subtensor.h:75
daal::data_management::interface1::SubtensorDescriptor::getSize
size_t getSize() const
Definition: subtensor.h:269
daal::data_management::interface1::SubtensorDescriptor::freeBuffer
void freeBuffer()
Definition: subtensor.h:312
daal::data_management::interface1::SubtensorDescriptor::resizeBuffer
bool resizeBuffer()
Definition: subtensor.h:138
daal::data_management::interface1::SubtensorDescriptor::getRWFlag
size_t getRWFlag() const
Definition: subtensor.h:306

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