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

subtensor.h
1 /* file: subtensor.h */
2 /*******************************************************************************
3 * Copyright 2014-2017 Intel Corporation
4 * All Rights Reserved.
5 *
6 * If this software was obtained under the Intel Simplified Software License,
7 * the following terms apply:
8 *
9 * The source code, information and material ("Material") contained herein is
10 * owned by Intel Corporation or its suppliers or licensors, and title to such
11 * Material remains with Intel Corporation or its suppliers or licensors. The
12 * Material contains proprietary information of Intel or its suppliers and
13 * licensors. The Material is protected by worldwide copyright laws and treaty
14 * provisions. No part of the Material may be used, copied, reproduced,
15 * modified, published, uploaded, posted, transmitted, distributed or disclosed
16 * in any way without Intel's prior express written permission. No license under
17 * any patent, copyright or other intellectual property rights in the Material
18 * is granted to or conferred upon you, either expressly, by implication,
19 * inducement, estoppel or otherwise. Any license under such intellectual
20 * property rights must be express and approved by Intel in writing.
21 *
22 * Unless otherwise agreed by Intel in writing, you may not remove or alter this
23 * notice or any other notice embedded in Materials by Intel or Intel's
24 * suppliers or licensors in any way.
25 *
26 *
27 * If this software was obtained under the Apache License, Version 2.0 (the
28 * "License"), the following terms apply:
29 *
30 * You may not use this file except in compliance with the License. You may
31 * obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
32 *
33 *
34 * Unless required by applicable law or agreed to in writing, software
35 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
36 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
37 *
38 * See the License for the specific language governing permissions and
39 * limitations under the License.
40 *******************************************************************************/
41 
42 /*
43 //++
44 // Declaration and implementation of the base class for numeric n-cubes.
45 //--
46 */
47 
48 
49 #ifndef __SUBTENSOR_H__
50 #define __SUBTENSOR_H__
51 
52 #include "services/error_handling.h"
53 #include "services/daal_memory.h"
54 #include "data_management/data/numeric_types.h"
55 #include "data_management/data/tensor.h"
56 
57 namespace daal
58 {
59 namespace data_management
60 {
61 
62 namespace interface1
63 {
72 template<typename DataType>
73 class DAAL_EXPORT SubtensorDescriptor
74 {
75 public:
77  SubtensorDescriptor();
78 
80  ~SubtensorDescriptor();
81 
86  inline DataType* getPtr() const
87  {
88  if(_rawPtr)
89  {
90  return (DataType *)_rawPtr;
91  }
92  return _ptr.get();
93  }
94 
99  inline services::SharedPtr<DataType> getSharedPtr() const
100  {
101  if(_rawPtr)
102  {
103  return services::SharedPtr<DataType>(services::reinterpretPointerCast<DataType, byte>(*_pPtr), (DataType *)_rawPtr);
104  }
105  return _ptr;
106  }
111  inline size_t getNumberOfDims() const { return _tensorNDims-_nFixedDims; }
112 
117  inline size_t* getSubtensorDimSizes() const { return _dimNums+_nFixedDims; }
118 
123  inline const TensorOffsetLayout *getLayout() const { return _layout; }
124 
129  inline bool getInplaceFlag() const { return _inplaceFlag; }
130 
134  inline void reset()
135  {
136  _pPtr = NULL;
137  _rawPtr = NULL;
138  }
139 
140 public:
146  inline void setPtr( DataType *ptr )
147  {
148  _ptr = services::SharedPtr<DataType>(ptr, services::EmptyDeleter());
149  _inplaceFlag = true;
150  }
151 
152  inline void setPtr( services::SharedPtr<byte>* pPtr, byte * rawPtr )
153  {
154  _pPtr = pPtr;
155  _rawPtr = rawPtr;
156  _inplaceFlag = true;
157  }
158 
162  inline bool resizeBuffer()
163  {
164  if ( _subtensorSize > _capacity )
165  {
166  freeBuffer();
167 
168  _buffer = services::SharedPtr<DataType>((DataType *)daal::services::daal_malloc(_subtensorSize * sizeof(DataType)), services::ServiceDeleter());
169 
170  if ( _buffer != 0 )
171  {
172  _capacity = _subtensorSize;
173  }
174  else
175  {
176  return false;
177  }
178 
179  }
180 
181  _ptr = _buffer;
182  _inplaceFlag = false;
183 
184  return true;
185  }
186 
198  size_t setDetails( size_t tensorNDims, const size_t *tensorDimNums,
199  size_t nFixedDims, const size_t *fixedDimNums, size_t rangeDimIdx, size_t rangeDimNum, int rwFlag )
200  {
201  if (tensorDimNums == 0 || (nFixedDims > 0 && fixedDimNums == 0) || nFixedDims > tensorNDims)
202  {
203  return 0;
204  }
205 
206  _rwFlag = rwFlag;
207 
208  if( _tensorNDims != tensorNDims )
209  {
210  if( _dimNums != _tensorNDimsBuffer )
211  {
212  daal::services::daal_free( _dimNums );
213  }
214 
215  if( tensorNDims>10 )
216  {
217  _dimNums = (size_t*)daal::services::daal_malloc( tensorNDims * sizeof(size_t) );
218  }
219  else
220  {
221  _dimNums = _tensorNDimsBuffer;
222  }
223 
224  if( !_dimNums )
225  {
226  _tensorNDims = 0;
227  return 0;
228  }
229 
230  _tensorNDims = tensorNDims;
231  }
232 
233  _nFixedDims = nFixedDims;
234  for( size_t i = 0; i < _nFixedDims; i++ )
235  {
236  _dimNums[i] = fixedDimNums[i];
237  }
238 
239  _subtensorSize = 1;
240 
241  if( _nFixedDims != _tensorNDims )
242  {
243  _rangeDimIdx = rangeDimIdx;
244  _dimNums[_nFixedDims] = rangeDimNum;
245  _subtensorSize *= rangeDimNum;
246  }
247 
248  for( size_t i = _nFixedDims+1; i < _tensorNDims; i++ )
249  {
250  _dimNums[i] = tensorDimNums[i];
251  _subtensorSize *= tensorDimNums[i];
252  }
253 
254  return _subtensorSize;
255  }
256 
261  inline bool saveOffsetLayout( const TensorOffsetLayout &layout )
262  {
263  if( !_layout )
264  {
265  _layout = const_cast<TensorOffsetLayout *>(&layout);
266  _layoutOwnFlag = false;
267  }
268  return true;
269  }
270 
275  inline bool saveOffsetLayoutCopy( const TensorOffsetLayout &layout )
276  {
277  if( !_layout )
278  {
279  _layout = new TensorOffsetLayout(layout);
280  if (!_layout)
281  {
282  return false;
283  }
284  _layoutOwnFlag = true;
285  }
286  return true;
287  }
288 
293  inline size_t getSize() const { return _subtensorSize; }
294 
299  inline size_t getFixedDims() const { return _nFixedDims; }
300 
305  inline size_t *getFixedDimNums() const { return _dimNums; }
306 
311  inline size_t getRangeDimIdx() const { return _rangeDimIdx; }
312 
317  inline size_t getRangeDimNum() const
318  {
319  if( _nFixedDims != _tensorNDims )
320  {
321  return _dimNums[_nFixedDims];
322  }
323  return 1;
324  }
325 
330  inline size_t getRWFlag() const { return _rwFlag; }
331 
332 protected:
336  void freeBuffer()
337  {
338  _buffer = services::SharedPtr<DataType>();
339  _capacity = 0;
340  }
341 
342 private:
343  services::SharedPtr<DataType> _ptr; /*<! Pointer to the buffer */
344  services::SharedPtr<DataType> _buffer; /*<! Pointer to the buffer */
345  size_t _capacity; /*<! Buffer size in bytes */
346 
347  size_t _tensorNDims;
348  size_t _nFixedDims;
349  size_t _rangeDimIdx;
350  size_t *_dimNums;
351 
352  size_t _tensorNDimsBuffer[10];
353 
354  size_t _subtensorSize;
355 
356  int _rwFlag; /*<! Buffer size in bytes */
357  TensorOffsetLayout *_layout;
358  bool _layoutOwnFlag;
359  bool _inplaceFlag;
360  services::SharedPtr<byte> *_pPtr;
361  byte *_rawPtr;
362 };
365 }
366 
367 using interface1::SubtensorDescriptor;
368 
369 }
370 } // namespace daal
371 
372 #endif
daal::data_management::interface1::SubtensorDescriptor::getRangeDimNum
size_t getRangeDimNum() const
Definition: subtensor.h:317
daal
Definition: algorithm_base_common.h:57
daal::data_management::interface1::SubtensorDescriptor::getFixedDims
size_t getFixedDims() const
Definition: subtensor.h:299
daal::data_management::interface1::SubtensorDescriptor::getRangeDimIdx
size_t getRangeDimIdx() const
Definition: subtensor.h:311
daal::data_management::interface1::SubtensorDescriptor::getNumberOfDims
size_t getNumberOfDims() const
Definition: subtensor.h:111
daal::data_management::interface1::SubtensorDescriptor::saveOffsetLayoutCopy
bool saveOffsetLayoutCopy(const TensorOffsetLayout &layout)
Definition: subtensor.h:275
daal::data_management::interface1::SubtensorDescriptor::getSize
size_t getSize() const
Definition: subtensor.h:293
daal::data_management::interface1::SubtensorDescriptor::getInplaceFlag
bool getInplaceFlag() const
Definition: subtensor.h:129
daal::data_management::interface1::SubtensorDescriptor::getPtr
DataType * getPtr() const
Definition: subtensor.h:86
daal::data_management::interface1::SubtensorDescriptor::freeBuffer
void freeBuffer()
Definition: subtensor.h:336
daal::data_management::interface1::SubtensorDescriptor::getSharedPtr
services::SharedPtr< DataType > getSharedPtr() const
Definition: subtensor.h:99
daal::data_management::interface1::SubtensorDescriptor::getSubtensorDimSizes
size_t * getSubtensorDimSizes() const
Definition: subtensor.h:117
daal::data_management::interface1::SubtensorDescriptor::reset
void reset()
Definition: subtensor.h:134
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:146
daal::data_management::interface1::SubtensorDescriptor::getRWFlag
size_t getRWFlag() const
Definition: subtensor.h:330
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:261
daal::data_management::interface1::TensorOffsetLayout
Class for a data management component responsible for representation of data layout in the HomogenTen...
Definition: tensor.h:215
daal::data_management::interface1::SubtensorDescriptor::getLayout
const TensorOffsetLayout * getLayout() const
Definition: subtensor.h:123
daal::data_management::interface1::SubtensorDescriptor
Class with descriptor of the subtensor retrieved from Tensor getSubTensor function.
Definition: subtensor.h:73
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:198
daal::data_management::interface1::SubtensorDescriptor::resizeBuffer
bool resizeBuffer()
Definition: subtensor.h:162
daal::data_management::interface1::SubtensorDescriptor::getFixedDimNums
size_t * getFixedDimNums() const
Definition: subtensor.h:305

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