cu-array.h

Go to the documentation of this file.

// cudamatrix/cu-array.h

// Copyright 2009-2012  Karel Vesely
//                2013  Johns Hopkins University (author: Daniel Povey)
//                2017  Shiyin Kang

// 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_ARRAY_H_
#define KALDI_CUDAMATRIX_CU_ARRAY_H_

#include "matrix/kaldi-vector.h"


namespace kaldi {

template <typename T> class CuArray;
template <typename T> class CuSubArray;


template<typename T>
class CuArrayBase {
  friend class CuArray<T>;
  friend class CuSubArray<T>;
 public:
  MatrixIndexT Dim() const { return dim_;  }

  const T* Data() const { return data_; }

  T* Data() { return data_; }

  void SetZero();

  void CopyFromArray(const CuArrayBase<T> &src);

  void CopyFromVec(const std::vector<T> &src);

  void CopyToVec(std::vector<T> *dst) const;

  void CopyToHost(T *dst) const;


  void Set(const T &value);

  void Sequence(const T base);

  void Add(const T &value);

  T Min() const;

  T Max() const;

 protected:
  CuArrayBase<T>(): data_(NULL), dim_(0) { }


  T *data_;  
  MatrixIndexT dim_;     

};

template<typename T>
class CuArray: public CuArrayBase<T> {
 public:

  CuArray<T>() { }

  explicit CuArray<T>(MatrixIndexT dim, MatrixResizeType resize_type = kSetZero)
     { Resize(dim, resize_type); }

  explicit CuArray<T>(const std::vector<T> &src) { CopyFromVec(src); }

  CuArray<T>(const CuArray<T> &src) { CopyFromArray(src); }

  ~CuArray() { Destroy(); }

  void Resize(MatrixIndexT dim, MatrixResizeType resize_type = kSetZero);

  void Destroy();

  void CopyFromVec(const std::vector<T> &src);

  void CopyFromArray(const CuArrayBase<T> &src);

  CuArray<T> &operator= (const CuArray<T> &in) {
    this->CopyFromArray(in); return *this;
  }

  CuArray<T> &operator= (const std::vector<T> &in) {
    this->CopyFromVec(in); return *this;
  }

  void Swap(CuArray<T> *other);

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

};


template<typename T>
class CuSubArray: public CuArrayBase<T> {
 public:
  explicit CuSubArray<T>(const CuArrayBase<T> &src,
                         MatrixIndexT offset, MatrixIndexT dim);

  CuSubArray(const T* data, MatrixIndexT length) {
    // Yes, we're evading C's restrictions on const here, and yes, it can be used
    // to do wrong stuff; unfortunately the workaround would be very difficult.
    this->data_ = const_cast<T*>(data);
    this->dim_ = length;
  }
};



template<typename T>
std::ostream &operator << (std::ostream &out, const CuArray<T> &vec);

} // namespace

#include "cudamatrix/cu-array-inl.h"

#endif