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

csr_numeric_table.h
1 /* file: csr_numeric_table.h */
2 /*******************************************************************************
3 * Copyright 2014-2020 Intel Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *******************************************************************************/
17 
18 /*
19 //++
20 // Implementation of a compressed sparse row (CSR) numeric table.
21 //--
22 */
23 
24 #ifndef __CSR_NUMERIC_TABLE_H__
25 #define __CSR_NUMERIC_TABLE_H__
26 
27 #include "services/base.h"
28 #include "data_management/data/numeric_table.h"
29 #include "data_management/data/data_serialize.h"
30 #include "data_management/data/internal/conversion.h"
31 
32 namespace daal
33 {
34 namespace data_management
35 {
36 
37 namespace interface1
38 {
47 template<typename DataType = DAAL_DATA_TYPE>
48 class DAAL_EXPORT CSRBlockDescriptor
49 {
50 public:
52  CSRBlockDescriptor();
53 
55  ~CSRBlockDescriptor() { freeValuesBuffer(); freeRowsBuffer(); }
56 
61  inline DataType *getBlockValuesPtr() const
62  {
63  if(_rawPtr)
64  {
65  return (DataType *)_rawPtr;
66  }
67  return _values_ptr.get();
68  }
69 
70  inline size_t *getBlockColumnIndicesPtr() const { return _cols_ptr.get(); }
71  inline size_t *getBlockRowIndicesPtr() const { return _rows_ptr.get(); }
72 
77  inline services::SharedPtr<DataType> getBlockValuesSharedPtr() const
78  {
79  if(_rawPtr)
80  {
81  return services::SharedPtr<DataType>(services::reinterpretPointerCast<DataType, byte>(*_pPtr), (DataType *)_rawPtr);
82  }
83  return _values_ptr;
84  }
85 
86  inline services::SharedPtr<size_t> getBlockColumnIndicesSharedPtr() const { return _cols_ptr; }
87  inline services::SharedPtr<size_t> getBlockRowIndicesSharedPtr() const { return _rows_ptr; }
88 
93  inline size_t getNumberOfColumns() const { return _ncols; }
94 
99  inline size_t getNumberOfRows() const { return _nrows; }
100 
105  inline size_t getDataSize() const
106  {
107  return ((_nrows > 0) ? _rows_ptr.get()[_nrows] - _rows_ptr.get()[0] : 0);
108  }
109 public:
110  inline void setValuesPtr( DataType *ptr, size_t nValues )
111  {
112  _values_ptr = services::SharedPtr<DataType>(ptr, services::EmptyDeleter());
113  _nvalues = nValues;
114  }
115 
116  inline void setColumnIndicesPtr( size_t *ptr, size_t nValues )
117  {
118  _cols_ptr = services::SharedPtr<size_t>(ptr, services::EmptyDeleter());
119  _nvalues = nValues;
120  }
121 
126  inline void setRowIndicesPtr( size_t *ptr, size_t nRows )
127  {
128  _rows_ptr = services::SharedPtr<size_t>(ptr, services::EmptyDeleter());
129  _nrows = nRows;
130  }
131 
132  inline void setValuesPtr( services::SharedPtr<DataType> ptr, size_t nValues )
133  {
134  _values_ptr = ptr;
135  _nvalues = nValues;
136  }
137 
138  inline void setValuesPtr( services::SharedPtr<byte> *pPtr, byte* rawPtr, size_t nValues)
139  {
140  _pPtr = pPtr;
141  _rawPtr = rawPtr;
142  _nvalues = nValues;
143  }
144 
145  inline void setColumnIndicesPtr( services::SharedPtr<size_t> ptr, size_t nValues )
146  {
147  _cols_ptr = ptr;
148  _nvalues = nValues;
149  }
150 
155  inline void setRowIndicesPtr( services::SharedPtr<size_t> ptr, size_t nRows )
156  {
157  _rows_ptr = ptr;
158  _nrows = nRows;
159  }
160 
164  inline void reset()
165  {
166  _ncols = 0;
167  _rowsOffset = 0;
168  _rwFlag = 0;
169  _pPtr = NULL;
170  _rawPtr = NULL;
171  }
172 
176  inline bool resizeValuesBuffer( size_t nValues )
177  {
178  size_t newSize = nValues * sizeof(DataType);
179  if ( newSize > _values_capacity )
180  {
181  freeValuesBuffer();
182  _values_buffer = services::SharedPtr<DataType>((DataType *)daal::services::daal_malloc(newSize), services::ServiceDeleter()) ;
183  if ( _values_buffer )
184  {
185  _values_capacity = newSize;
186  }
187  else
188  {
189  return false;
190  }
191  }
192 
193  _values_ptr = _values_buffer;
194 
195  return true;
196  }
197 
201  inline bool resizeRowsBuffer( size_t nRows )
202  {
203  _nrows = nRows;
204  size_t newSize = (nRows + 1) * sizeof(size_t);
205  if ( newSize > _rows_capacity )
206  {
207  freeRowsBuffer();
208  _rows_buffer = services::SharedPtr<size_t>((size_t *)daal::services::daal_malloc(newSize), services::ServiceDeleter()) ;
209  if ( _rows_buffer )
210  {
211  _rows_capacity = newSize;
212  }
213  else
214  {
215  return false;
216  }
217 
218  }
219 
220  _rows_ptr = _rows_buffer;
221 
222  return true;
223  }
224 
225  inline void setDetails( size_t nColumns, size_t rowIdx, int rwFlag )
226  {
227  _ncols = nColumns;
228  _rowsOffset = rowIdx;
229  _rwFlag = rwFlag;
230  }
231 
232  inline size_t getRowsOffset() const { return _rowsOffset; }
233  inline size_t getRWFlag() const { return _rwFlag; }
234 
235 protected:
239  void freeValuesBuffer()
240  {
241  if(_values_buffer)
242  {
243  _values_buffer = services::SharedPtr<DataType>();
244  }
245  _values_capacity = 0;
246  }
247 
251  void freeRowsBuffer()
252  {
253  _rows_buffer = services::SharedPtr<size_t>();
254  _rows_capacity = 0;
255  }
256 
257 private:
258  services::SharedPtr<DataType> _values_ptr;
259  services::SharedPtr<size_t> _cols_ptr;
260  services::SharedPtr<size_t> _rows_ptr;
261  size_t _nrows;
262  size_t _ncols;
263  size_t _nvalues;
264 
265  size_t _rowsOffset;
266  int _rwFlag;
267 
268  services::SharedPtr<DataType> _values_buffer; /*<! Pointer to the buffer */
269  size_t _values_capacity; /*<! Buffer size in bytes */
270 
271  services::SharedPtr<size_t> _rows_buffer; /*<! Pointer to the buffer */
272  size_t _rows_capacity; /*<! Buffer size in bytes */
273 
274  services::SharedPtr<byte> *_pPtr;
275  byte *_rawPtr;
276 };
277 
282 class CSRNumericTableIface
283 {
284 public:
289  enum CSRIndexing
290  {
291  zeroBased = 0,
292  oneBased = 1
293  };
294 
295 public:
296 
297  virtual ~CSRNumericTableIface() {}
298 
304  virtual size_t getDataSize() = 0;
315  virtual services::Status getSparseBlock(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, CSRBlockDescriptor<double> &block) = 0;
316 
327  virtual services::Status getSparseBlock(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, CSRBlockDescriptor<float> &block) = 0;
328 
339  virtual services::Status getSparseBlock(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, CSRBlockDescriptor<int> &block) = 0;
340 
345  virtual services::Status releaseSparseBlock(CSRBlockDescriptor<double> &block) = 0;
346 
351  virtual services::Status releaseSparseBlock(CSRBlockDescriptor<float> &block) = 0;
352 
357  virtual services::Status releaseSparseBlock(CSRBlockDescriptor<int> &block) = 0;
358 };
359 
364 class DAAL_EXPORT CSRNumericTable : public NumericTable, public CSRNumericTableIface
365 {
366 public:
367  DECLARE_SERIALIZABLE_TAG();
368  DECLARE_SERIALIZABLE_IMPL();
369 
370  DAAL_CAST_OPERATOR(CSRNumericTable)
375  CSRNumericTable(): NumericTable(0, 0, DictionaryIface::equal), _indexing(oneBased)
376  {
377  _layout = csrArray;
378  this->_status |= setArrays<double>( 0, 0, 0 ); //data type doesn't matter
379  }
380 
394  template<typename DataType>
395  CSRNumericTable( DataType *const ptr, size_t *colIndices = 0, size_t *rowOffsets = 0,
396  size_t nColumns = 0, size_t nRows = 0, CSRIndexing indexing = oneBased ):
397  NumericTable(nColumns, nRows, DictionaryIface::equal), _indexing(indexing)
398  {
399  _layout = csrArray;
400  this->_status |= setArrays<DataType>(ptr, colIndices, rowOffsets);
401 
402  _defaultFeature.setType<DataType>();
403  this->_status |= _ddict->setAllFeatures( _defaultFeature );
404  }
405 
406 
421  template<typename DataType>
422  static services::SharedPtr<CSRNumericTable> create(DataType *const ptr, size_t *colIndices = 0, size_t *rowOffsets = 0,
423  size_t nColumns = 0, size_t nRows = 0, CSRIndexing indexing = oneBased,
424  services::Status *stat = NULL)
425  {
426  return create<DataType>(services::SharedPtr<DataType>(ptr, services::EmptyDeleter()),
427  services::SharedPtr<size_t>(colIndices, services::EmptyDeleter()),
428  services::SharedPtr<size_t>(rowOffsets, services::EmptyDeleter()),
429  nColumns, nRows, indexing, stat);
430  }
431 
445  template<typename DataType>
446  CSRNumericTable( const services::SharedPtr<DataType>& ptr, const services::SharedPtr<size_t>& colIndices, const services::SharedPtr<size_t>& rowOffsets,
447  size_t nColumns, size_t nRows, CSRIndexing indexing = oneBased ):
448  NumericTable(nColumns, nRows, DictionaryIface::equal), _indexing(indexing)
449  {
450  _layout = csrArray;
451  this->_status |= setArrays<DataType>(ptr, colIndices, rowOffsets);
452 
453  _defaultFeature.setType<DataType>();
454  this->_status |= _ddict->setAllFeatures( _defaultFeature );
455  }
456 
471  template<typename DataType>
472  static services::SharedPtr<CSRNumericTable> create(const services::SharedPtr<DataType>& ptr,
473  const services::SharedPtr<size_t>& colIndices,
474  const services::SharedPtr<size_t>& rowOffsets,
475  size_t nColumns, size_t nRows, CSRIndexing indexing = oneBased,
476  services::Status *stat = NULL)
477  {
478  DAAL_DEFAULT_CREATE_IMPL_EX(CSRNumericTable, ptr, colIndices, rowOffsets, nColumns, nRows, indexing);
479  }
480 
481  virtual ~CSRNumericTable()
482  {
483  freeDataMemoryImpl();
484  }
485 
486  virtual services::Status resize(size_t nrows) DAAL_C11_OVERRIDE
487  {
488  return setNumberOfRowsImpl(nrows);
489  }
490 
497  template<typename DataType>
498  services::Status getArrays(DataType **ptr, size_t **colIndices, size_t **rowOffsets) const
499  {
500  if (ptr) { *ptr = (DataType*)_ptr.get(); }
501  if (colIndices) { *colIndices = _colIndices.get(); }
502  if (rowOffsets) { *rowOffsets = _rowOffsets.get(); }
503  return services::Status();
504  }
505 
512  template<typename DataType>
513  services::Status getArrays(services::SharedPtr<DataType> &ptr, services::SharedPtr<size_t> &colIndices, services::SharedPtr<size_t> &rowOffsets) const
514  {
515  if(ptr) { *ptr = _ptr; }
516  if (colIndices) { *colIndices = _colIndices; }
517  if (rowOffsets) { *rowOffsets = _rowOffsets; }
518  return services::Status();
519  }
520 
528  template<typename DataType>
529  services::Status setArrays(DataType *const ptr, size_t *colIndices, size_t *rowOffsets, CSRIndexing indexing = oneBased)
530  {
531  freeDataMemoryImpl();
532 
533  //if( ptr == 0 || colIndices == 0 || rowOffsets == 0 ) return services::Status(services::ErrorEmptyCSRNumericTable);
534 
535  _ptr = services::SharedPtr<byte>((byte*)ptr, services::EmptyDeleter());
536  _colIndices = services::SharedPtr<size_t>(colIndices, services::EmptyDeleter());
537  _rowOffsets = services::SharedPtr<size_t>(rowOffsets, services::EmptyDeleter());
538  _indexing = indexing;
539 
540  if( ptr != 0 && colIndices != 0 && rowOffsets != 0 ) { _memStatus = userAllocated; }
541  return services::Status();
542  }
543 
551  template<typename DataType>
552  services::Status setArrays(const services::SharedPtr<DataType>& ptr, const services::SharedPtr<size_t>& colIndices, const services::SharedPtr<size_t>& rowOffsets, CSRIndexing indexing = oneBased)
553  {
554  freeDataMemoryImpl();
555 
556  //if( ptr == 0 || colIndices == 0 || rowOffsets == 0 ) return services::Status(services::ErrorEmptyCSRNumericTable);
557 
558  _ptr = services::reinterpretPointerCast<byte, DataType>(ptr);
559  _colIndices = colIndices;
560  _rowOffsets = rowOffsets;
561  _indexing = indexing;
562 
563  if( ptr && colIndices && rowOffsets ) { _memStatus = userAllocated; }
564  return services::Status();
565  }
566 
567  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
568  {
569  return getTBlock<double>(vector_idx, vector_num, rwflag, block);
570  }
571  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
572  {
573  return getTBlock<float>(vector_idx, vector_num, rwflag, block);
574  }
575  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
576  {
577  return getTBlock<int>(vector_idx, vector_num, rwflag, block);
578  }
579 
580  services::Status releaseBlockOfRows(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
581  {
582  return releaseTBlock<double>(block);
583  }
584  services::Status releaseBlockOfRows(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
585  {
586  return releaseTBlock<float>(block);
587  }
588  services::Status releaseBlockOfRows(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
589  {
590  return releaseTBlock<int>(block);
591  }
592 
593  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
594  ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
595  {
596  return getTFeature<double>(feature_idx, vector_idx, value_num, rwflag, block);
597  }
598  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
599  ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
600  {
601  return getTFeature<float>(feature_idx, vector_idx, value_num, rwflag, block);
602  }
603  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
604  ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
605  {
606  return getTFeature<int>(feature_idx, vector_idx, value_num, rwflag, block);
607  }
608 
609  services::Status releaseBlockOfColumnValues(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
610  {
611  return releaseTFeature<double>(block);
612  }
613  services::Status releaseBlockOfColumnValues(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
614  {
615  return releaseTFeature<float>(block);
616  }
617  services::Status releaseBlockOfColumnValues(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
618  {
619  return releaseTFeature<int>(block);
620  }
621 
622 
623  services::Status getSparseBlock(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, CSRBlockDescriptor<double> &block) DAAL_C11_OVERRIDE
624  {
625  return getSparseTBlock<double>(vector_idx, vector_num, rwflag, block);
626  }
627  services::Status getSparseBlock(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, CSRBlockDescriptor<float> &block) DAAL_C11_OVERRIDE
628  {
629  return getSparseTBlock<float>(vector_idx, vector_num, rwflag, block);
630  }
631  services::Status getSparseBlock(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, CSRBlockDescriptor<int> &block) DAAL_C11_OVERRIDE
632  {
633  return getSparseTBlock<int>(vector_idx, vector_num, rwflag, block);
634  }
635 
636  services::Status releaseSparseBlock(CSRBlockDescriptor<double> &block) DAAL_C11_OVERRIDE
637  {
638  return releaseSparseTBlock<double>(block);
639  }
640  services::Status releaseSparseBlock(CSRBlockDescriptor<float> &block) DAAL_C11_OVERRIDE
641  {
642  return releaseSparseTBlock<float>(block);
643  }
644  services::Status releaseSparseBlock(CSRBlockDescriptor<int> &block) DAAL_C11_OVERRIDE
645  {
646  return releaseSparseTBlock<int>(block);
647  }
648 
654  services::Status allocateDataMemory(size_t dataSize, daal::MemType type = daal::dram)
655  {
656  freeDataMemoryImpl();
657 
658  size_t nrow = getNumberOfRows();
659 
660  if( nrow == 0 )
661  return services::Status(services::ErrorIncorrectNumberOfObservations);
662 
663  NumericTableFeature &f = (*_ddict)[0];
664 
665  _ptr = services::SharedPtr<byte> ( (byte*)daal::services::daal_malloc( dataSize * f.typeSize ), services::ServiceDeleter ());
666  _colIndices = services::SharedPtr<size_t>((size_t *)daal::services::daal_malloc( dataSize * sizeof(size_t) ), services::ServiceDeleter());
667  _rowOffsets = services::SharedPtr<size_t>((size_t *)daal::services::daal_malloc( (nrow + 1) * sizeof(size_t) ), services::ServiceDeleter());
668 
669  _memStatus = internallyAllocated;
670 
671  if( !_ptr || !_colIndices || !_rowOffsets )
672  {
673  freeDataMemoryImpl();
674  return services::Status(services::ErrorMemoryAllocationFailed);
675  }
676 
677  _rowOffsets.get()[0] = ((_indexing == oneBased) ? 1 : 0);
678  return services::Status();
679  }
680 
685  CSRIndexing getCSRIndexing() const
686  {
687  return _indexing;
688  }
689 
693  virtual services::Status check(const char *description, bool checkDataAllocation = true) const DAAL_C11_OVERRIDE
694  {
695  services::Status s;
696  DAAL_CHECK_STATUS(s, data_management::NumericTable::check(description, checkDataAllocation));
697 
698  if( _indexing != oneBased )
699  {
700  return services::Status(services::Error::create(services::ErrorUnsupportedCSRIndexing, services::ArgumentName, description));
701  }
702 
703  return services::Status();
704  }
705 
706 protected:
707  NumericTableFeature _defaultFeature;
708  CSRIndexing _indexing;
709 
710  services::SharedPtr<byte> _ptr;
711  services::SharedPtr<size_t> _colIndices;
712  services::SharedPtr<size_t> _rowOffsets;
713 
714  template<typename DataType>
715  CSRNumericTable(const services::SharedPtr<DataType>& ptr, const services::SharedPtr<size_t>& colIndices, const services::SharedPtr<size_t>& rowOffsets,
716  size_t nColumns, size_t nRows, CSRIndexing indexing,
717  services::Status &st):
718  NumericTable(nColumns, nRows, DictionaryIface::equal, st), _indexing(indexing)
719  {
720  _layout = csrArray;
721  st |= setArrays<DataType>(ptr, colIndices, rowOffsets);
722 
723  _defaultFeature.setType<DataType>();
724  st |= _ddict->setAllFeatures( _defaultFeature );
725  }
726 
727  services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE
728  {
729  return services::Status(services::ErrorMethodNotSupported);
730  }
731 
732  void freeDataMemoryImpl() DAAL_C11_OVERRIDE
733  {
734  _ptr = services::SharedPtr<byte>();
735  _colIndices = services::SharedPtr<size_t>();
736  _rowOffsets = services::SharedPtr<size_t>();
737 
738  _memStatus = notAllocated;
739  }
740 
741 
743  template<typename Archive, bool onDeserialize>
744  services::Status serialImpl( Archive *arch )
745  {
746  NumericTable::serialImpl<Archive, onDeserialize>( arch );
747 
748  size_t dataSize = 0;
749  if( !onDeserialize )
750  {
751  dataSize = getDataSize();
752  }
753  arch->set( dataSize );
754 
755  if( onDeserialize )
756  {
757  allocateDataMemory( dataSize );
758  }
759 
760  size_t nfeat = getNumberOfColumns();
761  size_t nobs = getNumberOfRows();
762 
763  if( nfeat > 0 )
764  {
765  NumericTableFeature &f = (*_ddict)[0];
766 
767  arch->set( (char *)_ptr.get(), dataSize * f.typeSize );
768  arch->set( _colIndices.get(), dataSize );
769  arch->set( _rowOffsets.get(), nobs + 1 );
770  }
771 
772  return services::Status();
773  }
774 
775 
776 public:
777  size_t getDataSize() DAAL_C11_OVERRIDE
778  {
779  size_t nobs = getNumberOfRows();
780  if( nobs > 0)
781  {
782  return _rowOffsets.get()[nobs] - _rowOffsets.get()[0];
783  }
784  else
785  {
786  return 0;
787  }
788  }
789 
790 protected:
791 
792  template <typename T>
793  services::Status getTBlock(size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block)
794  {
795  size_t ncols = getNumberOfColumns();
796  size_t nobs = getNumberOfRows();
797  block.setDetails( 0, idx, rwFlag );
798  size_t* rowOffsets = _rowOffsets.get();
799 
800  if (idx >= nobs)
801  {
802  block.resizeBuffer( ncols, 0 );
803  return services::Status();
804  }
805 
806  NumericTableFeature &f = (*_ddict)[0];
807 
808  T* buffer;
809  T* castingBuffer;
810  T* location = (T*)(_ptr.get() + (rowOffsets[idx] - 1) * f.typeSize);
811 
812  if( features::internal::getIndexNumType<T>() == f.indexType )
813  {
814  castingBuffer = location;
815 
816  if( !block.resizeBuffer( ncols, nrows ) )
817  return services::Status(services::ErrorMemoryAllocationFailed);
818  buffer = block.getBlockPtr();
819  }
820  else
821  {
822  size_t sparseBlockSize = rowOffsets[idx + nrows] - rowOffsets[idx];
823 
824  if( !block.resizeBuffer( ncols, nrows, sparseBlockSize * sizeof(T) ) )
825  return services::Status(services::ErrorMemoryAllocationFailed);
826  buffer = block.getBlockPtr();
827 
828  castingBuffer = (T*)block.getAdditionalBufferPtr();
829 
830  internal::getVectorUpCast(f.indexType, internal::getConversionDataType<T>())
831  ( sparseBlockSize, location, castingBuffer );
832  }
833 
834  T *bufRowCursor = castingBuffer;
835  size_t *indicesCursor = _colIndices.get() + rowOffsets[idx] - 1;
836 
837  for( size_t i = 0; i < ncols * nrows; i++ ) { buffer[i] = (T)0; }
838 
839  for( size_t i = 0; i < nrows; i++ )
840  {
841  size_t sparseRowSize = rowOffsets[idx + i + 1] - rowOffsets[idx + i];
842 
843  for( size_t k = 0; k < sparseRowSize; k++ )
844  {
845  buffer[i * ncols + indicesCursor[k] - 1] = bufRowCursor[k];
846  }
847 
848  bufRowCursor += sparseRowSize;
849  indicesCursor += sparseRowSize;
850  }
851  return services::Status();
852  }
853 
854  template <typename T>
855  services::Status releaseTBlock( BlockDescriptor<T> &block )
856  {
857  if (!(block.getRWFlag() & (int)writeOnly))
858  block.reset();
859  return services::Status();
860  }
861 
862  template <typename T>
863  services::Status getTFeature(size_t feat_idx, size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block)
864  {
865  size_t ncols = getNumberOfColumns();
866  size_t nobs = getNumberOfRows();
867  block.setDetails( feat_idx, idx, rwFlag );
868  size_t* rowOffsets = _rowOffsets.get();
869 
870  if (idx >= nobs)
871  {
872  block.resizeBuffer( 1, 0 );
873  return services::Status();
874  }
875 
876  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
877 
878  if( !block.resizeBuffer( 1, nrows ) )
879  return services::Status(services::ErrorMemoryAllocationFailed);
880 
881  NumericTableFeature &f = (*_ddict)[0];
882 
883  char *rowCursor = (char *)_ptr.get() + (rowOffsets[idx] - 1) * f.typeSize;
884  size_t *indicesCursor = _colIndices.get() + (rowOffsets[idx] - 1);
885 
886  T* bufferPtr = block.getBlockPtr();
887 
888  for(size_t i = 0; i < nrows; i++)
889  {
890  bufferPtr[i] = (T)0;
891 
892  size_t sparseRowSize = rowOffsets[idx + i + 1] - rowOffsets[idx + i];
893 
894  for(size_t k = 0; k < sparseRowSize; k++)
895  {
896  if( indicesCursor[k] - 1 == feat_idx )
897  {
898  internal::getVectorUpCast(f.indexType, internal::getConversionDataType<T>())
899  ( 1, rowCursor + k * f.typeSize, bufferPtr + i );
900  }
901  }
902 
903  rowCursor += sparseRowSize * f.typeSize;
904  indicesCursor += sparseRowSize;
905  }
906  return services::Status();
907  }
908 
909  template <typename T>
910  services::Status releaseTFeature( BlockDescriptor<T> &block )
911  {
912  if(block.getRWFlag() & (int)writeOnly)
913  return services::Status();
914  block.reset();
915  return services::Status();
916  }
917 
918  template <typename T>
919  services::Status getSparseTBlock( size_t idx, size_t nrows, int rwFlag, CSRBlockDescriptor<T> &block )
920  {
921  size_t ncols = getNumberOfColumns();
922  size_t nobs = getNumberOfRows();
923  block.setDetails( ncols, idx, rwFlag );
924  size_t* rowOffsets = _rowOffsets.get();
925 
926  if (idx >= nobs)
927  {
928  block.resizeValuesBuffer( 0 );
929  return services::Status();
930  }
931 
932  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
933 
934  NumericTableFeature &f = (*_ddict)[0];
935 
936 
937  size_t nValues = rowOffsets[idx + nrows] - rowOffsets[idx];
938 
939  if( features::internal::getIndexNumType<T>() == f.indexType )
940  {
941  block.setValuesPtr(&_ptr, _ptr.get() +(rowOffsets[idx] - 1) * f.typeSize, nValues);
942  }
943  else
944  {
945  if( !block.resizeValuesBuffer(nValues) ) { return services::Status(); }
946 
947  services::SharedPtr<byte> location(_ptr, _ptr.get() +(rowOffsets[idx] - 1) * f.typeSize);
948  internal::getVectorUpCast(f.indexType, internal::getConversionDataType<T>())
949  ( nValues, location.get(), block.getBlockValuesPtr() );
950  }
951 
952  services::SharedPtr<size_t> shiftedColumns(_colIndices, _colIndices.get() + (rowOffsets[idx] - 1));
953  block.setColumnIndicesPtr( shiftedColumns, nValues );
954 
955  if( idx == 0 )
956  {
957  block.setRowIndicesPtr( _rowOffsets, nrows );
958  }
959  else
960  {
961  if( !block.resizeRowsBuffer(nrows) ) { return services::Status(); }
962 
963  size_t *row_offsets = block.getBlockRowIndicesSharedPtr().get();
964 
965  for(size_t i = 0; i < nrows + 1; i++)
966  {
967  row_offsets[i] = rowOffsets[idx + i] - rowOffsets[idx] + 1;
968  }
969  }
970  return services::Status();
971  }
972 
973  template <typename T>
974  services::Status releaseSparseTBlock(CSRBlockDescriptor<T> &block)
975  {
976  if (block.getRWFlag() & (int)writeOnly)
977  {
978  NumericTableFeature &f = (*_ddict)[0];
979  if (f.indexType != features::internal::getIndexNumType<T>())
980  {
981  size_t nrows = block.getNumberOfRows();
982  size_t idx = block.getRowsOffset();
983  size_t nValues = _rowOffsets.get()[idx + nrows] - _rowOffsets.get()[idx];
984 
985  services::SharedPtr<byte> ptr = services::reinterpretPointerCast<byte, T>(block.getBlockValuesSharedPtr());
986  services::SharedPtr<byte> location = services::SharedPtr<byte>(ptr, _ptr.get() + (_rowOffsets.get()[idx] - 1) * f.typeSize);
987 
988  internal::getVectorDownCast(f.indexType, internal::getConversionDataType<T>())
989  (nValues, ptr.get(), location.get());
990  }
991  }
992  block.reset();
993  return services::Status();
994  }
995 
996  virtual services::Status setNumberOfColumnsImpl(size_t ncol) DAAL_C11_OVERRIDE
997  {
998  _ddict->setNumberOfFeatures( ncol );
999  _ddict->setAllFeatures( _defaultFeature );
1000  return services::Status();
1001  }
1002 
1003 };
1004 typedef services::SharedPtr<CSRNumericTableIface> CSRNumericTableIfacePtr;
1005 typedef services::SharedPtr<CSRNumericTable> CSRNumericTablePtr;
1007 } // namespace interface1
1008 using interface1::CSRNumericTableIface;
1009 using interface1::CSRNumericTableIfacePtr;
1010 using interface1::CSRBlockDescriptor;
1011 using interface1::CSRNumericTable;
1012 using interface1::CSRNumericTablePtr;
1013 
1014 }
1015 } // namespace daal
1016 #endif
daal::services::ErrorMethodNotSupported
Definition: error_indexes.h:71
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:603
daal::services::ArgumentName
Definition: error_indexes.h:52
daal::data_management::interface1::CSRBlockDescriptor::getBlockValuesPtr
DataType * getBlockValuesPtr() const
Definition: csr_numeric_table.h:61
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:571
daal::data_management::interface1::CSRBlockDescriptor::freeRowsBuffer
void freeRowsBuffer()
Definition: csr_numeric_table.h:251
daal::data_management::interface1::CSRNumericTableIface
Abstract class that defines the interface of CSR numeric tables.
Definition: csr_numeric_table.h:282
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:395
daal::algorithms::multivariate_outlier_detection::location
Definition: outlier_detection_multivariate_types.h:74
daal::data_management::interface1::CSRNumericTable::getCSRIndexing
CSRIndexing getCSRIndexing() const
Definition: csr_numeric_table.h:685
daal::services::ErrorIncorrectNumberOfObservations
Definition: error_indexes.h:73
daal::data_management::interface1::BlockDescriptor::getAdditionalBufferPtr
void * getAdditionalBufferPtr() const
Definition: numeric_table.h:226
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:48
daal::data_management::interface1::CSRNumericTable::releaseSparseBlock
services::Status releaseSparseBlock(CSRBlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:644
daal::data_management::interface1::NumericTable
Class for a data management component responsible for representation of data in the numeric format...
Definition: numeric_table.h:577
daal::data_management::interface1::CSRNumericTable::resize
virtual services::Status resize(size_t nrows) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:486
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:529
daal::data_management::interface1::CSRBlockDescriptor::resizeRowsBuffer
bool resizeRowsBuffer(size_t nRows)
Definition: csr_numeric_table.h:201
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:513
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:472
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:631
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:693
daal::data_management::interface1::CSRBlockDescriptor::getBlockValuesSharedPtr
services::SharedPtr< DataType > getBlockValuesSharedPtr() const
Definition: csr_numeric_table.h:77
daal::MemType
MemType
Definition: daal_defines.h:147
daal::data_management::interface1::CSRNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:584
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:598
daal::data_management::interface1::CSRNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:609
daal::data_management::interface1::CSRNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:588
daal::data_management::interface1::CSRNumericTableIface::releaseSparseBlock
virtual services::Status releaseSparseBlock(CSRBlockDescriptor< double > &block)=0
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::CSRBlockDescriptor::resizeValuesBuffer
bool resizeValuesBuffer(size_t nValues)
Definition: csr_numeric_table.h:176
daal::data_management::interface1::CSRBlockDescriptor::reset
void reset()
Definition: csr_numeric_table.h:164
daal::data_management::interface1::CSRNumericTable::releaseSparseBlock
services::Status releaseSparseBlock(CSRBlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:640
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:552
daal::data_management::interface1::CSRNumericTable::getArrays
services::Status getArrays(DataType **ptr, size_t **colIndices, size_t **rowOffsets) const
Definition: csr_numeric_table.h:498
daal::data_management::interface1::CSRNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:613
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:593
daal::data_management::interface1::CSRNumericTable::getDataSize
size_t getDataSize() DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:777
daal::data_management::interface1::CSRBlockDescriptor::setRowIndicesPtr
void setRowIndicesPtr(size_t *ptr, size_t nRows)
Definition: csr_numeric_table.h:126
daal::data_management::interface1::CSRBlockDescriptor::getDataSize
size_t getDataSize() const
Definition: csr_numeric_table.h:105
daal::dram
Definition: daal_defines.h:149
daal::services::daal_malloc
DAAL_EXPORT void * daal_malloc(size_t size, size_t alignment=DAAL_MALLOC_DEFAULT_ALIGNMENT)
daal::data_management::interface1::CSRNumericTable::allocateDataMemory
services::Status allocateDataMemory(size_t dataSize, daal::MemType type=daal::dram)
Definition: csr_numeric_table.h:654
daal::data_management::interface1::CSRNumericTable::releaseSparseBlock
services::Status releaseSparseBlock(CSRBlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:636
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:567
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:575
daal::data_management::interface1::BlockDescriptor
Base class that manages buffer memory for read/write operations required by numeric tables...
Definition: numeric_table.h:57
daal::data_management::interface1::CSRBlockDescriptor::freeValuesBuffer
void freeValuesBuffer()
Definition: csr_numeric_table.h:239
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:623
daal::services::ErrorMemoryAllocationFailed
Definition: error_indexes.h:150
daal::data_management::interface1::CSRBlockDescriptor::getNumberOfColumns
size_t getNumberOfColumns() const
Definition: csr_numeric_table.h:93
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:627
daal::data_management::interface1::CSRNumericTable
Class that provides methods to access data stored in the CSR layout.
Definition: csr_numeric_table.h:364
daal::data_management::interface1::NumericTableFeature
Data structure describes the Numeric Table feature.
Definition: data_dictionary.h:53
daal::data_management::interface1::CSRNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:617
daal::data_management::interface1::CSRNumericTableIface::zeroBased
Definition: csr_numeric_table.h:291
daal::data_management::interface1::CSRNumericTableIface::getDataSize
virtual size_t getDataSize()=0
daal::data_management::interface1::CSRBlockDescriptor::getNumberOfRows
size_t getNumberOfRows() const
Definition: csr_numeric_table.h:99
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:289
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:446
daal::data_management::interface1::CSRNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:580
daal::data_management::interface1::CSRNumericTableIface::oneBased
Definition: csr_numeric_table.h:292
daal::services::ErrorUnsupportedCSRIndexing
Definition: error_indexes.h:119
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:422
daal::data_management::interface1::BlockDescriptor::setDetails
void setDetails(size_t columnIdx, size_t rowIdx, int rwFlag)
Definition: numeric_table.h:197
daal::data_management::interface1::BlockDescriptor::getBlockPtr
DataType * getBlockPtr() const
Definition: numeric_table.h:71
daal::data_management::interface1::CSRBlockDescriptor::setRowIndicesPtr
void setRowIndicesPtr(services::SharedPtr< size_t > ptr, size_t nRows)
Definition: csr_numeric_table.h:155
daal::data_management::interface1::BlockDescriptor::resizeBuffer
bool resizeBuffer(size_t nColumns, size_t nRows, size_t auxMemorySize=0)
Definition: numeric_table.h:153

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