C++ API Reference for Intel® Data Analytics Acceleration Library 2019 Update 5

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

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