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

soa_numeric_table.h
1 /* file: soa_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 __SOA_NUMERIC_TABLE_H__
23 #define __SOA_NUMERIC_TABLE_H__
24 
25 #include "data_management/data/numeric_table.h"
26 
27 namespace daal
28 {
29 namespace data_management
30 {
31 
32 namespace interface1
33 {
43 class DAAL_EXPORT SOANumericTable : public NumericTable
44 {
45 public:
46  DECLARE_SERIALIZABLE_TAG();
47  DECLARE_SERIALIZABLE_IMPL();
48 
56  SOANumericTable(size_t nColumns = 0, size_t nRows = 0, DictionaryIface::FeaturesEqual featuresEqual = DictionaryIface::notEqual);
57 
66  static services::SharedPtr<SOANumericTable> create(size_t nColumns = 0, size_t nRows = 0,
67  DictionaryIface::FeaturesEqual featuresEqual = DictionaryIface::notEqual,
68  services::Status *stat = NULL);
69 
77  DAAL_DEPRECATED SOANumericTable( NumericTableDictionary *ddict, size_t nRows, AllocationFlag memoryAllocationFlag = notAllocate ):
78  NumericTable(NumericTableDictionaryPtr(ddict, services::EmptyDeleter())),
79  _arraysInitialized(0), _partialMemStatus(notAllocated)
80  {
81  _layout = soa;
82  this->_status |= setNumberOfRowsImpl( nRows );
83  if( !resizePointersArray( getNumberOfColumns() ) )
84  {
85  this->_status.add(services::ErrorMemoryAllocationFailed);
86  return;
87  }
88  if( memoryAllocationFlag == doAllocate )
89  {
90  this->_status |= allocateDataMemoryImpl();
91  }
92  }
93 
101  SOANumericTable( NumericTableDictionaryPtr ddict, size_t nRows, AllocationFlag memoryAllocationFlag = notAllocate );
102 
111  static services::SharedPtr<SOANumericTable> create(NumericTableDictionaryPtr ddict, size_t nRows,
112  AllocationFlag memoryAllocationFlag = notAllocate,
113  services::Status *stat = NULL);
114 
115  virtual ~SOANumericTable()
116  {
117  freeDataMemoryImpl();
118  }
119 
126  template<typename T>
127  services::Status setArray(const services::SharedPtr<T> &ptr, size_t idx)
128  {
129  if( _partialMemStatus != notAllocated && _partialMemStatus != userAllocated )
130  {
131  return services::Status(services::ErrorIncorrectNumberOfFeatures);
132  }
133 
134  if( idx < getNumberOfColumns() && idx < _arrays.size() )
135  {
136  _ddict->setFeature<T>(idx);
137 
138  if( !_arrays[idx] && ptr )
139  {
140  _arraysInitialized++;
141  }
142 
143  if( _arrays[idx] && !ptr )
144  {
145  _arraysInitialized--;
146  }
147 
148  _arrays[idx] = services::reinterpretPointerCast<byte, T>(ptr);
149  }
150  else
151  {
152  return services::Status(services::ErrorIncorrectNumberOfFeatures);
153  }
154 
155  _partialMemStatus = userAllocated;
156 
157  if(_arraysInitialized == getNumberOfColumns())
158  {
159  _memStatus = userAllocated;
160  }
161  return services::Status();
162  }
163 
170  template<typename T>
171  services::Status setArray(T *ptr, size_t idx)
172  {
173  return setArray(services::SharedPtr<T>(ptr, services::EmptyDeleter()), idx);
174  }
175 
181  services::SharedPtr<byte> getArraySharedPtr(size_t idx)
182  {
183  if( idx < _ddict->getNumberOfFeatures() )
184  {
185  return _arrays[idx];
186  }
187  else
188  {
189  this->_status.add(services::ErrorIncorrectNumberOfFeatures);
190  return services::SharedPtr<byte>();
191  }
192  }
193 
199  void *getArray(size_t idx)
200  {
201  return getArraySharedPtr(idx).get();
202  }
203 
204  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
205  {
206  return getTBlock<double>(vector_idx, vector_num, rwflag, block);
207  }
208  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
209  {
210  return getTBlock<float>(vector_idx, vector_num, rwflag, block);
211  }
212  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
213  {
214  return getTBlock<int>(vector_idx, vector_num, rwflag, block);
215  }
216 
217  services::Status releaseBlockOfRows(BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
218  {
219  return releaseTBlock<double>(block);
220  }
221  services::Status releaseBlockOfRows(BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
222  {
223  return releaseTBlock<float>(block);
224  }
225  services::Status releaseBlockOfRows(BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
226  {
227  return releaseTBlock<int>(block);
228  }
229 
230  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
231  ReadWriteMode rwflag, BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
232  {
233  return getTFeature<double>(feature_idx, vector_idx, value_num, rwflag, block);
234  }
235  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
236  ReadWriteMode rwflag, BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
237  {
238  return getTFeature<float>(feature_idx, vector_idx, value_num, rwflag, block);
239  }
240  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
241  ReadWriteMode rwflag, BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
242  {
243  return getTFeature<int>(feature_idx, vector_idx, value_num, rwflag, block);
244  }
245 
246  services::Status releaseBlockOfColumnValues(BlockDescriptor<double>& block) DAAL_C11_OVERRIDE
247  {
248  return releaseTFeature<double>(block);
249  }
250  services::Status releaseBlockOfColumnValues(BlockDescriptor<float>& block) DAAL_C11_OVERRIDE
251  {
252  return releaseTFeature<float>(block);
253  }
254  services::Status releaseBlockOfColumnValues(BlockDescriptor<int>& block) DAAL_C11_OVERRIDE
255  {
256  return releaseTFeature<int>(block);
257  }
258 
259  DAAL_DEPRECATED_VIRTUAL services::Status setDictionary( NumericTableDictionary *ddict ) DAAL_C11_OVERRIDE
260  {
261  services::Status s;
262  DAAL_CHECK_STATUS(s, NumericTable::setDictionary( ddict ));
263 
264  size_t ncol = ddict->getNumberOfFeatures();
265 
266  if( !resizePointersArray( ncol ) )
267  {
268  return services::Status(services::ErrorMemoryAllocationFailed);
269  }
270  return s;
271  }
272 
273 protected:
274 
275  SOANumericTable( size_t nColumns, size_t nRows, DictionaryIface::FeaturesEqual featuresEqual, services::Status &st );
276 
277  SOANumericTable( NumericTableDictionaryPtr ddict, size_t nRows, AllocationFlag memoryAllocationFlag, services::Status &st );
278 
279  services::Collection<services::SharedPtr<byte> > _arrays;
280  size_t _arraysInitialized;
281  MemoryStatus _partialMemStatus;
282 
283  bool resizePointersArray(size_t nColumns)
284  {
285  if( _arrays.size() >= nColumns )
286  {
287  size_t counter = 0;
288  for(size_t i = 0; i < nColumns; i++)
289  {
290  counter += (_arrays[i] != 0);
291  }
292  _arraysInitialized = counter;
293 
294  if( _arraysInitialized == nColumns )
295  {
296  _memStatus = _partialMemStatus;
297  }
298  else
299  {
300  _memStatus = notAllocated;
301  }
302 
303  return true;
304  }
305  _arrays.resize(nColumns);
306  _memStatus = notAllocated;
307 
308  return true;
309  }
310 
311  services::Status setNumberOfColumnsImpl(size_t ncol) DAAL_C11_OVERRIDE
312  {
313  services::Status s;
314  DAAL_CHECK_STATUS(s, NumericTable::setNumberOfColumnsImpl(ncol));
315 
316  if( !resizePointersArray( ncol ) )
317  {
318  return services::Status(services::ErrorMemoryAllocationFailed);
319  }
320  return s;
321  }
322 
323  services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE
324  {
325  freeDataMemoryImpl();
326 
327  size_t ncol = _ddict->getNumberOfFeatures();
328  size_t nrows = getNumberOfRows();
329 
330  if( ncol * nrows == 0 )
331  {
332  if( nrows == 0 )
333  {
334  return services::Status(services::ErrorIncorrectNumberOfObservations);
335  }
336  else
337  {
338  return services::Status(services::ErrorIncorrectNumberOfFeatures);
339  }
340  }
341 
342  for(size_t i = 0; i < ncol; i++)
343  {
344  NumericTableFeature f = (*_ddict)[i];
345  if( f.typeSize != 0 )
346  {
347  _arrays[i] = services::SharedPtr<byte>((byte *)daal::services::daal_malloc( f.typeSize * nrows ), services::ServiceDeleter());
348  _arraysInitialized++;
349  }
350  if( !_arrays[i] )
351  {
352  freeDataMemoryImpl();
353  return services::Status(services::ErrorMemoryAllocationFailed);
354  }
355  }
356 
357  if(_arraysInitialized > 0)
358  {
359  _partialMemStatus = internallyAllocated;
360  }
361 
362  if(_arraysInitialized == ncol)
363  {
364  _memStatus = internallyAllocated;
365  }
366  return services::Status();
367  }
368 
369  void freeDataMemoryImpl() DAAL_C11_OVERRIDE
370  {
371  _arrays.clear();
372  _arrays.resize(_ddict->getNumberOfFeatures());
373  _arraysInitialized = 0;
374 
375  _partialMemStatus = notAllocated;
376  _memStatus = notAllocated;
377  }
378 
379  template<typename Archive, bool onDeserialize>
380  services::Status serialImpl( Archive *arch )
381  {
382  NumericTable::serialImpl<Archive, onDeserialize>( arch );
383 
384  if( onDeserialize )
385  {
386  allocateDataMemoryImpl();
387  }
388 
389  size_t ncol = _ddict->getNumberOfFeatures();
390  size_t nrows = getNumberOfRows();
391 
392  for(size_t i = 0; i < ncol; i++)
393  {
394  NumericTableFeature f = (*_ddict)[i];
395  void *ptr = getArraySharedPtr(i).get();
396 
397  arch->set( (char *)ptr, nrows * f.typeSize );
398  }
399 
400  return services::Status();
401  }
402 
403 private:
404 
405  template <typename T>
406  services::Status getTBlock( size_t idx, size_t nrows, ReadWriteMode rwFlag, BlockDescriptor<T>& block )
407  {
408  size_t ncols = getNumberOfColumns();
409  size_t nobs = getNumberOfRows();
410  block.setDetails( 0, idx, rwFlag );
411 
412  if (idx >= nobs)
413  {
414  block.resizeBuffer( ncols, 0 );
415  return services::Status();
416  }
417 
418  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
419 
420  if( !block.resizeBuffer( ncols, nrows ) )
421  {
422  return services::Status(services::ErrorMemoryAllocationFailed);
423  }
424 
425  if( !(block.getRWFlag() & (int)readOnly) ) return services::Status();
426 
427  T lbuf[32];
428 
429  size_t di = 32;
430 
431  T *buffer = block.getBlockPtr();
432 
433  for( size_t i = 0 ; i < nrows ; i += di )
434  {
435  if( i + di > nrows ) { di = nrows - i; }
436 
437  for( size_t j = 0 ; j < ncols ; j++ )
438  {
439  NumericTableFeature &f = (*_ddict)[j];
440 
441  char *ptr = (char *)_arrays[j].get() + (idx + i) * f.typeSize;
442 
443  data_feature_utils::getVectorUpCast(f.indexType, data_feature_utils::getInternalNumType<T>())
444  ( di, ptr, lbuf );
445 
446  for( size_t ii = 0 ; ii < di; ii++ )
447  {
448  buffer[ (i + ii)*ncols + j ] = lbuf[ii];
449  }
450  }
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  size_t nrows = block.getNumberOfRows();
462  size_t idx = block.getRowsOffset();
463  T lbuf[32];
464 
465  size_t di = 32;
466 
467  T *blockPtr = block.getBlockPtr();
468 
469  for( size_t i = 0 ; i < nrows ; i += di )
470  {
471  if( i + di > nrows ) { di = nrows - i; }
472 
473  for( size_t j = 0 ; j < ncols ; j++ )
474  {
475  NumericTableFeature &f = (*_ddict)[j];
476 
477  char *ptr = (char *)_arrays[j].get() + (idx + i) * f.typeSize;
478 
479  for( size_t ii = 0 ; ii < di; ii++ )
480  {
481  lbuf[ii] = blockPtr[ (i + ii) * ncols + j ];
482  }
483 
484  data_feature_utils::getVectorDownCast(f.indexType, data_feature_utils::getInternalNumType<T>())
485  ( di, lbuf, ptr );
486  }
487  }
488  }
489  block.reset();
490  return services::Status();
491  }
492 
493  template <typename T>
494  services::Status getTFeature( size_t feat_idx, size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T>& block )
495  {
496  size_t ncols = getNumberOfColumns();
497  size_t nobs = getNumberOfRows();
498  block.setDetails( feat_idx, idx, rwFlag );
499 
500  if (idx >= nobs)
501  {
502  block.resizeBuffer( 1, 0 );
503  return services::Status();
504  }
505 
506  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
507 
508  NumericTableFeature &f = (*_ddict)[feat_idx];
509 
510  if( data_feature_utils::getIndexNumType<T>() == f.indexType )
511  {
512  block.setPtr(&(_arrays[feat_idx]), _arrays[feat_idx].get() + idx * f.typeSize , 1, nrows );
513  }
514  else
515  {
516  byte *location = _arrays[feat_idx].get() + idx * f.typeSize;
517 
518  if( !block.resizeBuffer( 1, nrows ) )
519  {
520  return services::Status(services::ErrorMemoryAllocationFailed);
521  }
522 
523  if( !(block.getRWFlag() & (int)readOnly) ) return services::Status();
524 
525  data_feature_utils::getVectorUpCast(f.indexType, data_feature_utils::getInternalNumType<T>())
526  ( nrows, location, block.getBlockPtr() );
527  }
528  return services::Status();
529  }
530 
531  template <typename T>
532  services::Status releaseTFeature( BlockDescriptor<T>& block )
533  {
534  if (block.getRWFlag() & (int)writeOnly)
535  {
536  size_t feat_idx = block.getColumnsOffset();
537 
538  NumericTableFeature &f = (*_ddict)[feat_idx];
539 
540  if( data_feature_utils::getIndexNumType<T>() != f.indexType )
541  {
542  char *ptr = (char *)_arrays[feat_idx].get() + block.getRowsOffset() * f.typeSize;
543 
544  data_feature_utils::getVectorDownCast(f.indexType, data_feature_utils::getInternalNumType<T>())
545  ( block.getNumberOfRows(), block.getBlockPtr(), ptr );
546  }
547  }
548  block.reset();
549  return services::Status();
550  }
551 };
552 typedef services::SharedPtr<SOANumericTable> SOANumericTablePtr;
554 } // namespace interface1
555 using interface1::SOANumericTable;
556 using interface1::SOANumericTablePtr;
557 
558 }
559 } // namespace daal
560 #endif
daal::data_management::interface1::NumericTableIface::AllocationFlag
AllocationFlag
Enumeration to specify whether the Numeric Table must allocate memory.
Definition: numeric_table.h:283
daal::data_management::interface1::SOANumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: soa_numeric_table.h:246
daal
Definition: algorithm_base_common.h:31
daal::data_management::interface1::SOANumericTable::setArray
services::Status setArray(T *ptr, size_t idx)
Definition: soa_numeric_table.h:171
daal::data_management::interface1::SOANumericTable
Class that provides methods to access data stored as a structure of arrays, where each (contiguous) a...
Definition: soa_numeric_table.h:43
daal::data_management::interface1::SOANumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: soa_numeric_table.h:250
daal::services::ErrorMemoryAllocationFailed
Definition: error_indexes.h:146
daal::data_management::interface1::SOANumericTable::getArray
void * getArray(size_t idx)
Definition: soa_numeric_table.h:199
daal::dram
Definition: daal_defines.h:133
daal::data_management::interface1::SOANumericTable::SOANumericTable
DAAL_DEPRECATED SOANumericTable(NumericTableDictionary *ddict, size_t nRows, AllocationFlag memoryAllocationFlag=notAllocate)
Definition: soa_numeric_table.h:77
daal::data_management::interface1::SOANumericTable::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: soa_numeric_table.h:204
daal::data_management::interface1::SOANumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: soa_numeric_table.h:225
daal::services::ErrorIncorrectNumberOfFeatures
Definition: error_indexes.h:70
daal::algorithms::multivariate_outlier_detection::location
Definition: outlier_detection_multivariate_types.h:72
daal::data_management::interface1::SOANumericTable::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: soa_numeric_table.h:235
daal::data_management::interface1::SOANumericTable::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: soa_numeric_table.h:212
daal::services::daal_malloc
DAAL_EXPORT void * daal_malloc(size_t size, size_t alignment=DAAL_MALLOC_DEFAULT_ALIGNMENT)
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::SOANumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: soa_numeric_table.h:217
daal::data_management::interface1::SOANumericTable::setArray
services::Status setArray(const services::SharedPtr< T > &ptr, size_t idx)
Definition: soa_numeric_table.h:127
daal::data_management::interface1::SOANumericTable::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: soa_numeric_table.h:230
daal::data_management::interface1::SOANumericTable::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: soa_numeric_table.h:208
daal::data_management::interface1::SOANumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: soa_numeric_table.h:254
daal::data_management::interface1::SOANumericTable::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: soa_numeric_table.h:240
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::data_management::interface1::DictionaryIface::FeaturesEqual
FeaturesEqual
Enumeration to specify whether the Data Dictionary contains equal features.
Definition: data_dictionary.h:145
daal::services::ErrorIncorrectNumberOfObservations
Definition: error_indexes.h:71
daal::data_management::interface1::SOANumericTable::getArraySharedPtr
services::SharedPtr< byte > getArraySharedPtr(size_t idx)
Definition: soa_numeric_table.h:181
daal::data_management::interface1::SOANumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: soa_numeric_table.h:221
daal::data_management::interface1::NumericTable::setDictionary
virtual DAAL_DEPRECATED_VIRTUAL services::Status setDictionary(NumericTableDictionary *ddict) DAAL_C11_OVERRIDE
Definition: numeric_table.h:624
daal::MemType
MemType
Definition: daal_defines.h:131
daal::data_management::interface1::SOANumericTable::setDictionary
DAAL_DEPRECATED_VIRTUAL services::Status setDictionary(NumericTableDictionary *ddict) DAAL_C11_OVERRIDE
Definition: soa_numeric_table.h:259
daal::data_management::interface1::Dictionary
Class that represents a dictionary of a data set and provides methods to work with the data dictionar...
Definition: data_dictionary.h:158

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