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

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

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