cu-block-matrix.h

Go to the documentation of this file.

// cudamatrix/cu-block-matrix.h

// Copyright 2013      Johns Hopkins University (author: Daniel Povey)

// See ../../COPYING for clarification regarding multiple authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//  http://www.apache.org/licenses/LICENSE-2.0
//
// THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
// WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
// MERCHANTABLITY OR NON-INFRINGEMENT.
// See the Apache 2 License for the specific language governing permissions and
// limitations under the License.



#ifndef KALDI_CUDAMATRIX_CU_BLOCK_MATRIX_H_
#define KALDI_CUDAMATRIX_CU_BLOCK_MATRIX_H_

#include <sstream>

#include <vector>
#include "cudamatrix/cu-common.h"


namespace kaldi {


template<typename Real>
class CuBlockMatrix {
 public:
  friend class CuMatrixBase<Real>;
  
  CuBlockMatrix();

  CuBlockMatrix(const std::vector<CuMatrix<Real> > &data);

  ~CuBlockMatrix() { Destroy(); }
  
  CuBlockMatrix(const CuBlockMatrix &other); 

  CuBlockMatrix &operator= (const CuBlockMatrix &other); 

  void Write(std::ostream &os, bool binary) const;
  
  void Read(std::istream &is, bool binary);

  MatrixIndexT NumRows() const { return num_rows_; }

  MatrixIndexT NumCols() const { return data_.num_cols_; }

  MatrixIndexT NumBlocks() const { return block_data_.size(); }
  
  // Returns max num-columns of any block
  MatrixIndexT MaxBlockCols() const ;

  // Returns max num-rows of any block
  MatrixIndexT MaxBlockRows() const;
    
  const CuSubMatrix<Real> Block(MatrixIndexT b) const;

  CuSubMatrix<Real> Block(MatrixIndexT b); // return CuMatrixBase to disallow resizes.


  void AddMatMat(BaseFloat alpha,
                 const CuMatrix<Real> &A, MatrixTransposeType transA,
                 const CuMatrix<Real> &B, MatrixTransposeType transB,
                 BaseFloat beta);


  void CopyFromMat(const CuMatrix<Real> &M);

  void NormalizeColumns();

  void Swap(CuBlockMatrix *other);
  
 protected:
  CuMatrix<Real> data_; // This is a single matrix into which
  // we pack all the blocks (possibly with spaces left over)

  struct BlockMatrixData{
    MatrixIndexT num_rows;
    MatrixIndexT num_cols;
    MatrixIndexT row_offset;
    MatrixIndexT col_offset;
  };
  

#if HAVE_CUDA == 1
  const CuBlockMatrixData* CuData() const { return cu_data_; }
#endif
 private:
  
  void FreeCudaData();
  void SetCudaData();


  void Destroy();

  std::vector<BlockMatrixData> block_data_;
  
  MatrixIndexT num_rows_; // sum of num_rows of elements of block_data_.
#if HAVE_CUDA == 1
  CuBlockMatrixData *cu_data_; // We store the pointers and some additional info
                               // on the GPU card in a form more suited to
                               // use by CUDA kernels.
#endif
}; // class CuBlockMatrix

template<typename Real>
std::ostream &operator << (std::ostream &out, const CuBlockMatrix<Real> &mat);


} // namespace Kaldi
#endif