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

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

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