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

csr_numeric_table.h
1 /* file: csr_numeric_table.h */
2 /*******************************************************************************
3 * Copyright 2014-2017 Intel Corporation
4 * All Rights Reserved.
5 *
6 * If this software was obtained under the Intel Simplified Software License,
7 * the following terms apply:
8 *
9 * The source code, information and material ("Material") contained herein is
10 * owned by Intel Corporation or its suppliers or licensors, and title to such
11 * Material remains with Intel Corporation or its suppliers or licensors. The
12 * Material contains proprietary information of Intel or its suppliers and
13 * licensors. The Material is protected by worldwide copyright laws and treaty
14 * provisions. No part of the Material may be used, copied, reproduced,
15 * modified, published, uploaded, posted, transmitted, distributed or disclosed
16 * in any way without Intel's prior express written permission. No license under
17 * any patent, copyright or other intellectual property rights in the Material
18 * is granted to or conferred upon you, either expressly, by implication,
19 * inducement, estoppel or otherwise. Any license under such intellectual
20 * property rights must be express and approved by Intel in writing.
21 *
22 * Unless otherwise agreed by Intel in writing, you may not remove or alter this
23 * notice or any other notice embedded in Materials by Intel or Intel's
24 * suppliers or licensors in any way.
25 *
26 *
27 * If this software was obtained under the Apache License, Version 2.0 (the
28 * "License"), the following terms apply:
29 *
30 * You may not use this file except in compliance with the License. You may
31 * obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
32 *
33 *
34 * Unless required by applicable law or agreed to in writing, software
35 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
36 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
37 *
38 * See the License for the specific language governing permissions and
39 * limitations under the License.
40 *******************************************************************************/
41 
42 /*
43 //++
44 // Implementation of a compressed sparse row (CSR) numeric table.
45 //--
46 */
47 
48 #ifndef __CSR_NUMERIC_TABLE_H__
49 #define __CSR_NUMERIC_TABLE_H__
50 
51 #include "services/base.h"
52 #include "data_management/data/numeric_table.h"
53 #include "data_management/data/data_serialize.h"
54 
55 namespace daal
56 {
57 namespace data_management
58 {
59 
60 namespace interface1
61 {
70 template<typename DataType = DAAL_DATA_TYPE>
71 class DAAL_EXPORT CSRBlockDescriptor
72 {
73 public:
75  CSRBlockDescriptor();
76 
78  ~CSRBlockDescriptor() { freeValuesBuffer(); freeRowsBuffer(); }
79 
84  inline DataType *getBlockValuesPtr() const
85  {
86  if(_rawPtr)
87  {
88  return (DataType *)_rawPtr;
89  }
90  return _values_ptr.get();
91  }
92 
93  inline size_t *getBlockColumnIndicesPtr() const { return _cols_ptr.get(); }
94  inline size_t *getBlockRowIndicesPtr() const { return _rows_ptr.get(); }
95 
100  inline services::SharedPtr<DataType> getBlockValuesSharedPtr() const
101  {
102  if(_rawPtr)
103  {
104  return services::SharedPtr<DataType>(services::reinterpretPointerCast<DataType, byte>(*_pPtr), (DataType *)_rawPtr);
105  }
106  return _values_ptr;
107  }
108 
109  inline services::SharedPtr<size_t> getBlockColumnIndicesSharedPtr() const { return _cols_ptr; }
110  inline services::SharedPtr<size_t> getBlockRowIndicesSharedPtr() const { return _rows_ptr; }
111 
116  inline size_t getNumberOfColumns() const { return _ncols; }
117 
122  inline size_t getNumberOfRows() const { return _nrows; }
123 
128  inline size_t getDataSize() const
129  {
130  return ((_nrows > 0) ? _rows_ptr.get()[_nrows] - _rows_ptr.get()[0] : 0);
131  }
132 public:
133  inline void setValuesPtr( DataType *ptr, size_t nValues )
134  {
135  _values_ptr = services::SharedPtr<DataType>(ptr, services::EmptyDeleter());
136  _nvalues = nValues;
137  }
138 
139  inline void setColumnIndicesPtr( size_t *ptr, size_t nValues )
140  {
141  _cols_ptr = services::SharedPtr<size_t>(ptr, services::EmptyDeleter());
142  _nvalues = nValues;
143  }
144 
149  inline void setRowIndicesPtr( size_t *ptr, size_t nRows )
150  {
151  _rows_ptr = services::SharedPtr<size_t>(ptr, services::EmptyDeleter());
152  _nrows = nRows;
153  }
154 
155  inline void setValuesPtr( services::SharedPtr<DataType> ptr, size_t nValues )
156  {
157  _values_ptr = ptr;
158  _nvalues = nValues;
159  }
160 
161  inline void setValuesPtr( services::SharedPtr<byte> *pPtr, byte* rawPtr, size_t nValues)
162  {
163  _pPtr = pPtr;
164  _rawPtr = rawPtr;
165  _nvalues = nValues;
166  }
167 
168  inline void setColumnIndicesPtr( services::SharedPtr<size_t> ptr, size_t nValues )
169  {
170  _cols_ptr = ptr;
171  _nvalues = nValues;
172  }
173 
178  inline void setRowIndicesPtr( services::SharedPtr<size_t> ptr, size_t nRows )
179  {
180  _rows_ptr = ptr;
181  _nrows = nRows;
182  }
183 
187  inline void reset()
188  {
189  _ncols = 0;
190  _rowsOffset = 0;
191  _rwFlag = 0;
192  _pPtr = NULL;
193  _rawPtr = NULL;
194  }
195 
199  inline bool resizeValuesBuffer( size_t nValues )
200  {
201  size_t newSize = nValues * sizeof(DataType);
202  if ( newSize > _values_capacity )
203  {
204  freeValuesBuffer();
205  _values_buffer = services::SharedPtr<DataType>((DataType *)daal::services::daal_malloc(newSize), services::ServiceDeleter()) ;
206  if ( _values_buffer )
207  {
208  _values_capacity = newSize;
209  }
210  else
211  {
212  return false;
213  }
214  }
215 
216  _values_ptr = _values_buffer;
217 
218  return true;
219  }
220 
224  inline bool resizeRowsBuffer( size_t nRows )
225  {
226  _nrows = nRows;
227  size_t newSize = (nRows + 1) * sizeof(size_t);
228  if ( newSize > _rows_capacity )
229  {
230  freeRowsBuffer();
231  _rows_buffer = services::SharedPtr<size_t>((size_t *)daal::services::daal_malloc(newSize), services::ServiceDeleter()) ;
232  if ( _rows_buffer )
233  {
234  _rows_capacity = newSize;
235  }
236  else
237  {
238  return false;
239  }
240 
241  }
242 
243  _rows_ptr = _rows_buffer;
244 
245  return true;
246  }
247 
248  inline void setDetails( size_t nColumns, size_t rowIdx, int rwFlag )
249  {
250  _ncols = nColumns;
251  _rowsOffset = rowIdx;
252  _rwFlag = rwFlag;
253  }
254 
255  inline size_t getRowsOffset() const { return _rowsOffset; }
256  inline size_t getRWFlag() const { return _rwFlag; }
257 
258 protected:
262  void freeValuesBuffer()
263  {
264  if(_values_buffer)
265  {
266  _values_buffer = services::SharedPtr<DataType>();
267  }
268  _values_capacity = 0;
269  }
270 
274  void freeRowsBuffer()
275  {
276  _rows_buffer = services::SharedPtr<size_t>();
277  _rows_capacity = 0;
278  }
279 
280 private:
281  services::SharedPtr<DataType> _values_ptr;
282  services::SharedPtr<size_t> _cols_ptr;
283  services::SharedPtr<size_t> _rows_ptr;
284  size_t _nrows;
285  size_t _ncols;
286  size_t _nvalues;
287 
288  size_t _rowsOffset;
289  int _rwFlag;
290 
291  services::SharedPtr<DataType> _values_buffer; /*<! Pointer to the buffer */
292  size_t _values_capacity; /*<! Buffer size in bytes */
293 
294  services::SharedPtr<size_t> _rows_buffer; /*<! Pointer to the buffer */
295  size_t _rows_capacity; /*<! Buffer size in bytes */
296 
297  services::SharedPtr<byte> *_pPtr;
298  byte *_rawPtr;
299 };
300 
305 class CSRNumericTableIface
306 {
307 public:
312  enum CSRIndexing
313  {
314  zeroBased = 0,
315  oneBased = 1
316  };
317 
318 public:
319 
320  virtual ~CSRNumericTableIface() {}
321 
327  virtual size_t getDataSize() = 0;
338  virtual services::Status getSparseBlock(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, CSRBlockDescriptor<double> &block) = 0;
339 
350  virtual services::Status getSparseBlock(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, CSRBlockDescriptor<float> &block) = 0;
351 
362  virtual services::Status getSparseBlock(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, CSRBlockDescriptor<int> &block) = 0;
363 
368  virtual services::Status releaseSparseBlock(CSRBlockDescriptor<double> &block) = 0;
369 
374  virtual services::Status releaseSparseBlock(CSRBlockDescriptor<float> &block) = 0;
375 
380  virtual services::Status releaseSparseBlock(CSRBlockDescriptor<int> &block) = 0;
381 };
382 
387 class DAAL_EXPORT CSRNumericTable : public NumericTable, public CSRNumericTableIface
388 {
389 public:
390  DECLARE_SERIALIZABLE_TAG();
391  DECLARE_SERIALIZABLE_IMPL();
392 
393  DAAL_CAST_OPERATOR(CSRNumericTable)
398  CSRNumericTable(): NumericTable(0, 0, DictionaryIface::equal), _indexing(oneBased)
399  {
400  _layout = csrArray;
401  this->_status |= setArrays<double>( 0, 0, 0 ); //data type doesn't matter
402  }
403 
417  template<typename DataType>
418  CSRNumericTable( DataType *const ptr, size_t *colIndices = 0, size_t *rowOffsets = 0,
419  size_t nColumns = 0, size_t nRows = 0, CSRIndexing indexing = oneBased ):
420  NumericTable(nColumns, nRows, DictionaryIface::equal), _indexing(indexing)
421  {
422  _layout = csrArray;
423  this->_status |= setArrays<DataType>(ptr, colIndices, rowOffsets);
424 
425  _defaultFeature.setType<DataType>();
426  this->_status |= _ddict->setAllFeatures( _defaultFeature );
427  }
428 
429 
444  template<typename DataType>
445  static services::SharedPtr<CSRNumericTable> create(DataType *const ptr, size_t *colIndices = 0, size_t *rowOffsets = 0,
446  size_t nColumns = 0, size_t nRows = 0, CSRIndexing indexing = oneBased,
447  services::Status *stat = NULL)
448  {
449  return create<DataType>(services::SharedPtr<DataType>(ptr, services::EmptyDeleter()),
450  services::SharedPtr<size_t>(colIndices, services::EmptyDeleter()),
451  services::SharedPtr<size_t>(rowOffsets, services::EmptyDeleter()),
452  nColumns, nRows, indexing, stat);
453  }
454 
468  template<typename DataType>
469  CSRNumericTable( const services::SharedPtr<DataType>& ptr, const services::SharedPtr<size_t>& colIndices, const services::SharedPtr<size_t>& rowOffsets,
470  size_t nColumns, size_t nRows, CSRIndexing indexing = oneBased ):
471  NumericTable(nColumns, nRows, DictionaryIface::equal), _indexing(indexing)
472  {
473  _layout = csrArray;
474  this->_status |= setArrays<DataType>(ptr, colIndices, rowOffsets);
475 
476  _defaultFeature.setType<DataType>();
477  this->_status |= _ddict->setAllFeatures( _defaultFeature );
478  }
479 
494  template<typename DataType>
495  static services::SharedPtr<CSRNumericTable> create(const services::SharedPtr<DataType>& ptr,
496  const services::SharedPtr<size_t>& colIndices,
497  const services::SharedPtr<size_t>& rowOffsets,
498  size_t nColumns, size_t nRows, CSRIndexing indexing = oneBased,
499  services::Status *stat = NULL)
500  {
501  DAAL_DEFAULT_CREATE_IMPL_EX(CSRNumericTable, ptr, colIndices, rowOffsets, nColumns, nRows, indexing);
502  }
503 
504  virtual ~CSRNumericTable()
505  {
506  freeDataMemoryImpl();
507  }
508 
509  virtual services::Status resize(size_t nrows) DAAL_C11_OVERRIDE
510  {
511  return setNumberOfRowsImpl(nrows);
512  }
513 
520  template<typename DataType>
521  services::Status getArrays(DataType **ptr, size_t **colIndices, size_t **rowOffsets) const
522  {
523  if (ptr) { *ptr = (DataType*)_ptr.get(); }
524  if (colIndices) { *colIndices = _colIndices.get(); }
525  if (rowOffsets) { *rowOffsets = _rowOffsets.get(); }
526  return services::Status();
527  }
528 
535  template<typename DataType>
536  services::Status getArrays(services::SharedPtr<DataType> &ptr, services::SharedPtr<size_t> &colIndices, services::SharedPtr<size_t> &rowOffsets) const
537  {
538  if(ptr) { *ptr = _ptr; }
539  if (colIndices) { *colIndices = _colIndices; }
540  if (rowOffsets) { *rowOffsets = _rowOffsets; }
541  return services::Status();
542  }
543 
551  template<typename DataType>
552  services::Status setArrays(DataType *const ptr, size_t *colIndices, 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::SharedPtr<byte>((byte*)ptr, services::EmptyDeleter());
559  _colIndices = services::SharedPtr<size_t>(colIndices, services::EmptyDeleter());
560  _rowOffsets = services::SharedPtr<size_t>(rowOffsets, services::EmptyDeleter());
561  _indexing = indexing;
562 
563  if( ptr != 0 && colIndices != 0 && rowOffsets != 0 ) { _memStatus = userAllocated; }
564  return services::Status();
565  }
566 
574  template<typename DataType>
575  services::Status setArrays(const services::SharedPtr<DataType>& ptr, const services::SharedPtr<size_t>& colIndices, const services::SharedPtr<size_t>& rowOffsets, CSRIndexing indexing = oneBased)
576  {
577  freeDataMemoryImpl();
578 
579  //if( ptr == 0 || colIndices == 0 || rowOffsets == 0 ) return services::Status(services::ErrorEmptyCSRNumericTable);
580 
581  _ptr = services::reinterpretPointerCast<byte, DataType>(ptr);
582  _colIndices = colIndices;
583  _rowOffsets = rowOffsets;
584  _indexing = indexing;
585 
586  if( ptr && colIndices && rowOffsets ) { _memStatus = userAllocated; }
587  return services::Status();
588  }
589 
590  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
591  {
592  return getTBlock<double>(vector_idx, vector_num, rwflag, block);
593  }
594  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
595  {
596  return getTBlock<float>(vector_idx, vector_num, rwflag, block);
597  }
598  services::Status getBlockOfRows(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
599  {
600  return getTBlock<int>(vector_idx, vector_num, rwflag, block);
601  }
602 
603  services::Status releaseBlockOfRows(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
604  {
605  return releaseTBlock<double>(block);
606  }
607  services::Status releaseBlockOfRows(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
608  {
609  return releaseTBlock<float>(block);
610  }
611  services::Status releaseBlockOfRows(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
612  {
613  return releaseTBlock<int>(block);
614  }
615 
616  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
617  ReadWriteMode rwflag, BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
618  {
619  return getTFeature<double>(feature_idx, vector_idx, value_num, rwflag, block);
620  }
621  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
622  ReadWriteMode rwflag, BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
623  {
624  return getTFeature<float>(feature_idx, vector_idx, value_num, rwflag, block);
625  }
626  services::Status getBlockOfColumnValues(size_t feature_idx, size_t vector_idx, size_t value_num,
627  ReadWriteMode rwflag, BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
628  {
629  return getTFeature<int>(feature_idx, vector_idx, value_num, rwflag, block);
630  }
631 
632  services::Status releaseBlockOfColumnValues(BlockDescriptor<double> &block) DAAL_C11_OVERRIDE
633  {
634  return releaseTFeature<double>(block);
635  }
636  services::Status releaseBlockOfColumnValues(BlockDescriptor<float> &block) DAAL_C11_OVERRIDE
637  {
638  return releaseTFeature<float>(block);
639  }
640  services::Status releaseBlockOfColumnValues(BlockDescriptor<int> &block) DAAL_C11_OVERRIDE
641  {
642  return releaseTFeature<int>(block);
643  }
644 
645 
646  services::Status getSparseBlock(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, CSRBlockDescriptor<double> &block) DAAL_C11_OVERRIDE
647  {
648  return getSparseTBlock<double>(vector_idx, vector_num, rwflag, block);
649  }
650  services::Status getSparseBlock(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, CSRBlockDescriptor<float> &block) DAAL_C11_OVERRIDE
651  {
652  return getSparseTBlock<float>(vector_idx, vector_num, rwflag, block);
653  }
654  services::Status getSparseBlock(size_t vector_idx, size_t vector_num, ReadWriteMode rwflag, CSRBlockDescriptor<int> &block) DAAL_C11_OVERRIDE
655  {
656  return getSparseTBlock<int>(vector_idx, vector_num, rwflag, block);
657  }
658 
659  services::Status releaseSparseBlock(CSRBlockDescriptor<double> &block) DAAL_C11_OVERRIDE
660  {
661  return releaseSparseTBlock<double>(block);
662  }
663  services::Status releaseSparseBlock(CSRBlockDescriptor<float> &block) DAAL_C11_OVERRIDE
664  {
665  return releaseSparseTBlock<float>(block);
666  }
667  services::Status releaseSparseBlock(CSRBlockDescriptor<int> &block) DAAL_C11_OVERRIDE
668  {
669  return releaseSparseTBlock<int>(block);
670  }
671 
677  services::Status allocateDataMemory(size_t dataSize, daal::MemType type = daal::dram)
678  {
679  freeDataMemoryImpl();
680 
681  size_t nrow = getNumberOfRows();
682 
683  if( nrow == 0 )
684  return services::Status(services::ErrorIncorrectNumberOfObservations);
685 
686  NumericTableFeature &f = (*_ddict)[0];
687 
688  _ptr = services::SharedPtr<byte> ( (byte*)daal::services::daal_malloc( dataSize * f.typeSize ), services::ServiceDeleter ());
689  _colIndices = services::SharedPtr<size_t>((size_t *)daal::services::daal_malloc( dataSize * sizeof(size_t) ), services::ServiceDeleter());
690  _rowOffsets = services::SharedPtr<size_t>((size_t *)daal::services::daal_malloc( (nrow + 1) * sizeof(size_t) ), services::ServiceDeleter());
691 
692  _memStatus = internallyAllocated;
693 
694  if( !_ptr || !_colIndices || !_rowOffsets )
695  {
696  freeDataMemoryImpl();
697  return services::Status(services::ErrorMemoryAllocationFailed);
698  }
699 
700  _rowOffsets.get()[0] = ((_indexing == oneBased) ? 1 : 0);
701  return services::Status();
702  }
703 
708  CSRIndexing getCSRIndexing() const
709  {
710  return _indexing;
711  }
712 
716  virtual services::Status check(const char *description, bool checkDataAllocation = true) const DAAL_C11_OVERRIDE
717  {
718  services::Status s;
719  DAAL_CHECK_STATUS(s, data_management::NumericTable::check(description, checkDataAllocation));
720 
721  if( _indexing != oneBased )
722  {
723  return services::Status(services::Error::create(services::ErrorUnsupportedCSRIndexing, services::ArgumentName, description));
724  }
725 
726  return services::Status();
727  }
728 
729 protected:
730  NumericTableFeature _defaultFeature;
731  CSRIndexing _indexing;
732 
733  services::SharedPtr<byte> _ptr;
734  services::SharedPtr<size_t> _colIndices;
735  services::SharedPtr<size_t> _rowOffsets;
736 
737  template<typename DataType>
738  CSRNumericTable(const services::SharedPtr<DataType>& ptr, const services::SharedPtr<size_t>& colIndices, const services::SharedPtr<size_t>& rowOffsets,
739  size_t nColumns, size_t nRows, CSRIndexing indexing,
740  services::Status &st):
741  NumericTable(nColumns, nRows, DictionaryIface::equal, st), _indexing(indexing)
742  {
743  _layout = csrArray;
744  st |= setArrays<DataType>(ptr, colIndices, rowOffsets);
745 
746  _defaultFeature.setType<DataType>();
747  st |= _ddict->setAllFeatures( _defaultFeature );
748  }
749 
750  services::Status allocateDataMemoryImpl(daal::MemType type = daal::dram) DAAL_C11_OVERRIDE
751  {
752  return services::Status(services::ErrorMethodNotSupported);
753  }
754 
755  void freeDataMemoryImpl() DAAL_C11_OVERRIDE
756  {
757  _ptr = services::SharedPtr<byte>();
758  _colIndices = services::SharedPtr<size_t>();
759  _rowOffsets = services::SharedPtr<size_t>();
760 
761  _memStatus = notAllocated;
762  }
763 
764 
766  template<typename Archive, bool onDeserialize>
767  services::Status serialImpl( Archive *arch )
768  {
769  NumericTable::serialImpl<Archive, onDeserialize>( arch );
770 
771  size_t dataSize = 0;
772  if( !onDeserialize )
773  {
774  dataSize = getDataSize();
775  }
776  arch->set( dataSize );
777 
778  if( onDeserialize )
779  {
780  allocateDataMemory( dataSize );
781  }
782 
783  size_t nfeat = getNumberOfColumns();
784  size_t nobs = getNumberOfRows();
785 
786  if( nfeat > 0 )
787  {
788  NumericTableFeature &f = (*_ddict)[0];
789 
790  arch->set( (char *)_ptr.get(), dataSize * f.typeSize );
791  arch->set( _colIndices.get(), dataSize );
792  arch->set( _rowOffsets.get(), nobs + 1 );
793  }
794 
795  return services::Status();
796  }
797 
798 
799 public:
800  size_t getDataSize() DAAL_C11_OVERRIDE
801  {
802  size_t nobs = getNumberOfRows();
803  if( nobs > 0)
804  {
805  return _rowOffsets.get()[nobs] - _rowOffsets.get()[0];
806  }
807  else
808  {
809  return 0;
810  }
811  }
812 
813 protected:
814 
815  template <typename T>
816  services::Status getTBlock(size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block)
817  {
818  size_t ncols = getNumberOfColumns();
819  size_t nobs = getNumberOfRows();
820  block.setDetails( 0, idx, rwFlag );
821  size_t* rowOffsets = _rowOffsets.get();
822 
823  if (idx >= nobs)
824  {
825  block.resizeBuffer( ncols, 0 );
826  return services::Status();
827  }
828 
829  NumericTableFeature &f = (*_ddict)[0];
830 
831  T* buffer;
832  T* castingBuffer;
833  T* location = (T*)(_ptr.get() + (rowOffsets[idx] - 1) * f.typeSize);
834 
835  if( data_feature_utils::getIndexNumType<T>() == f.indexType )
836  {
837  castingBuffer = location;
838 
839  if( !block.resizeBuffer( ncols, nrows ) )
840  return services::Status(services::ErrorMemoryAllocationFailed);
841  buffer = block.getBlockPtr();
842  }
843  else
844  {
845  size_t sparseBlockSize = rowOffsets[idx + nrows] - rowOffsets[idx];
846 
847  if( !block.resizeBuffer( ncols, nrows, sparseBlockSize * sizeof(T) ) )
848  return services::Status(services::ErrorMemoryAllocationFailed);
849  buffer = block.getBlockPtr();
850 
851  castingBuffer = (T*)block.getAdditionalBufferPtr();
852 
853  data_feature_utils::getVectorUpCast(f.indexType,data_feature_utils::getInternalNumType<T>())
854  ( sparseBlockSize, location, castingBuffer );
855  }
856 
857  T *bufRowCursor = castingBuffer;
858  size_t *indicesCursor = _colIndices.get() + rowOffsets[idx] - 1;
859 
860  for( size_t i = 0; i < ncols * nrows; i++ ) { buffer[i] = (T)0; }
861 
862  for( size_t i = 0; i < nrows; i++ )
863  {
864  size_t sparseRowSize = rowOffsets[idx + i + 1] - rowOffsets[idx + i];
865 
866  for( size_t k = 0; k < sparseRowSize; k++ )
867  {
868  buffer[i * ncols + indicesCursor[k] - 1] = bufRowCursor[k];
869  }
870 
871  bufRowCursor += sparseRowSize;
872  indicesCursor += sparseRowSize;
873  }
874  return services::Status();
875  }
876 
877  template <typename T>
878  services::Status releaseTBlock( BlockDescriptor<T> &block )
879  {
880  if (!(block.getRWFlag() & (int)writeOnly))
881  block.reset();
882  return services::Status();
883  }
884 
885  template <typename T>
886  services::Status getTFeature(size_t feat_idx, size_t idx, size_t nrows, int rwFlag, BlockDescriptor<T> &block)
887  {
888  size_t ncols = getNumberOfColumns();
889  size_t nobs = getNumberOfRows();
890  block.setDetails( feat_idx, idx, rwFlag );
891  size_t* rowOffsets = _rowOffsets.get();
892 
893  if (idx >= nobs)
894  {
895  block.resizeBuffer( 1, 0 );
896  return services::Status();
897  }
898 
899  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
900 
901  if( !block.resizeBuffer( 1, nrows ) )
902  return services::Status(services::ErrorMemoryAllocationFailed);
903 
904  NumericTableFeature &f = (*_ddict)[0];
905 
906  char *rowCursor = (char *)_ptr.get() + (rowOffsets[idx] - 1) * f.typeSize;
907  size_t *indicesCursor = _colIndices.get() + (rowOffsets[idx] - 1);
908 
909  T* bufferPtr = block.getBlockPtr();
910 
911  for(size_t i = 0; i < nrows; i++)
912  {
913  bufferPtr[i] = (T)0;
914 
915  size_t sparseRowSize = rowOffsets[idx + i + 1] - rowOffsets[idx + i];
916 
917  for(size_t k = 0; k < sparseRowSize; k++)
918  {
919  if( indicesCursor[k] - 1 == feat_idx )
920  {
921  data_feature_utils::getVectorUpCast(f.indexType, data_feature_utils::getInternalNumType<T>())
922  ( 1, rowCursor + k * f.typeSize, bufferPtr + i );
923  }
924  }
925 
926  rowCursor += sparseRowSize * f.typeSize;
927  indicesCursor += sparseRowSize;
928  }
929  return services::Status();
930  }
931 
932  template <typename T>
933  services::Status releaseTFeature( BlockDescriptor<T> &block )
934  {
935  if(block.getRWFlag() & (int)writeOnly)
936  return services::Status();
937  block.reset();
938  return services::Status();
939  }
940 
941  template <typename T>
942  services::Status getSparseTBlock( size_t idx, size_t nrows, int rwFlag, CSRBlockDescriptor<T> &block )
943  {
944  size_t ncols = getNumberOfColumns();
945  size_t nobs = getNumberOfRows();
946  block.setDetails( ncols, idx, rwFlag );
947  size_t* rowOffsets = _rowOffsets.get();
948 
949  if (idx >= nobs)
950  {
951  block.resizeValuesBuffer( 0 );
952  return services::Status();
953  }
954 
955  nrows = ( idx + nrows < nobs ) ? nrows : nobs - idx;
956 
957  NumericTableFeature &f = (*_ddict)[0];
958 
959 
960  size_t nValues = rowOffsets[idx + nrows] - rowOffsets[idx];
961 
962  if( data_feature_utils::getIndexNumType<T>() == f.indexType )
963  {
964  block.setValuesPtr(&_ptr, _ptr.get() +(rowOffsets[idx] - 1) * f.typeSize, nValues);
965  }
966  else
967  {
968  if( !block.resizeValuesBuffer(nValues) ) { return services::Status(); }
969 
970  services::SharedPtr<byte> location(_ptr, _ptr.get() +(rowOffsets[idx] - 1) * f.typeSize);
971  data_feature_utils::getVectorUpCast(f.indexType, data_feature_utils::getInternalNumType<T>())
972  ( nValues, location.get(), block.getBlockValuesPtr() );
973  }
974 
975  services::SharedPtr<size_t> shiftedColumns(_colIndices, _colIndices.get() + (rowOffsets[idx] - 1));
976  block.setColumnIndicesPtr( shiftedColumns, nValues );
977 
978  if( idx == 0 )
979  {
980  block.setRowIndicesPtr( _rowOffsets, nrows );
981  }
982  else
983  {
984  if( !block.resizeRowsBuffer(nrows) ) { return services::Status(); }
985 
986  size_t *row_offsets = block.getBlockRowIndicesSharedPtr().get();
987 
988  for(size_t i = 0; i < nrows + 1; i++)
989  {
990  row_offsets[i] = rowOffsets[idx + i] - rowOffsets[idx] + 1;
991  }
992  }
993  return services::Status();
994  }
995 
996  template <typename T>
997  services::Status releaseSparseTBlock(CSRBlockDescriptor<T> &block)
998  {
999  if (block.getRWFlag() & (int)writeOnly)
1000  {
1001  NumericTableFeature &f = (*_ddict)[0];
1002  if (f.indexType != data_feature_utils::getIndexNumType<T>())
1003  {
1004  size_t nrows = block.getNumberOfRows();
1005  size_t idx = block.getRowsOffset();
1006  size_t nValues = _rowOffsets.get()[idx + nrows] - _rowOffsets.get()[idx];
1007 
1008  services::SharedPtr<byte> ptr = services::reinterpretPointerCast<byte, T>(block.getBlockValuesSharedPtr());
1009  services::SharedPtr<byte> location = services::SharedPtr<byte>(ptr, _ptr.get() + (_rowOffsets.get()[idx] - 1) * f.typeSize);
1010 
1011  data_feature_utils::getVectorDownCast(f.indexType, data_feature_utils::getInternalNumType<T>())
1012  (nValues, ptr.get(), location.get());
1013  }
1014  }
1015  block.reset();
1016  return services::Status();
1017  }
1018 
1019  virtual services::Status setNumberOfColumnsImpl(size_t ncol) DAAL_C11_OVERRIDE
1020  {
1021  _ddict->setNumberOfFeatures( ncol );
1022  _ddict->setAllFeatures( _defaultFeature );
1023  return services::Status();
1024  }
1025 
1026 };
1027 typedef services::SharedPtr<CSRNumericTableIface> CSRNumericTableIfacePtr;
1028 typedef services::SharedPtr<CSRNumericTable> CSRNumericTablePtr;
1030 } // namespace interface1
1031 using interface1::CSRNumericTableIface;
1032 using interface1::CSRNumericTableIfacePtr;
1033 using interface1::CSRBlockDescriptor;
1034 using interface1::CSRNumericTable;
1035 using interface1::CSRNumericTablePtr;
1036 
1037 }
1038 } // namespace daal
1039 #endif
daal::data_management::interface1::CSRBlockDescriptor::getDataSize
size_t getDataSize() const
Definition: csr_numeric_table.h:128
daal::data_management::interface1::CSRBlockDescriptor::getNumberOfRows
size_t getNumberOfRows() const
Definition: csr_numeric_table.h:122
daal::data_management::interface1::CSRBlockDescriptor::setRowIndicesPtr
void setRowIndicesPtr(size_t *ptr, size_t nRows)
Definition: csr_numeric_table.h:149
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:521
daal::data_management::interface1::BlockDescriptor::getBlockPtr
DataType * getBlockPtr() const
Definition: numeric_table.h:95
daal
Definition: algorithm_base_common.h:57
daal::data_management::interface1::CSRBlockDescriptor::getBlockValuesSharedPtr
services::SharedPtr< DataType > getBlockValuesSharedPtr() const
Definition: csr_numeric_table.h:100
daal::data_management::interface1::BlockDescriptor::getAdditionalBufferPtr
void * getAdditionalBufferPtr() const
Definition: numeric_table.h:250
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:603
daal::data_management::interface1::CSRNumericTable::getDataSize
size_t getDataSize() DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:800
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:575
daal::data_management::interface1::CSRNumericTable::resize
virtual services::Status resize(size_t nrows) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:509
daal::data_management::interface1::CSRBlockDescriptor::getBlockValuesPtr
DataType * getBlockValuesPtr() const
Definition: csr_numeric_table.h:84
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:716
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:536
daal::data_management::interface1::CSRNumericTableIface::zeroBased
Definition: csr_numeric_table.h:314
daal::data_management::interface1::CSRNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:632
daal::services::ErrorMemoryAllocationFailed
Definition: error_indexes.h:170
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:594
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:71
daal::data_management::interface1::CSRNumericTableIface::oneBased
Definition: csr_numeric_table.h:315
daal::dram
Definition: daal_defines.h:158
daal::data_management::interface1::CSRNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< float > &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< int > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:598
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:646
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:552
daal::data_management::interface1::CSRBlockDescriptor::setRowIndicesPtr
void setRowIndicesPtr(services::SharedPtr< size_t > ptr, size_t nRows)
Definition: csr_numeric_table.h:178
daal::algorithms::multivariate_outlier_detection::location
Definition: outlier_detection_multivariate_types.h:98
daal::data_management::interface1::BlockDescriptor::resizeBuffer
bool resizeBuffer(size_t nColumns, size_t nRows, size_t auxMemorySize=0)
Definition: numeric_table.h:177
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:590
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:418
daal::services::ErrorUnsupportedCSRIndexing
Definition: error_indexes.h:143
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:626
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:607
daal::data_management::interface1::CSRNumericTable::releaseSparseBlock
services::Status releaseSparseBlock(CSRBlockDescriptor< double > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:659
daal::data_management::interface1::CSRBlockDescriptor::resizeValuesBuffer
bool resizeValuesBuffer(size_t nValues)
Definition: csr_numeric_table.h:199
daal::data_management::interface1::NumericTable
Class for a data management component responsible for representation of data in the numeric format...
Definition: numeric_table.h:600
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:654
daal::data_management::interface1::CSRNumericTable
Class that provides methods to access data stored in the CSR layout.
Definition: csr_numeric_table.h:387
daal::data_management::interface1::CSRBlockDescriptor::getNumberOfColumns
size_t getNumberOfColumns() const
Definition: csr_numeric_table.h:116
daal::data_management::interface1::CSRBlockDescriptor::resizeRowsBuffer
bool resizeRowsBuffer(size_t nRows)
Definition: csr_numeric_table.h:224
daal::data_management::interface1::CSRNumericTable::releaseBlockOfRows
services::Status releaseBlockOfRows(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:611
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:312
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:445
daal::data_management::interface1::CSRBlockDescriptor::freeValuesBuffer
void freeValuesBuffer()
Definition: csr_numeric_table.h:262
daal::data_management::interface1::CSRBlockDescriptor::reset
void reset()
Definition: csr_numeric_table.h:187
daal::data_management::interface1::CSRNumericTable::getCSRIndexing
CSRIndexing getCSRIndexing() const
Definition: csr_numeric_table.h:708
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:616
daal::data_management::interface1::CSRNumericTable::allocateDataMemory
services::Status allocateDataMemory(size_t dataSize, daal::MemType type=daal::dram)
Definition: csr_numeric_table.h:677
daal::data_management::interface1::BlockDescriptor
Base class that manages buffer memory for read/write operations required by numeric tables...
Definition: numeric_table.h:81
daal::data_management::interface1::CSRNumericTableIface
Abstract class that defines the interface of CSR numeric tables.
Definition: csr_numeric_table.h:305
daal::data_management::interface1::NumericTableFeature::setType
void setType()
Definition: data_dictionary.h:117
daal::services::ErrorIncorrectNumberOfObservations
Definition: error_indexes.h:97
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:469
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:495
daal::data_management::interface1::BlockDescriptor::setDetails
void setDetails(size_t columnIdx, size_t rowIdx, int rwFlag)
Definition: numeric_table.h:221
daal::data_management::interface1::CSRNumericTable::releaseSparseBlock
services::Status releaseSparseBlock(CSRBlockDescriptor< float > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:663
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:650
daal::data_management::interface1::CSRBlockDescriptor::freeRowsBuffer
void freeRowsBuffer()
Definition: csr_numeric_table.h:274
daal::data_management::interface1::NumericTableFeature
Data structure describes the Numeric Table feature.
Definition: data_dictionary.h:74
daal::services::ArgumentName
Definition: error_indexes.h:76
daal::data_management::interface1::CSRNumericTable::releaseBlockOfColumnValues
services::Status releaseBlockOfColumnValues(BlockDescriptor< int > &block) DAAL_C11_OVERRIDE
Definition: csr_numeric_table.h:640
daal::MemType
MemType
Definition: daal_defines.h:156
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:667
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:621
daal::services::ErrorMethodNotSupported
Definition: error_indexes.h:95

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