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

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

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