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

csr_numeric_table.h
1 /* file: csr_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 compressed sparse row (CSR) numeric table.
19 //--
20 */
21 
22 #ifndef __CSR_NUMERIC_TABLE_H__
23 #define __CSR_NUMERIC_TABLE_H__
24 
25 #include "services/base.h"
26 #include "data_management/data/numeric_table.h"
27 #include "data_management/data/data_serialize.h"
28 
29 namespace daal
30 {
31 namespace data_management
32 {
33 
34 namespace interface1
35 {
44 template<typename DataType = DAAL_DATA_TYPE>
45 class DAAL_EXPORT CSRBlockDescriptor
46 {
47 public:
49  CSRBlockDescriptor();
50 
52  ~CSRBlockDescriptor() { freeValuesBuffer(); freeRowsBuffer(); }
53 
58  inline DataType *getBlockValuesPtr() const
59  {
60  if(_rawPtr)
61  {
62  return (DataType *)_rawPtr;
63  }
64  return _values_ptr.get();
65  }
66 
67  inline size_t *getBlockColumnIndicesPtr() const { return _cols_ptr.get(); }
68  inline size_t *getBlockRowIndicesPtr() const { return _rows_ptr.get(); }
69 
74  inline services::SharedPtr<DataType> getBlockValuesSharedPtr() const
75  {
76  if(_rawPtr)
77  {
78  return services::SharedPtr<DataType>(services::reinterpretPointerCast<DataType, byte>(*_pPtr), (DataType *)_rawPtr);
79  }
80  return _values_ptr;
81  }
82 
83  inline services::SharedPtr<size_t> getBlockColumnIndicesSharedPtr() const { return _cols_ptr; }
84  inline services::SharedPtr<size_t> getBlockRowIndicesSharedPtr() const { return _rows_ptr; }
85 
90  inline size_t getNumberOfColumns() const { return _ncols; }
91 
96  inline size_t getNumberOfRows() const { return _nrows; }
97 
102  inline size_t getDataSize() const
103  {
104  return ((_nrows > 0) ? _rows_ptr.get()[_nrows] - _rows_ptr.get()[0] : 0);
105  }
106 public:
107  inline void setValuesPtr( DataType *ptr, size_t nValues )
108  {
109  _values_ptr = services::SharedPtr<DataType>(ptr, services::EmptyDeleter());
110  _nvalues = nValues;
111  }
112 
113  inline void setColumnIndicesPtr( size_t *ptr, size_t nValues )
114  {
115  _cols_ptr = services::SharedPtr<size_t>(ptr, services::EmptyDeleter());
116  _nvalues = nValues;
117  }
118 
123  inline void setRowIndicesPtr( size_t *ptr, size_t nRows )
124  {
125  _rows_ptr = services::SharedPtr<size_t>(ptr, services::EmptyDeleter());
126  _nrows = nRows;
127  }
128 
129  inline void setValuesPtr( services::SharedPtr<DataType> ptr, size_t nValues )
130  {
131  _values_ptr = ptr;
132  _nvalues = nValues;
133  }
134 
135  inline void setValuesPtr( services::SharedPtr<byte> *pPtr, byte* rawPtr, size_t nValues)
136  {
137  _pPtr = pPtr;
138  _rawPtr = rawPtr;
139  _nvalues = nValues;
140  }
141 
142  inline void setColumnIndicesPtr( services::SharedPtr<size_t> ptr, size_t nValues )
143  {
144  _cols_ptr = ptr;
145  _nvalues = nValues;
146  }
147 
152  inline void setRowIndicesPtr( services::SharedPtr<size_t> ptr, size_t nRows )
153  {
154  _rows_ptr = ptr;
155  _nrows = nRows;
156  }
157 
161  inline void reset()
162  {
163  _ncols = 0;
164  _rowsOffset = 0;
165  _rwFlag = 0;
166  _pPtr = NULL;
167  _rawPtr = NULL;
168  }
169 
173  inline bool resizeValuesBuffer( size_t nValues )
174  {
175  size_t newSize = nValues * sizeof(DataType);
176  if ( newSize > _values_capacity )
177  {
178  freeValuesBuffer();
179  _values_buffer = services::SharedPtr<DataType>((DataType *)daal::services::daal_malloc(newSize), services::ServiceDeleter()) ;
180  if ( _values_buffer )
181  {
182  _values_capacity = newSize;
183  }
184  else
185  {
186  return false;
187  }
188  }
189 
190  _values_ptr = _values_buffer;
191 
192  return true;
193  }
194 
198  inline bool resizeRowsBuffer( size_t nRows )
199  {
200  _nrows = nRows;
201  size_t newSize = (nRows + 1) * sizeof(size_t);
202  if ( newSize > _rows_capacity )
203  {
204  freeRowsBuffer();
205  _rows_buffer = services::SharedPtr<size_t>((size_t *)daal::services::daal_malloc(newSize), services::ServiceDeleter()) ;
206  if ( _rows_buffer )
207  {
208  _rows_capacity = newSize;
209  }
210  else
211  {
212  return false;
213  }
214 
215  }
216 
217  _rows_ptr = _rows_buffer;
218 
219  return true;
220  }
221 
222  inline void setDetails( size_t nColumns, size_t rowIdx, int rwFlag )
223  {
224  _ncols = nColumns;
225  _rowsOffset = rowIdx;
226  _rwFlag = rwFlag;
227  }
228 
229  inline size_t getRowsOffset() const { return _rowsOffset; }
230  inline size_t getRWFlag() const { return _rwFlag; }
231 
232 protected:
236  void freeValuesBuffer()
237  {
238  if(_values_buffer)
239  {
240  _values_buffer = services::SharedPtr<DataType>();
241  }
242  _values_capacity = 0;
243  }
244 
248  void freeRowsBuffer()
249  {
250  _rows_buffer = services::SharedPtr<size_t>();
251  _rows_capacity = 0;
252  }
253 
254 private:
255  services::SharedPtr<DataType> _values_ptr;
256  services::SharedPtr<size_t> _cols_ptr;
257  services::SharedPtr<size_t> _rows_ptr;
258  size_t _nrows;
259  size_t _ncols;
260  size_t _nvalues;
261 
262  size_t _rowsOffset;
263  int _rwFlag;
264 
265  services::SharedPtr<DataType> _values_buffer; /*<! Pointer to the buffer */
266  size_t _values_capacity; /*<! Buffer size in bytes */
267 
268  services::SharedPtr<size_t> _rows_buffer; /*<! Pointer to the buffer */
269  size_t _rows_capacity; /*<! Buffer size in bytes */
270 
271  services::SharedPtr<byte> *_pPtr;
272  byte *_rawPtr;
273 };
274 
279 class CSRNumericTableIface
280 {
281 public:
286  enum CSRIndexing
287  {
288  zeroBased = 0,
289  oneBased = 1
290  };
291 
292 public:
293 
294  virtual ~CSRNumericTableIface() {}
295 
301  virtual size_t getDataSize() = 0;
312  virtual services::Status getSparseBlock(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, CSRBlockDescriptor<double> &block) = 0;
313 
324  virtual services::Status getSparseBlock(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, CSRBlockDescriptor<float> &block) = 0;
325 
336  virtual services::Status getSparseBlock(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, CSRBlockDescriptor<int> &block) = 0;
337 
342  virtual services::Status releaseSparseBlock(CSRBlockDescriptor<double> &block) = 0;
343 
348  virtual services::Status releaseSparseBlock(CSRBlockDescriptor<float> &block) = 0;
349 
354  virtual services::Status releaseSparseBlock(CSRBlockDescriptor<int> &block) = 0;
355 };
356 
361 class DAAL_EXPORT CSRNumericTable : public NumericTable, public CSRNumericTableIface
362 {
363 public:
364  DECLARE_SERIALIZABLE_TAG();
365  DECLARE_SERIALIZABLE_IMPL();
366 
367  DAAL_CAST_OPERATOR(CSRNumericTable)
372  CSRNumericTable(): NumericTable(0, 0, DictionaryIface::equal), _indexing(oneBased)
373  {
374  _layout = csrArray;
375  this->_status |= setArrays<double>( 0, 0, 0 ); //data type doesn't matter
376  }
377 
391  template<typename DataType>
392  CSRNumericTable( DataType *const ptr, size_t *colIndices = 0, size_t *rowOffsets = 0,
393  size_t nColumns = 0, size_t nRows = 0, CSRIndexing indexing = oneBased ):
394  NumericTable(nColumns, nRows, DictionaryIface::equal), _indexing(indexing)
395  {
396  _layout = csrArray;
397  this->_status |= setArrays<DataType>(ptr, colIndices, rowOffsets);
398 
399  _defaultFeature.setType<DataType>();
400  this->_status |= _ddict->setAllFeatures( _defaultFeature );
401  }
402 
403 
418  template<typename DataType>
419  static services::SharedPtr<CSRNumericTable> create(DataType *const ptr, size_t *colIndices = 0, size_t *rowOffsets = 0,
420  size_t nColumns = 0, size_t nRows = 0, CSRIndexing indexing = oneBased,
421  services::Status *stat = NULL)
422  {
423  return create<DataType>(services::SharedPtr<DataType>(ptr, services::EmptyDeleter()),
424  services::SharedPtr<size_t>(colIndices, services::EmptyDeleter()),
425  services::SharedPtr<size_t>(rowOffsets, services::EmptyDeleter()),
426  nColumns, nRows, indexing, stat);
427  }
428 
442  template<typename DataType>
443  CSRNumericTable( const services::SharedPtr<DataType>& ptr, const services::SharedPtr<size_t>& colIndices, const services::SharedPtr<size_t>& rowOffsets,
444  size_t nColumns, size_t nRows, CSRIndexing indexing = oneBased ):
445  NumericTable(nColumns, nRows, DictionaryIface::equal), _indexing(indexing)
446  {
447  _layout = csrArray;
448  this->_status |= setArrays<DataType>(ptr, colIndices, rowOffsets);
449 
450  _defaultFeature.setType<DataType>();
451  this->_status |= _ddict->setAllFeatures( _defaultFeature );
452  }
453 
468  template<typename DataType>
469  static services::SharedPtr<CSRNumericTable> create(const services::SharedPtr<DataType>& ptr,
470  const services::SharedPtr<size_t>& colIndices,
471  const services::SharedPtr<size_t>& rowOffsets,
472  size_t nColumns, size_t nRows, CSRIndexing indexing = oneBased,
473  services::Status *stat = NULL)
474  {
475  DAAL_DEFAULT_CREATE_IMPL_EX(CSRNumericTable, ptr, colIndices, rowOffsets, nColumns, nRows, indexing);
476  }
477 
478  virtual ~CSRNumericTable()
479  {
480  freeDataMemoryImpl();
481  }
482 
483  virtual services::Status resize(size_t nrows) DAAL_C11_OVERRIDE
484  {
485  return setNumberOfRowsImpl(nrows);
486  }
487 
494  template<typename DataType>
495  services::Status getArrays(DataType **ptr, size_t **colIndices, size_t **rowOffsets) const
496  {
497  if (ptr) { *ptr = (DataType*)_ptr.get(); }
498  if (colIndices) { *colIndices = _colIndices.get(); }
499  if (rowOffsets) { *rowOffsets = _rowOffsets.get(); }
500  return services::Status();
501  }
502 
509  template<typename DataType>
510  services::Status getArrays(services::SharedPtr<DataType> &ptr, services::SharedPtr<size_t> &colIndices, services::SharedPtr<size_t> &rowOffsets) const
511  {
512  if(ptr) { *ptr = _ptr; }
513  if (colIndices) { *colIndices = _colIndices; }
514  if (rowOffsets) { *rowOffsets = _rowOffsets; }
515  return services::Status();
516  }
517 
525  template<typename DataType>
526  services::Status setArrays(DataType *const ptr, size_t *colIndices, size_t *rowOffsets, CSRIndexing indexing = oneBased)
527  {
528  freeDataMemoryImpl();
529 
530  //if( ptr == 0 || colIndices == 0 || rowOffsets == 0 ) return services::Status(services::ErrorEmptyCSRNumericTable);
531 
532  _ptr = services::SharedPtr<byte>((byte*)ptr, services::EmptyDeleter());
533  _colIndices = services::SharedPtr<size_t>(colIndices, services::EmptyDeleter());
534  _rowOffsets = services::SharedPtr<size_t>(rowOffsets, services::EmptyDeleter());
535  _indexing = indexing;
536 
537  if( ptr != 0 && colIndices != 0 && rowOffsets != 0 ) { _memStatus = userAllocated; }
538  return services::Status();
539  }
540 
548  template<typename DataType>
549  services::Status setArrays(const services::SharedPtr<DataType>& ptr, const services::SharedPtr<size_t>& colIndices, const services::SharedPtr<size_t>& rowOffsets, CSRIndexing indexing = oneBased)
550  {
551  freeDataMemoryImpl();
552 
553  //if( ptr == 0 || colIndices == 0 || rowOffsets == 0 ) return services::Status(services::ErrorEmptyCSRNumericTable);
554 
555  _ptr = services::reinterpretPointerCast<byte, DataType>(ptr);
556  _colIndices = colIndices;
557  _rowOffsets = rowOffsets;
558  _indexing = indexing;
559 
560  if( ptr && colIndices && rowOffsets ) { _memStatus = userAllocated; }
561  return services::Status();
562  }
563 
564  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
565  {
566  return getTBlock<double>(vector_idx, vector_num, rwflag, block);
567  }
568  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
569  {
570  return getTBlock<float>(vector_idx, vector_num, rwflag, block);
571  }
572  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
573  {
574  return getTBlock<int>(vector_idx, vector_num, rwflag, block);
575  }
576 
577  services::Status releaseBlockOfRows(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
578  {
579  return releaseTBlock<double>(block);
580  }
581  services::Status releaseBlockOfRows(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
582  {
583  return releaseTBlock<float>(block);
584  }
585  services::Status releaseBlockOfRows(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
586  {
587  return releaseTBlock<int>(block);
588  }
589 
590  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
591  ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
592  {
593  return getTFeature<double>(feature_idx, vector_idx, value_num, rwflag, block);
594  }
595  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
596  ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
597  {
598  return getTFeature<float>(feature_idx, vector_idx, value_num, rwflag, block);
599  }
600  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
601  ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
602  {
603  return getTFeature<int>(feature_idx, vector_idx, value_num, rwflag, block);
604  }
605 
606  services::Status releaseBlockOfColumnValues(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
607  {
608  return releaseTFeature<double>(block);
609  }
610  services::Status releaseBlockOfColumnValues(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
611  {
612  return releaseTFeature<float>(block);
613  }
614  services::Status releaseBlockOfColumnValues(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
615  {
616  return releaseTFeature<int>(block);
617  }
618 
619 
620  services::Status getSparseBlock(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, CSRBlockDescriptor<double> &block) DAAL_C11_OVERRIDE
621  {
622  return getSparseTBlock<double>(vector_idx, vector_num, rwflag, block);
623  }
624  services::Status getSparseBlock(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, CSRBlockDescriptor<float> &block) DAAL_C11_OVERRIDE
625  {
626  return getSparseTBlock<float>(vector_idx, vector_num, rwflag, block);
627  }
628  services::Status getSparseBlock(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, CSRBlockDescriptor<int> &block) DAAL_C11_OVERRIDE
629  {
630  return getSparseTBlock<int>(vector_idx, vector_num, rwflag, block);
631  }
632 
633  services::Status releaseSparseBlock(CSRBlockDescriptor<double> &block) DAAL_C11_OVERRIDE
634  {
635  return releaseSparseTBlock<double>(block);
636  }
637  services::Status releaseSparseBlock(CSRBlockDescriptor<float> &block) DAAL_C11_OVERRIDE
638  {
639  return releaseSparseTBlock<float>(block);
640  }
641  services::Status releaseSparseBlock(CSRBlockDescriptor<int> &block) DAAL_C11_OVERRIDE
642  {
643  return releaseSparseTBlock<int>(block);
644  }
645 
651  services::Status allocateDataMemory(size_t dataSize, daal::MemType type = daal::dram)
652  {
653  freeDataMemoryImpl();
654 
655  size_t nrow = getNumberOfRows();
656 
657  if( nrow == 0 )
658  return services::Status(services::ErrorIncorrectNumberOfObservations);
659 
660  NumericTableFeature &f = (*_ddict)[0];
661 
662  _ptr = services::SharedPtr<byte> ( (byte*)daal::services::daal_malloc( dataSize * f.typeSize ), services::ServiceDeleter ());
663  _colIndices = services::SharedPtr<size_t>((size_t *)daal::services::daal_malloc( dataSize * sizeof(size_t) ), services::ServiceDeleter());
664  _rowOffsets = services::SharedPtr<size_t>((size_t *)daal::services::daal_malloc( (nrow + 1) * sizeof(size_t) ), services::ServiceDeleter());
665 
666  _memStatus = internallyAllocated;
667 
668  if( !_ptr || !_colIndices || !_rowOffsets )
669  {
670  freeDataMemoryImpl();
671  return services::Status(services::ErrorMemoryAllocationFailed);
672  }
673 
674  _rowOffsets.get()[0] = ((_indexing == oneBased) ? 1 : 0);
675  return services::Status();
676  }
677 
682  CSRIndexing getCSRIndexing() const
683  {
684  return _indexing;
685  }
686 
690  virtual services::Status check(const char *description, bool checkDataAllocation = true) const DAAL_C11_OVERRIDE
691  {
692  services::Status s;
693  DAAL_CHECK_STATUS(s, data_management::NumericTable::check(description, checkDataAllocation));
694 
695  if( _indexing != oneBased )
696  {
697  return services::Status(services::Error::create(services::ErrorUnsupportedCSRIndexing, services::ArgumentName, description));
698  }
699 
700  return services::Status();
701  }
702 
703 protected:
704  NumericTableFeature _defaultFeature;
705  CSRIndexing _indexing;
706 
707  services::SharedPtr<byte> _ptr;
708  services::SharedPtr<size_t> _colIndices;
709  services::SharedPtr<size_t> _rowOffsets;
710 
711  template<typename DataType>
712  CSRNumericTable(const services::SharedPtr<DataType>& ptr, const services::SharedPtr<size_t>& colIndices, const services::SharedPtr<size_t>& rowOffsets,
713  size_t nColumns, size_t nRows, CSRIndexing indexing,
714  services::Status &st):
715  NumericTable(nColumns, nRows, DictionaryIface::equal, st), _indexing(indexing)
716  {
717  _layout = csrArray;
718  st |= setArrays<DataType>(ptr, colIndices, rowOffsets);
719 
720  _defaultFeature.setType<DataType>();
721  st |= _ddict->setAllFeatures( _defaultFeature );
722  }
723 
724  services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE
725  {
726  return services::Status(services::ErrorMethodNotSupported);
727  }
728 
729  void freeDataMemoryImpl() DAAL_C11_OVERRIDE
730  {
731  _ptr = services::SharedPtr<byte>();
732  _colIndices = services::SharedPtr<size_t>();
733  _rowOffsets = services::SharedPtr<size_t>();
734 
735  _memStatus = notAllocated;
736  }
737 
738 
740  template<typename Archive, bool onDeserialize>
741  services::Status serialImpl( Archive *arch )
742  {
743  NumericTable::serialImpl<Archive, onDeserialize>( arch );
744 
745  size_t dataSize = 0;
746  if( !onDeserialize )
747  {
748  dataSize = getDataSize();
749  }
750  arch->set( dataSize );
751 
752  if( onDeserialize )
753  {
754  allocateDataMemory( dataSize );
755  }
756 
757  size_t nfeat = getNumberOfColumns();
758  size_t nobs = getNumberOfRows();
759 
760  if( nfeat > 0 )
761  {
762  NumericTableFeature &f = (*_ddict)[0];
763 
764  arch->set( (char *)_ptr.get(), dataSize * f.typeSize );
765  arch->set( _colIndices.get(), dataSize );
766  arch->set( _rowOffsets.get(), nobs + 1 );
767  }
768 
769  return services::Status();
770  }
771 
772 
773 public:
774  size_t getDataSize() DAAL_C11_OVERRIDE
775  {
776  size_t nobs = getNumberOfRows();
777  if( nobs > 0)
778  {
779  return _rowOffsets.get()[nobs] - _rowOffsets.get()[0];
780  }
781  else
782  {
783  return 0;
784  }
785  }
786 
787 protected:
788 
789  template <typename T>
790  services::Status getTBlock(size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block)
791  {
792  size_t ncols = getNumberOfColumns();
793  size_t nobs = getNumberOfRows();
794  block.setDetails( 0, idx, rwFlag );
795  size_t* rowOffsets = _rowOffsets.get();
796 
797  if (idx >= nobs)
798  {
799  block.resizeBuffer( ncols, 0 );
800  return services::Status();
801  }
802 
803  NumericTableFeature &f = (*_ddict)[0];
804 
805  T* buffer;
806  T* castingBuffer;
807  T* location = (T*)(_ptr.get() + (rowOffsets[idx] - 1) * f.typeSize);
808 
809  if( data_feature_utils::getIndexNumType<T>() == f.indexType )
810  {
811  castingBuffer = location;
812 
813  if( !block.resizeBuffer( ncols, nrows ) )
814  return services::Status(services::ErrorMemoryAllocationFailed);
815  buffer = block.getBlockPtr();
816  }
817  else
818  {
819  size_t sparseBlockSize = rowOffsets[idx + nrows] - rowOffsets[idx];
820 
821  if( !block.resizeBuffer( ncols, nrows, sparseBlockSize * sizeof(T) ) )
822  return services::Status(services::ErrorMemoryAllocationFailed);
823  buffer = block.getBlockPtr();
824 
825  castingBuffer = (T*)block.getAdditionalBufferPtr();
826 
827  data_feature_utils::getVectorUpCast(f.indexType,data_feature_utils::getInternalNumType<T>())
828  ( sparseBlockSize, location, castingBuffer );
829  }
830 
831  T *bufRowCursor = castingBuffer;
832  size_t *indicesCursor = _colIndices.get() + rowOffsets[idx] - 1;
833 
834  for( size_t i = 0; i < ncols * nrows; i++ ) { buffer[i] = (T)0; }
835 
836  for( size_t i = 0; i < nrows; i++ )
837  {
838  size_t sparseRowSize = rowOffsets[idx + i + 1] - rowOffsets[idx + i];
839 
840  for( size_t k = 0; k < sparseRowSize; k++ )
841  {
842  buffer[i * ncols + indicesCursor[k] - 1] = bufRowCursor[k];
843  }
844 
845  bufRowCursor += sparseRowSize;
846  indicesCursor += sparseRowSize;
847  }
848  return services::Status();
849  }
850 
851  template <typename T>
852  services::Status releaseTBlock( BlockDescriptor<T> &block )
853  {
854  if (!(block.getRWFlag() & (int)writeOnly))
855  block.reset();
856  return services::Status();
857  }
858 
859  template <typename T>
860  services::Status getTFeature(size_t feat_idx, size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block)
861  {
862  size_t ncols = getNumberOfColumns();
863  size_t nobs = getNumberOfRows();
864  block.setDetails( feat_idx, idx, rwFlag );
865  size_t* rowOffsets = _rowOffsets.get();
866 
867  if (idx >= nobs)
868  {
869  block.resizeBuffer( 1, 0 );
870  return services::Status();
871  }
872 
873  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
874 
875  if( !block.resizeBuffer( 1, nrows ) )
876  return services::Status(services::ErrorMemoryAllocationFailed);
877 
878  NumericTableFeature &f = (*_ddict)[0];
879 
880  char *rowCursor = (char *)_ptr.get() + (rowOffsets[idx] - 1) * f.typeSize;
881  size_t *indicesCursor = _colIndices.get() + (rowOffsets[idx] - 1);
882 
883  T* bufferPtr = block.getBlockPtr();
884 
885  for(size_t i = 0; i < nrows; i++)
886  {
887  bufferPtr[i] = (T)0;
888 
889  size_t sparseRowSize = rowOffsets[idx + i + 1] - rowOffsets[idx + i];
890 
891  for(size_t k = 0; k < sparseRowSize; k++)
892  {
893  if( indicesCursor[k] - 1 == feat_idx )
894  {
895  data_feature_utils::getVectorUpCast(f.indexType, data_feature_utils::getInternalNumType<T>())
896  ( 1, rowCursor + k * f.typeSize, bufferPtr + i );
897  }
898  }
899 
900  rowCursor += sparseRowSize * f.typeSize;
901  indicesCursor += sparseRowSize;
902  }
903  return services::Status();
904  }
905 
906  template <typename T>
907  services::Status releaseTFeature( BlockDescriptor<T> &block )
908  {
909  if(block.getRWFlag() & (int)writeOnly)
910  return services::Status();
911  block.reset();
912  return services::Status();
913  }
914 
915  template <typename T>
916  services::Status getSparseTBlock( size_t idx, size_t nrows, int rwFlag, CSRBlockDescriptor<T> &block )
917  {
918  size_t ncols = getNumberOfColumns();
919  size_t nobs = getNumberOfRows();
920  block.setDetails( ncols, idx, rwFlag );
921  size_t* rowOffsets = _rowOffsets.get();
922 
923  if (idx >= nobs)
924  {
925  block.resizeValuesBuffer( 0 );
926  return services::Status();
927  }
928 
929  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
930 
931  NumericTableFeature &f = (*_ddict)[0];
932 
933 
934  size_t nValues = rowOffsets[idx + nrows] - rowOffsets[idx];
935 
936  if( data_feature_utils::getIndexNumType<T>() == f.indexType )
937  {
938  block.setValuesPtr(&_ptr, _ptr.get() +(rowOffsets[idx] - 1) * f.typeSize, nValues);
939  }
940  else
941  {
942  if( !block.resizeValuesBuffer(nValues) ) { return services::Status(); }
943 
944  services::SharedPtr<byte> location(_ptr, _ptr.get() +(rowOffsets[idx] - 1) * f.typeSize);
945  data_feature_utils::getVectorUpCast(f.indexType, data_feature_utils::getInternalNumType<T>())
946  ( nValues, location.get(), block.getBlockValuesPtr() );
947  }
948 
949  services::SharedPtr<size_t> shiftedColumns(_colIndices, _colIndices.get() + (rowOffsets[idx] - 1));
950  block.setColumnIndicesPtr( shiftedColumns, nValues );
951 
952  if( idx == 0 )
953  {
954  block.setRowIndicesPtr( _rowOffsets, nrows );
955  }
956  else
957  {
958  if( !block.resizeRowsBuffer(nrows) ) { return services::Status(); }
959 
960  size_t *row_offsets = block.getBlockRowIndicesSharedPtr().get();
961 
962  for(size_t i = 0; i < nrows + 1; i++)
963  {
964  row_offsets[i] = rowOffsets[idx + i] - rowOffsets[idx] + 1;
965  }
966  }
967  return services::Status();
968  }
969 
970  template <typename T>
971  services::Status releaseSparseTBlock(CSRBlockDescriptor<T> &block)
972  {
973  if (block.getRWFlag() & (int)writeOnly)
974  {
975  NumericTableFeature &f = (*_ddict)[0];
976  if (f.indexType != data_feature_utils::getIndexNumType<T>())
977  {
978  size_t nrows = block.getNumberOfRows();
979  size_t idx = block.getRowsOffset();
980  size_t nValues = _rowOffsets.get()[idx + nrows] - _rowOffsets.get()[idx];
981 
982  services::SharedPtr<byte> ptr = services::reinterpretPointerCast<byte, T>(block.getBlockValuesSharedPtr());
983  services::SharedPtr<byte> location = services::SharedPtr<byte>(ptr, _ptr.get() + (_rowOffsets.get()[idx] - 1) * f.typeSize);
984 
985  data_feature_utils::getVectorDownCast(f.indexType, data_feature_utils::getInternalNumType<T>())
986  (nValues, ptr.get(), location.get());
987  }
988  }
989  block.reset();
990  return services::Status();
991  }
992 
993  virtual services::Status setNumberOfColumnsImpl(size_t ncol) DAAL_C11_OVERRIDE
994  {
995  _ddict->setNumberOfFeatures( ncol );
996  _ddict->setAllFeatures( _defaultFeature );
997  return services::Status();
998  }
999 
1000 };
1001 typedef services::SharedPtr<CSRNumericTableIface> CSRNumericTableIfacePtr;
1002 typedef services::SharedPtr<CSRNumericTable> CSRNumericTablePtr;
1004 } // namespace interface1
1005 using interface1::CSRNumericTableIface;
1006 using interface1::CSRNumericTableIfacePtr;
1007 using interface1::CSRBlockDescriptor;
1008 using interface1::CSRNumericTable;
1009 using interface1::CSRNumericTablePtr;
1010 
1011 }
1012 } // namespace daal
1013 #endif
daal::data_management::interface1::CSRBlockDescriptor::getDataSize
size_t getDataSize() const
Definition: csr_numeric_table.h:102
daal::data_management::interface1::CSRBlockDescriptor::getNumberOfRows
size_t getNumberOfRows() const
Definition: csr_numeric_table.h:96
daal::data_management::interface1::CSRBlockDescriptor::setRowIndicesPtr
void setRowIndicesPtr(size_t *ptr, size_t nRows)
Definition: csr_numeric_table.h:123
daal::data_management::interface1::CSRNumericTableIface::releaseSparseBlock
virtual services::Status releaseSparseBlock(CSRBlockDescriptor< double > &block)=0
daal::data_management::interface1::CSRNumericTable::getArrays
services::Status getArrays(DataType **ptr, size_t **colIndices, size_t **rowOffsets) const
Definition: csr_numeric_table.h:495
daal::data_management::interface1::BlockDescriptor::getBlockPtr
DataType * getBlockPtr() const
Definition: numeric_table.h:69
daal
Definition: algorithm_base_common.h:31
daal::data_management::interface1::CSRBlockDescriptor::getBlockValuesSharedPtr
services::SharedPtr< DataType > getBlockValuesSharedPtr() const
Definition: csr_numeric_table.h:74
daal::data_management::interface1::BlockDescriptor::getAdditionalBufferPtr
void * getAdditionalBufferPtr() const
Definition: numeric_table.h:224
daal::data_management::interface1::CSRNumericTableIface::getDataSize
virtual size_t getDataSize()=0
daal::data_management::interface1::CSRNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:577
daal::data_management::interface1::CSRNumericTable::getDataSize
size_t getDataSize() DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:774
daal::data_management::interface1::CSRNumericTable::setArrays
services::Status setArrays(const services::SharedPtr< DataType > &ptr, const services::SharedPtr< size_t > &colIndices, const services::SharedPtr< size_t > &rowOffsets, CSRIndexing indexing=oneBased)
Definition: csr_numeric_table.h:549
daal::data_management::interface1::CSRNumericTable::resize
virtual services::Status resize(size_t nrows) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:483
daal::data_management::interface1::CSRBlockDescriptor::getBlockValuesPtr
DataType * getBlockValuesPtr() const
Definition: csr_numeric_table.h:58
daal::data_management::interface1::CSRNumericTable::check
virtual services::Status check(const char *description, bool checkDataAllocation=true) const DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:690
daal::data_management::interface1::CSRNumericTable::getArrays
services::Status getArrays(services::SharedPtr< DataType > &ptr, services::SharedPtr< size_t > &colIndices, services::SharedPtr< size_t > &rowOffsets) const
Definition: csr_numeric_table.h:510
daal::data_management::interface1::CSRNumericTableIface::zeroBased
Definition: csr_numeric_table.h:288
daal::data_management::interface1::CSRNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:606
daal::services::ErrorMemoryAllocationFailed
Definition: error_indexes.h:146
daal::data_management::interface1::CSRNumericTable::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:568
daal::data_management::interface1::CSRBlockDescriptor
Base class that manages buffer memory for read/write operations required by CSR numeric tables...
Definition: csr_numeric_table.h:45
daal::data_management::interface1::CSRNumericTableIface::oneBased
Definition: csr_numeric_table.h:289
daal::dram
Definition: daal_defines.h:133
daal::data_management::interface1::CSRNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:610
daal::data_management::interface1::CSRNumericTable::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:572
daal::data_management::interface1::CSRNumericTable::getSparseBlock
services::Status getSparseBlock(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, CSRBlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:620
daal::data_management::interface1::CSRNumericTable::setArrays
services::Status setArrays(DataType *const ptr, size_t *colIndices, size_t *rowOffsets, CSRIndexing indexing=oneBased)
Definition: csr_numeric_table.h:526
daal::data_management::interface1::CSRBlockDescriptor::setRowIndicesPtr
void setRowIndicesPtr(services::SharedPtr< size_t > ptr, size_t nRows)
Definition: csr_numeric_table.h:152
daal::algorithms::multivariate_outlier_detection::location
Definition: outlier_detection_multivariate_types.h:72
daal::data_management::interface1::BlockDescriptor::resizeBuffer
bool resizeBuffer(size_t nColumns, size_t nRows, size_t auxMemorySize=0)
Definition: numeric_table.h:151
daal::data_management::interface1::CSRNumericTable::getBlockOfRows
services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:564
daal::data_management::interface1::CSRNumericTable::CSRNumericTable
CSRNumericTable(DataType *const ptr, size_t *colIndices=0, size_t *rowOffsets=0, size_t nColumns=0, size_t nRows=0, CSRIndexing indexing=oneBased)
Definition: csr_numeric_table.h:392
daal::services::ErrorUnsupportedCSRIndexing
Definition: error_indexes.h:117
daal::data_management::interface1::CSRNumericTable::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: csr_numeric_table.h:600
daal::services::daal_malloc
DAAL_EXPORT void * daal_malloc(size_t size, size_t alignment=DAAL_MALLOC_DEFAULT_ALIGNMENT)
daal::data_management::interface1::CSRNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:581
daal::data_management::interface1::CSRNumericTable::releaseSparseBlock
services::Status releaseSparseBlock(CSRBlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:633
daal::data_management::interface1::CSRBlockDescriptor::resizeValuesBuffer
bool resizeValuesBuffer(size_t nValues)
Definition: csr_numeric_table.h:173
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::CSRNumericTable::getSparseBlock
services::Status getSparseBlock(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, CSRBlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:628
daal::data_management::interface1::CSRNumericTable
Class that provides methods to access data stored in the CSR layout.
Definition: csr_numeric_table.h:361
daal::data_management::interface1::CSRBlockDescriptor::getNumberOfColumns
size_t getNumberOfColumns() const
Definition: csr_numeric_table.h:90
daal::data_management::interface1::CSRBlockDescriptor::resizeRowsBuffer
bool resizeRowsBuffer(size_t nRows)
Definition: csr_numeric_table.h:198
daal::data_management::interface1::CSRNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:585
daal::data_management::interface1::CSRNumericTableIface::CSRIndexing
CSRIndexing
Enumeration to specify the indexing scheme for access to data in the CSR layout.
Definition: csr_numeric_table.h:286
daal::data_management::interface1::CSRNumericTable::create
static services::SharedPtr< CSRNumericTable > create(DataType *const ptr, size_t *colIndices=0, size_t *rowOffsets=0, size_t nColumns=0, size_t nRows=0, CSRIndexing indexing=oneBased, services::Status *stat=NULL)
Definition: csr_numeric_table.h:419
daal::data_management::interface1::CSRBlockDescriptor::freeValuesBuffer
void freeValuesBuffer()
Definition: csr_numeric_table.h:236
daal::data_management::interface1::CSRBlockDescriptor::reset
void reset()
Definition: csr_numeric_table.h:161
daal::data_management::interface1::CSRNumericTable::getCSRIndexing
CSRIndexing getCSRIndexing() const
Definition: csr_numeric_table.h:682
daal::data_management::interface1::CSRNumericTable::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: csr_numeric_table.h:590
daal::data_management::interface1::CSRNumericTable::allocateDataMemory
services::Status allocateDataMemory(size_t dataSize, daal::MemType type=daal::dram)
Definition: csr_numeric_table.h:651
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::CSRNumericTableIface
Abstract class that defines the interface of CSR numeric tables.
Definition: csr_numeric_table.h:279
daal::data_management::interface1::NumericTableFeature::setType
void setType()
Definition: data_dictionary.h:91
daal::services::ErrorIncorrectNumberOfObservations
Definition: error_indexes.h:71
daal::data_management::interface1::CSRNumericTable::CSRNumericTable
CSRNumericTable(const services::SharedPtr< DataType > &ptr, const services::SharedPtr< size_t > &colIndices, const services::SharedPtr< size_t > &rowOffsets, size_t nColumns, size_t nRows, CSRIndexing indexing=oneBased)
Definition: csr_numeric_table.h:443
daal::data_management::interface1::CSRNumericTable::create
static services::SharedPtr< CSRNumericTable > create(const services::SharedPtr< DataType > &ptr, const services::SharedPtr< size_t > &colIndices, const services::SharedPtr< size_t > &rowOffsets, size_t nColumns, size_t nRows, CSRIndexing indexing=oneBased, services::Status *stat=NULL)
Definition: csr_numeric_table.h:469
daal::data_management::interface1::BlockDescriptor::setDetails
void setDetails(size_t columnIdx, size_t rowIdx, int rwFlag)
Definition: numeric_table.h:195
daal::data_management::interface1::CSRNumericTable::releaseSparseBlock
services::Status releaseSparseBlock(CSRBlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:637
daal::data_management::interface1::CSRNumericTable::getSparseBlock
services::Status getSparseBlock(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, CSRBlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:624
daal::data_management::interface1::CSRBlockDescriptor::freeRowsBuffer
void freeRowsBuffer()
Definition: csr_numeric_table.h:248
daal::data_management::interface1::NumericTableFeature
Data structure describes the Numeric Table feature.
Definition: data_dictionary.h:48
daal::services::ArgumentName
Definition: error_indexes.h:50
daal::data_management::interface1::CSRNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:614
daal::MemType
MemType
Definition: daal_defines.h:131
daal::data_management::interface1::CSRNumericTableIface::getSparseBlock
virtual services::Status getSparseBlock(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, CSRBlockDescriptor< double > &block)=0
daal::data_management::interface1::CSRNumericTable::releaseSparseBlock
services::Status releaseSparseBlock(CSRBlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:641
daal::data_management::interface1::CSRNumericTable::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: csr_numeric_table.h:595
daal::services::ErrorMethodNotSupported
Definition: error_indexes.h:69

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