CuArray< T > Class Template Reference

Class CuArray represents a vector of an integer or struct of type T. More...

#include <cu-array.h>

Inheritance diagram for CuArray< T >:

Collaboration diagram for CuArray< T >:

Public Member Functions
	CuArray ()
	Default constructor, initialized data_ to NULL and dim_ to 0 via constructor of CuArrayBase. More...
	CuArray (MatrixIndexT dim, MatrixResizeType resize_type=kSetZero)
	Constructor with memory initialisation. More...
	CuArray (const std::vector< T > &src)
	Constructor from CPU-based int vector. More...
	CuArray (const CuArray< T > &src)
	Copy constructor. More...
	~CuArray ()
	Destructor. More...
void	Resize (MatrixIndexT dim, MatrixResizeType resize_type=kSetZero)
	Allocate the memory. More...
void	Destroy ()
	Deallocate the memory and set dim_ and data_ to zero. More...
void	CopyFromVec (const std::vector< T > &src)
	This function resizes if needed. More...
void	CopyFromArray (const CuArrayBase< T > &src)
	This function resizes if needed. More...
CuArray< T > &	operator= (const CuArray< T > &in)
CuArray< T > &	operator= (const std::vector< T > &in)
void	Swap (CuArray< T > *other)
	Shallow swap with another CuArray<T>. More...
void	Read (std::istream &is, bool binary)
	I/O. More...
void	Write (std::ostream &is, bool binary) const
Public Member Functions inherited from CuArrayBase< T >
MatrixIndexT	Dim () const
	Return the vector dimension. More...
const T *	Data () const
	Get raw pointer. More...
T *	Data ()
void	SetZero ()
	Sets the memory for the object to zero, via memset. More...
void	CopyFromArray (const CuArrayBase< T > &src)
	The caller is responsible to ensure dim is equal between *this and src. More...
void	CopyFromVec (const std::vector< T > &src)
	The caller is responsible to ensure dim is equal between *this and src. More...
void	CopyToVec (std::vector< T > *dst) const
	This function resizes *dst if needed. More...
void	CopyToHost (T *dst) const
	Version of the above function that copies contents to a host array (i.e. More...
void	Set (const T &value)
	Set to a constant value. More...
void	Sequence (const T base)
	Fill with the sequence [base ... More...
void	Add (const T &value)
	Add a constant value. More...
T	Min () const
	Get minimum value (for now implemented on CPU, reimplement if slow). More...
T	Max () const
	Get minimum value (for now implemented on CPU, reimplement if slow). More...
template<>
void	Set (const int32 &value)
template<>
void	Sequence (const int32 base)
template<>
void	Add (const int32 &value)
template<>
void	Sequence (const int32 base)
template<>
void	Set (const int32 &value)
template<>
void	Add (const int32 &value)

Additional Inherited Members
Protected Member Functions inherited from CuArrayBase< T >
	CuArrayBase ()
	Default constructor: make it protected so the user cannot instantiate this class. More...
Protected Attributes inherited from CuArrayBase< T >
T *	data_
	GPU data pointer (if GPU not available, will point to CPU memory). More...
MatrixIndexT	dim_
	dimension of the vector More...

Detailed Description

template<typename T>
class kaldi::CuArray< T >

Class CuArray represents a vector of an integer or struct of type T.

If we are using a GPU then the memory is on the GPU, otherwise it's on the CPU. This class owns the data that it contains from a memory allocation perspective; see also CuSubArrary which does not own the data it contains.

Definition at line 32 of file cu-array.h.

Constructor & Destructor Documentation

CuArray() [1/4]

CuArray ( )

inline

Default constructor, initialized data_ to NULL and dim_ to 0 via constructor of CuArrayBase.

Definition at line 129 of file cu-array.h.

{ }

CuArray() [2/4]

CuArray ( MatrixIndexT  dim, MatrixResizeType  resize_type = kSetZero  )

inlineexplicit

Constructor with memory initialisation.

resize_type may be kSetZero or kUndefined.

Definition at line 133 of file cu-array.h.

     { Resize(dim, resize_type); }

CuArray() [3/4]

CuArray ( const std::vector< T > &  src )

inlineexplicit

Constructor from CPU-based int vector.

Definition at line 137 of file cu-array.h.

{ CopyFromVec(src); }

CuArray() [4/4]

CuArray ( const CuArray< T > &  src )

inline

Copy constructor.

We don't make this explicit because we want to be able to create a std::vector<CuArray>.

Definition at line 141 of file cu-array.h.

{ CopyFromArray(src); }

~CuArray()

~CuArray ( )

inline

Destructor.

Definition at line 144 of file cu-array.h.

{ Destroy(); }

Member Function Documentation

CopyFromArray()

void CopyFromArray

(

const CuArrayBase< T > &

src

)

This function resizes if needed.

Definition at line 139 of file cu-array-inl.h.

                                                        {
  this->Resize(src.Dim(), kUndefined);
  if (this->dim_ == 0) return;
#if HAVE_CUDA == 1
  if (CuDevice::Instantiate().Enabled()) {
    CuTimer tim;
    CU_SAFE_CALL(cudaMemcpyAsync(this->data_, src.data_, this->dim_ * sizeof(T),
                                 cudaMemcpyDeviceToDevice,
                                 cudaStreamPerThread));
    CuDevice::Instantiate().AccuProfile(__func__, tim);
  } else
#endif
  {
    memcpy(this->data_, src.data_, this->dim_ * sizeof(T));
  }
}

CopyFromVec()

void CopyFromVec

(

const std::vector< T > &

src

)

This function resizes if needed.

Note: copying to GPU is done via memcpy, and any constructors or assignment operators are not called.

Definition at line 120 of file cu-array-inl.h.

Referenced by ConvolutionComputation::ComputeDerived(), kaldi::nnet3::CopyPairVector(), NnetComputer::GetPointers(), GeneralDropoutComponent::PrecomputeIndexes(), MatrixRandomizer::Randomize(), kaldi::UnitTestCuDiffXent(), kaldi::UnitTestCuMathCopy(), kaldi::UnitTestCuMathRandomize(), and kaldi::UnitTestCuMathSplice().

                                                    {
  Resize(src.size(), kUndefined);
  if (src.empty()) return;
#if HAVE_CUDA == 1
  if (CuDevice::Instantiate().Enabled()) {
    CuTimer tim;
    CU_SAFE_CALL(cudaMemcpyAsync(this->data_, &src.front(), 
          src.size()*sizeof(T), cudaMemcpyHostToDevice, cudaStreamPerThread));
    CU_SAFE_CALL(cudaStreamSynchronize(cudaStreamPerThread));
    CuDevice::Instantiate().AccuProfile(__func__, tim);
  } else
#endif
  {
    memcpy(this->data_, &src.front(), src.size()*sizeof(T));
  }
}

Destroy()

void Destroy

(

)

Deallocate the memory and set dim_ and data_ to zero.

Does not call any destructors of the objects stored.

Definition at line 82 of file cu-array-inl.h.

                         {
#if HAVE_CUDA == 1
  if (CuDevice::Instantiate().Enabled()) {
    if (this->data_ != NULL) {
      CuDevice::Instantiate().Free(this->data_);
    }
  } else
#endif
  {
    if (this->data_ != NULL)
      free(this->data_);
  }
  this->dim_ = 0;
  this->data_ = NULL;
}

operator=() [1/2]

CuArray<T>& operator= ( const CuArray< T > &  in )

inline

Definition at line 161 of file cu-array.h.

                                               {
    this->CopyFromArray(in); return *this;
  }

operator=() [2/2]

CuArray<T>& operator= ( const std::vector< T > &  in )

inline

Definition at line 165 of file cu-array.h.

                                                 {
    this->CopyFromVec(in); return *this;
  }

Read()

void Read	(	std::istream &	is,
		bool	binary
	)

I/O.

Definition at line 300 of file cu-array-inl.h.

Referenced by Splice::InitData(), and Splice::ReadData().

                                                 {
  std::vector<T> tmp;
  ReadIntegerVector(in, binary, &tmp);
  (*this) = tmp;
}

Resize()

void Resize	(	MatrixIndexT	dim,
		MatrixResizeType	resize_type = kSetZero
	)

Allocate the memory.

resize_type may be kSetZero or kUndefined. kCopyData not yet supported (can be implemented if needed).

Definition at line 43 of file cu-array-inl.h.

Referenced by kaldi::UnitTestCuArray().

                                                                      {
  KALDI_ASSERT((resize_type == kSetZero || resize_type == kUndefined) && dim >= 0);
  if (this->dim_ == dim) {
    if (resize_type == kSetZero)
      this->SetZero();
    return;
  }

  Destroy();

  if (dim == 0) return;

#if HAVE_CUDA == 1
  if (CuDevice::Instantiate().Enabled()) {
    CuTimer tim;
    this->data_ = static_cast<T*>(CuDevice::Instantiate().Malloc(dim * sizeof(T)));
    this->dim_ = dim;
    if (resize_type == kSetZero) this->SetZero();
    CuDevice::Instantiate().AccuProfile("CuArray::Resize", tim);
  } else
#endif
  {
    this->data_ = static_cast<T*>(malloc(dim * sizeof(T)));
    // We allocate with malloc because we don't want constructors being called.
    // We basically ignore memory alignment issues here-- we assume the malloc
    // implementation is forgiving enough that it will automatically align on
    // sensible boundaries.
    if (this->data_ == 0)
      KALDI_ERR << "Memory allocation failed when initializing CuVector "
                << "with dimension " << dim << " object size in bytes: "
                << sizeof(T);
  }

  this->dim_ = dim;
  if (resize_type == kSetZero)
    this->SetZero();
}

Swap()

void Swap

(

CuArray< T > *

other

)

Shallow swap with another CuArray<T>.

Definition at line 341 of file cu-array-inl.h.

                                       {
  std::swap(this->dim_, other->dim_);
  std::swap(this->data_, other->data_);
}

Write()

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

Definition at line 307 of file cu-array-inl.h.

Referenced by Splice::WriteData(), and CopyComponent::WriteData().

                                                         {
  std::vector<T> tmp(this->Dim());
  this->CopyToVec(&tmp);
  WriteIntegerVector(out, binary, tmp);
}

---

The documentation for this class was generated from the following files:

• cudamatrix/cu-array.h
• cudamatrix/cu-array-inl.h