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

aos_numeric_table.h
1 /* file: aos_numeric_table.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 // Implementation of a heterogeneous table stored as a structure of arrays.
19 //--
20 */
21 
22 #ifndef __AOS_NUMERIC_TABLE_H__
23 #define __AOS_NUMERIC_TABLE_H__
24 
25 #include "data_management/data/data_serialize.h"
26 #include "data_management/data/numeric_table.h"
27 #include "services/daal_defines.h"
28 
29 namespace daal
30 {
31 namespace data_management
32 {
33 
34 // Extended variant of the standard offsetof() macro (not limited to only POD types)
35 /* Not sure if it's standard-compliant; most likely, it only works in certain environments.
36  The constant 0x1000 (not NULL) is necessary to appease GCC. */
37 #define DAAL_STRUCT_MEMBER_OFFSET(class_name, member_name) \
38  ((ptrdiff_t)&(reinterpret_cast<class_name*>(0x1000)->member_name) - 0x1000)
39 
40 namespace interface1
41 {
53 class DAAL_EXPORT AOSNumericTable : public NumericTable
54 {
55 public:
56  DECLARE_SERIALIZABLE_TAG();
57  DECLARE_SERIALIZABLE_IMPL();
58 
66  AOSNumericTable( size_t structSize = 0, size_t ncol = 0, size_t nrow = 0 );
67 
76  static services::SharedPtr<AOSNumericTable> create( size_t structSize = 0, size_t ncol = 0, size_t nrow = 0, services::Status *stat = NULL);
77 
85  template<typename StructDataType>
86  AOSNumericTable(const services::SharedPtr<StructDataType> &ptr, size_t ncol, size_t nrow = 0 ): NumericTable(ncol, nrow)
87  {
88  _ptr = services::reinterpretPointerCast<byte, StructDataType>(ptr);
89  _layout = aos;
90  _structSize = sizeof(StructDataType);
91 
92  initOffsets();
93  }
94 
103  template<typename StructDataType>
104  static services::SharedPtr<AOSNumericTable> create(const services::SharedPtr<StructDataType> &ptr, size_t ncol, size_t nrow = 0, services::Status *stat = NULL )
105  {
106  DAAL_DEFAULT_CREATE_IMPL_EX(AOSNumericTable, ptr, ncol, nrow);
107  }
108 
116  template<typename StructDataType>
117  AOSNumericTable( StructDataType *ptr, size_t ncol, size_t nrow = 0 ): NumericTable(ncol, nrow)
118  {
119  _ptr = services::SharedPtr<byte>((byte*)ptr, services::EmptyDeleter());
120  _layout = aos;
121  _structSize = sizeof(StructDataType);
122 
123  initOffsets();
124  }
125 
134  template<typename StructDataType>
135  static services::SharedPtr<AOSNumericTable> create( StructDataType *ptr, size_t ncol, size_t nrow = 0, services::Status *stat = NULL )
136  {
137  return create(services::SharedPtr<StructDataType>(ptr, services::EmptyDeleter()), ncol, nrow);
138  }
139 
141  virtual ~AOSNumericTable()
142  {
143  if (_offsets)
144  daal::services::daal_free(_offsets);
145  freeDataMemoryImpl();
146  }
147 
153  services::Status setArray(void *const ptr, size_t obsnum = 0)
154  {
155  _ptr = services::SharedPtr<byte>((byte*)ptr, services::EmptyDeleter());
156  _memStatus = userAllocated;
157  return setNumberOfRowsImpl( obsnum );
158  }
159 
165  services::Status setArray(const services::SharedPtr<byte>& ptr, size_t obsnum = 0)
166  {
167  _ptr = ptr;
168  _memStatus = userAllocated;
169  return setNumberOfRowsImpl( obsnum );
170  }
171 
176  void *getArray()
177  {
178  return (void *)(_ptr.get());
179  }
180 
185  const void *getArray() const
186  {
187  return (void *)(_ptr.get());
188  }
189 
194  services::SharedPtr<byte> getArraySharedPtr()
195  {
196  return _ptr;
197  }
198 
207  template<typename T>
208  services::Status setFeature(size_t idx, size_t offset, data_feature_utils::FeatureType featureType = data_feature_utils::DAAL_CONTINUOUS, size_t categoryNumber=0)
209  {
210  services::Status s;
211  if( _ddict.get() == NULL )
212  {
213  _ddict = NumericTableDictionary::create(&s);
214  }
215  if(!s) return s;
216 
217  s = _ddict->setFeature<T>(idx);
218  if(!s) return s;
219  (*_ddict)[idx].featureType = featureType;
220  (*_ddict)[idx].categoryNumber = categoryNumber;
221 
222  _offsets[idx] = offset;
223  return s;
224  }
225 
231  void setOffset(size_t idx, size_t offset)
232  {
233  _offsets[idx] = offset;
234  }
235 
236  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
237  {
238  return getTBlock<double>(vector_idx, vector_num, rwflag, block);
239  }
240  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
241  {
242  return getTBlock<float>(vector_idx, vector_num, rwflag, block);
243  }
244  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
245  {
246  return getTBlock<int>(vector_idx, vector_num, rwflag, block);
247  }
248 
249  services::Status releaseBlockOfRows(BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
250  {
251  return releaseTBlock<double>(block);
252  }
253  services::Status releaseBlockOfRows(BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
254  {
255  return releaseTBlock<float>(block);
256  }
257  services::Status releaseBlockOfRows(BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
258  {
259  return releaseTBlock<int>(block);
260  }
261 
262  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
263  ReadWriteMode rwflag, BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
264  {
265  return getTFeature<double>(feature_idx, vector_idx, value_num, rwflag, block);
266  }
267  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
268  ReadWriteMode rwflag, BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
269  {
270  return getTFeature<float>(feature_idx, vector_idx, value_num, rwflag, block);
271  }
272  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
273  ReadWriteMode rwflag, BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
274  {
275  return getTFeature<int>(feature_idx, vector_idx, value_num, rwflag, block);
276  }
277 
278  services::Status releaseBlockOfColumnValues(BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
279  {
280  return releaseTFeature<double>(block);
281  }
282  services::Status releaseBlockOfColumnValues(BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
283  {
284  return releaseTFeature<float>(block);
285  }
286  services::Status releaseBlockOfColumnValues(BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
287  {
288  return releaseTFeature<int>(block);
289  }
290 
291 protected:
292  services::SharedPtr<byte> _ptr;
293  size_t _structSize;
294  size_t *_offsets;
295 
296  AOSNumericTable( size_t structSize, size_t ncol, size_t nrow, services::Status &st );
297 
298  template<typename StructDataType>
299  AOSNumericTable(const services::SharedPtr<StructDataType> &ptr, size_t ncol, size_t nrow, services::Status &st) : NumericTable(ncol, nrow, DictionaryIface::notEqual, st)
300  {
301  _ptr = services::reinterpretPointerCast<byte, StructDataType>(ptr);
302  _layout = aos;
303  _structSize = sizeof(StructDataType);
304 
305  st |= initOffsets();
306  }
307 
308  services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE
309  {
310  if (checkOffsets())
311  {
312  services::Status s = createOffsetsFromDictionary();
313  if (!s) return s;
314  }
315 
316  freeDataMemoryImpl();
317 
318  const size_t size = _structSize * getNumberOfRows();
319 
320  if( size == 0 )
321  return services::Status(getNumberOfRows() == 0 ? services::ErrorIncorrectNumberOfObservations :
322  services::ErrorIncorrectNumberOfFeatures);
323 
324  _ptr = services::SharedPtr<byte>((byte *)daal::services::daal_malloc(size), services::ServiceDeleter());
325  if(!_ptr)
326  return services::Status(services::ErrorMemoryAllocationFailed);
327 
328  _memStatus = internallyAllocated;
329  return services::Status();
330  }
331 
332  bool checkOffsets() const
333  {
334  if (!_offsets) return true;
335 
336  const size_t ncols = getNumberOfColumns();
337 
338  size_t sizeOfRowInDict = 0;
339  for( size_t i = 0; i < ncols; ++i )
340  {
341  if (!(*_ddict)[i].typeSize)
342  {
343  return false;
344  }
345  sizeOfRowInDict += (*_ddict)[i].typeSize;
346  }
347  if (sizeOfRowInDict > _structSize)
348  {
349  return true;
350  }
351 
352  for( size_t i = 1; i < ncols; ++i )
353  {
354  if ( _offsets[i-1] >= _offsets[i] )
355  {
356  return true;
357  }
358  }
359  return false;
360  }
361 
362  services::Status createOffsetsFromDictionary()
363  {
364  const size_t ncols = getNumberOfColumns();
365 
366  if (_offsets)
367  daal::services::daal_free(_offsets);
368 
369  _offsets = (size_t *)daal::services::daal_malloc(sizeof(size_t) * (ncols));
370  if(!_offsets)
371  return services::Status(services::ErrorMemoryAllocationFailed);
372 
373  size_t offset = 0;
374  for( size_t i = 0; i < ncols; ++i )
375  {
376  _offsets[i] = offset;
377  offset += (*_ddict)[i].typeSize;
378  }
379  _structSize = offset;
380 
381  return services::Status();
382  }
383 
384  void freeDataMemoryImpl() DAAL_C11_OVERRIDE
385  {
386  _ptr = services::SharedPtr<byte>();
387  _memStatus = notAllocated;
388  }
389 
391  template<typename Archive, bool onDeserialize>
392  services::Status serialImpl( Archive *arch )
393  {
394  NumericTable::serialImpl<Archive, onDeserialize>( arch );
395  arch->set(_structSize);
396 
397  if( onDeserialize )
398  {
399  initOffsets();
400  }
401  arch->set((char*)_offsets, getNumberOfColumns() * sizeof(size_t));
402 
403  if( onDeserialize )
404  {
405  allocateDataMemoryImpl();
406  }
407 
408  size_t size = getNumberOfRows();
409 
410  arch->set( (char *)_ptr.get(), size * _structSize );
411 
412  return services::Status();
413  }
414 
415 private:
416 
417  template <typename T>
418  services::Status getTBlock(size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T>& block)
419  {
420  size_t ncols = getNumberOfColumns();
421  size_t nobs = getNumberOfRows();
422  block.setDetails( 0, idx, rwFlag );
423 
424  if (idx >= nobs)
425  {
426  block.resizeBuffer( ncols, 0 );
427  return services::Status();
428  }
429 
430  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
431 
432  if( !block.resizeBuffer( ncols, nrows ) )
433  return services::Status(services::ErrorMemoryAllocationFailed);
434 
435  if( !(rwFlag & (int)readOnly) )
436  return services::Status();
437 
438  char *ptr = (char *)(_ptr.get()) + _structSize * idx;
439 
440  for( size_t j = 0 ; j < ncols ; j++ )
441  {
442  NumericTableFeature &f = (*_ddict)[j];
443 
444  char *location = ptr + _offsets[j];
445 
446  T* blockPtr = block.getBlockPtr();
447 
448  data_feature_utils::getVectorStrideUpCast(f.indexType, data_feature_utils::getInternalNumType<T>())
449  ( nrows, location, _structSize, blockPtr + j, sizeof(T)*ncols );
450  }
451  return services::Status();
452  }
453 
454  template <typename T>
455  services::Status releaseTBlock( BlockDescriptor<T>& block )
456  {
457  if(block.getRWFlag() & (int)writeOnly)
458  {
459  size_t ncols = getNumberOfColumns();
460 
461  char *ptr = (char *)(_ptr.get()) + _structSize * block.getRowsOffset();
462 
463  T* blockPtr = block.getBlockPtr();
464 
465  for( size_t j = 0 ; j < ncols ; j++ )
466  {
467  NumericTableFeature &f = (*_ddict)[j];
468 
469  char *location = ptr + _offsets[j];
470 
471  data_feature_utils::getVectorStrideDownCast(f.indexType, data_feature_utils::getInternalNumType<T>())
472  ( block.getNumberOfRows(), blockPtr + j, sizeof(T)*ncols, location, _structSize );
473  }
474  }
475  block.reset();
476  return services::Status();
477  }
478 
479  template <typename T>
480  services::Status getTFeature(size_t feat_idx, size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T>& block)
481  {
482  size_t ncols = getNumberOfColumns();
483  size_t nobs = getNumberOfRows();
484  block.setDetails( feat_idx, idx, rwFlag );
485 
486  if (idx >= nobs)
487  {
488  block.resizeBuffer( 1, 0 );
489  return services::Status();
490  }
491 
492  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
493 
494  if( !block.resizeBuffer( 1, nrows ) )
495  return services::Status(services::ErrorMemoryAllocationFailed);
496 
497  if((block.getRWFlag() & (int)readOnly))
498  {
499  NumericTableFeature &f = (*_ddict)[feat_idx];
500  char *ptr = (char *)(_ptr.get()) + _structSize * idx + _offsets[feat_idx];
501  data_feature_utils::getVectorStrideUpCast(f.indexType, data_feature_utils::getInternalNumType<T>())
502  (nrows, ptr, _structSize, block.getBlockPtr(), sizeof(T));
503  }
504  return services::Status();
505  }
506 
507  template <typename T>
508  services::Status releaseTFeature( BlockDescriptor<T>& block )
509  {
510  if (block.getRWFlag() & (int)writeOnly)
511  {
512  size_t feat_idx = block.getColumnsOffset();
513 
514  NumericTableFeature &f = (*_ddict)[feat_idx];
515 
516  char *ptr = (char *)(_ptr.get()) + _structSize * block.getRowsOffset() + _offsets[feat_idx];
517 
518  data_feature_utils::getVectorStrideDownCast(f.indexType, data_feature_utils::getInternalNumType<T>())
519  ( block.getNumberOfRows(), block.getBlockPtr(), sizeof(T), ptr, _structSize );
520  }
521  block.reset();
522  return services::Status();
523  }
524 
525  services::Status initOffsets()
526  {
527  const size_t ncols = getNumberOfColumns();
528  if( ncols > 0 )
529  {
530  _offsets = (size_t *)daal::services::daal_malloc(sizeof(size_t) * (ncols));
531  if(!_offsets)
532  return services::Status(services::ErrorMemoryAllocationFailed);
533  for( size_t i = 0; i < ncols; ++i ) _offsets[i] = 0;
534  }
535  else
536  {
537  _offsets = 0;
538  }
539  return services::Status();
540  }
541 };
542 typedef services::SharedPtr<AOSNumericTable> AOSNumericTablePtr;
544 } // namespace interface1
545 using interface1::AOSNumericTable;
546 using interface1::AOSNumericTablePtr;
547 
548 }
549 } // namespace daal
550 #endif
daal::data_management::interface1::AOSNumericTable::getArray
const void * getArray() const
Definition: aos_numeric_table.h:185
daal::data_management::interface1::AOSNumericTable::AOSNumericTable
AOSNumericTable(StructDataType *ptr, size_t ncol, size_t nrow=0)
Definition: aos_numeric_table.h:117
daal
Definition: algorithm_base_common.h:31
daal::data_management::interface1::AOSNumericTable::AOSNumericTable
AOSNumericTable(const services::SharedPtr< StructDataType > &ptr, size_t ncol, size_t nrow=0)
Definition: aos_numeric_table.h:86
daal::data_management::interface1::AOSNumericTable::getBlockOfColumnValues
services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num, ReadWriteMode rwflag, BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: aos_numeric_table.h:262
daal::data_management::interface1::AOSNumericTable::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: aos_numeric_table.h:244
daal::services::ErrorMemoryAllocationFailed
Definition: error_indexes.h:146
daal::data_management::interface1::AOSNumericTable::setFeature
services::Status setFeature(size_t idx, size_t offset, data_feature_utils::FeatureType featureType=data_feature_utils::DAAL_CONTINUOUS, size_t categoryNumber=0)
Definition: aos_numeric_table.h:208
daal::data_management::interface1::AOSNumericTable::getBlockOfColumnValues
services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num, ReadWriteMode rwflag, BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: aos_numeric_table.h:272
daal::dram
Definition: daal_defines.h:133
daal::data_management::interface1::AOSNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: aos_numeric_table.h:282
daal::services::ErrorIncorrectNumberOfFeatures
Definition: error_indexes.h:70
daal_defines.h
daal::algorithms::multivariate_outlier_detection::location
Definition: outlier_detection_multivariate_types.h:72
daal::data_management::interface1::AOSNumericTable::setArray
services::Status setArray(const services::SharedPtr< byte > &ptr, size_t obsnum=0)
Definition: aos_numeric_table.h:165
daal::services::daal_malloc
DAAL_EXPORT void * daal_malloc(size_t size, size_t alignment=DAAL_MALLOC_DEFAULT_ALIGNMENT)
daal::data_management::interface1::AOSNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: aos_numeric_table.h:278
daal::data_management::interface1::NumericTable
Class for a data management component responsible for representation of data in the numeric format...
Definition: numeric_table.h:574
daal::data_management::interface1::AOSNumericTable::getArray
void * getArray()
Definition: aos_numeric_table.h:176
daal::data_management::interface1::AOSNumericTable::setOffset
void setOffset(size_t idx, size_t offset)
Definition: aos_numeric_table.h:231
daal::data_management::interface1::AOSNumericTable
Class that provides methods to access data stored as a contiguous array of heterogeneous feature vect...
Definition: aos_numeric_table.h:53
daal::services::daal_free
DAAL_EXPORT void daal_free(void *ptr)
daal::data_management::interface1::AOSNumericTable::getArraySharedPtr
services::SharedPtr< byte > getArraySharedPtr()
Definition: aos_numeric_table.h:194
daal::data_management::interface1::AOSNumericTable::create
static services::SharedPtr< AOSNumericTable > create(StructDataType *ptr, size_t ncol, size_t nrow=0, services::Status *stat=NULL)
Definition: aos_numeric_table.h:135
daal::data_management::interface1::AOSNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: aos_numeric_table.h:253
daal::data_management::interface1::AOSNumericTable::setArray
services::Status setArray(void *const ptr, size_t obsnum=0)
Definition: aos_numeric_table.h:153
daal::data_management::interface1::AOSNumericTable::create
static services::SharedPtr< AOSNumericTable > create(const services::SharedPtr< StructDataType > &ptr, size_t ncol, size_t nrow=0, services::Status *stat=NULL)
Definition: aos_numeric_table.h:104
daal::data_management::interface1::AOSNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: aos_numeric_table.h:249
daal::data_management::interface1::AOSNumericTable::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: aos_numeric_table.h:236
daal::data_management::interface1::BlockDescriptor
Base class that manages buffer memory for read/write operations required by numeric tables...
Definition: numeric_table.h:55
daal::services::ErrorIncorrectNumberOfObservations
Definition: error_indexes.h:71
daal::data_management::interface1::AOSNumericTable::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: aos_numeric_table.h:240
daal::algorithms::implicit_als::training::offset
Definition: implicit_als_training_types.h:148
daal::data_management::interface1::Dictionary::create
static services::SharedPtr< Dictionary > create(size_t nfeat, FeaturesEqual featuresEqual=notEqual, services::Status *stat=NULL)
Definition: data_dictionary.h:183
daal::data_management::interface1::AOSNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: aos_numeric_table.h:286
daal::data_management::interface1::AOSNumericTable::getBlockOfColumnValues
services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num, ReadWriteMode rwflag, BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: aos_numeric_table.h:267
daal::MemType
MemType
Definition: daal_defines.h:131
daal::data_management::interface1::AOSNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: aos_numeric_table.h:257

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