Ignore:
Timestamp:
Feb 18, 2008, 4:13:53 AM (14 years ago)
Author:
Jari Häkkinen
Message:

Fixes #299. Memory leak in matrix was found and removed.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/yat/utility/matrix.cc

    r1064 r1098  
    4545
    4646  matrix::matrix(void)
    47     : blas_result_(NULL), m_(NULL), view_(NULL), view_const_(NULL),
    48       proxy_m_(NULL)
     47    : blas_result_(NULL), m_(NULL)
    4948  {
    5049  }
     
    5251
    5352  matrix::matrix(const size_t& r, const size_t& c, double init_value)
    54     : blas_result_(NULL), m_(gsl_matrix_alloc(r,c)), view_(NULL),
    55       view_const_(NULL), proxy_m_(m_)
     53    : blas_result_(NULL), m_(gsl_matrix_alloc(r,c))
    5654  {
    5755    if (!m_)
     
    6260
    6361  matrix::matrix(const matrix& o)
    64     : blas_result_(NULL), m_(o.create_gsl_matrix_copy()), view_(NULL),
    65       view_const_(NULL), proxy_m_(m_)
    66   {
    67   }
    68 
    69 
    70   matrix::matrix(matrix& m, size_t offset_row, size_t offset_column,
    71                  size_t n_row, size_t n_column)
    72     : blas_result_(NULL), view_const_(NULL)
    73   {
    74     view_ = new gsl_matrix_view(gsl_matrix_submatrix(m.m_,
    75                                                      offset_row,offset_column,
    76                                                      n_row,n_column));
    77     if (!view_)
    78       throw utility::GSL_error("matrix::matrix failed to setup view");
    79     proxy_m_ = m_ = &(view_->matrix);
     62    : blas_result_(NULL), m_(o.create_gsl_matrix_copy())
     63  {
    8064  }
    8165
     
    8468  matrix::matrix(std::istream& is, char sep)
    8569    throw (utility::IO_error,std::exception)
    86     : blas_result_(NULL), view_(NULL), view_const_(NULL)
     70    : blas_result_(NULL)
    8771  {
    8872    // read the data file and store in stl vectors (dynamically
     
    140124    is.clear(std::ios::goodbit);
    141125    // convert the data to a gsl matrix
    142     proxy_m_ = m_ = gsl_matrix_alloc ( nof_rows, nof_columns );
     126    m_ = gsl_matrix_alloc ( nof_rows, nof_columns );
    143127    if (!m_)
    144128      throw utility::GSL_error("matrix::matrix failed to allocate memory");
     
    157141    if (blas_result_)
    158142      gsl_matrix_free(blas_result_);
     143    blas_result_=NULL;
     144  }
     145
     146
     147  void matrix::all(const double value)
     148  {
     149    assert(m_);
     150    gsl_matrix_set_all(m_, value);
    159151  }
    160152
     
    196188
    197189
    198   const matrix& matrix::clone(const matrix& other)
    199   {
    200     if (this!=&other) {
    201 
    202       delete_allocated_memory();
    203 
    204       if (other.view_) {
    205         view_ = new gsl_matrix_view(*other.view_);
    206         proxy_m_ = m_ = &(view_->matrix);
    207       }
    208       else if (other.view_const_) {
    209         view_const_ = new gsl_matrix_const_view(*other.view_const_);
    210         proxy_m_ = &(view_const_->matrix);
    211       }
    212       else if (other.m_)
    213         proxy_m_ = m_ = other.create_gsl_matrix_copy();
    214 
    215       // no need to delete blas_result_ if the number of rows fit, it
    216       // may be useful later.
    217       if (blas_result_ && (blas_result_->size1!=rows())) {
    218         gsl_matrix_free(blas_result_);
    219         blas_result_=NULL;
    220       }
    221     }
    222     return *this;
    223   }
     190  VectorView matrix::column_view(size_t col)
     191  {
     192    VectorView res(*this, col, false);
     193    return res;
     194  }
     195
     196
     197  const VectorConstView matrix::column_const_view(size_t col) const
     198  {
     199    return VectorConstView(*this, col, false);
     200  }
    224201
    225202
    226203  size_t matrix::columns(void) const
    227204  {
    228     if (!proxy_m_)
    229       return 0;
    230     return proxy_m_->size2;
     205    return (m_ ? m_->size2 : 0);
    231206  }
    232207
     
    237212    if (!m)
    238213      throw utility::GSL_error("matrix::create_gsl_matrix_copy failed to allocate memory");
    239     if (gsl_matrix_memcpy(m,proxy_m_))
     214    if (gsl_matrix_memcpy(m,m_))
    240215      throw utility::GSL_error("matrix::create_gsl_matrix_copy dimension mis-match");
    241216    return m;
     
    245220  void matrix::delete_allocated_memory(void)
    246221  {
    247     if (view_)
    248       delete view_;
    249     else if (view_const_)
    250       delete view_const_;
    251     else if (m_)
     222    if (m_)
    252223      gsl_matrix_free(m_);
    253     blas_result_=NULL;
    254     proxy_m_=m_=NULL;
     224    m_=NULL;
    255225  }
    256226
     
    319289  const gsl_matrix* matrix::gsl_matrix_p(void) const
    320290  {
    321     return proxy_m_;
     291    return m_;
    322292  }
    323293
     
    329299
    330300
    331   bool matrix::isview(void) const
    332   {
    333     return view_ || view_const_;
    334   }
    335 
    336 
    337301  void matrix::mul(const matrix& other)
    338302  {
     
    348312    delete_allocated_memory();
    349313
    350     proxy_m_ = m_ = gsl_matrix_alloc(r,c);
     314    m_ = gsl_matrix_alloc(r,c);
    351315    if (!m_)
    352316      throw utility::GSL_error("matrix::matrix failed to allocate memory");
     
    364328  size_t matrix::rows(void) const
    365329  {
    366     if (!proxy_m_)
    367       return 0;
    368     return proxy_m_->size1;
    369   }
    370 
    371 
    372   void matrix::all(const double value)
    373   {
    374     assert(m_);
    375     gsl_matrix_set_all(m_, value);
    376   }
    377 
    378 
    379   VectorView matrix::column_view(size_t col)
    380   {
    381     VectorView res(*this, col, false);
    382     return res;
    383   }
    384 
    385 
    386   const VectorConstView matrix::column_const_view(size_t col) const
    387   {
    388     return VectorConstView(*this, col, false);
     330    return (m_ ? m_->size1 : 0);
    389331  }
    390332
     
    442384      gsl_matrix_transpose_memcpy(transposed,m_);
    443385      gsl_matrix_free(m_);
    444       proxy_m_ = m_ = transposed;
     386      m_ = transposed;
    445387      if (blas_result_) {
    446388        gsl_matrix_free(blas_result_);
     
    467409    assert(row<rows());
    468410    assert(column<columns());
    469     const double* d=gsl_matrix_const_ptr(proxy_m_, row, column);
     411    const double* d=gsl_matrix_const_ptr(m_, row, column);
    470412    if (!d)
    471413      throw utility::GSL_error("matrix::operator()",GSL_EINVAL);
     
    488430  const matrix& matrix::operator=( const matrix& other )
    489431  {
    490     assert(m_);
    491     if (this!=&other)
     432    assert(other.m_);
     433    if (this!=&other) {
     434      if ( !m_ || (other.m_->size1!=m_->size1) || (other.m_->size2!=m_->size2) )
     435        resize(other.m_->size1,other.m_->size2);
    492436      if (gsl_matrix_memcpy(m_, other.gsl_matrix_p()))
    493437        throw utility::GSL_error("matrix::create_gsl_matrix_copy dimension mis-match");
     438    }
    494439    return *this;
    495440  }
     
    499444  {
    500445    assert(m_);
    501     int status=gsl_matrix_add(m_, other.proxy_m_);
     446    int status=gsl_matrix_add(m_, other.m_);
    502447    if (status)
    503448      throw utility::GSL_error(std::string("matrix::operator+=", status));
     
    517462  {
    518463    assert(m_);
    519     int status=gsl_matrix_sub(m_, other.proxy_m_);
     464    int status=gsl_matrix_sub(m_, other.m_);
    520465    if (status)
    521466      throw utility::GSL_error(std::string("matrix::operator-=", status));
     
    545490        throw utility::GSL_error("matrix::operator*= failed to allocate memory");
    546491    }
    547     gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, m_, other.proxy_m_, 0.0,
    548                    blas_result_);
     492    gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, m_, other.m_, 0.0, blas_result_);
    549493    gsl_matrix* tmp=m_;
    550     proxy_m_ = m_ = blas_result_;
     494    m_ = blas_result_;
    551495    blas_result_=tmp;
    552496    return *this;
     
    593537    size_t columns=templat.columns();
    594538    if (rows!=flag.rows() && columns!=flag.columns())
    595       flag.clone(matrix(rows,columns,1.0));
     539      flag.resize(rows,columns,1.0);
    596540    else
    597541      flag.all(1.0);
Note: See TracChangeset for help on using the changeset viewer.