matrix_base.h

Go to the documentation of this file.

#ifndef matrix_BASE_H
#define matrix_BASE_H

#include "qgd/QGDTypes.h"
#include <cstring>
#include <iostream>
#include <tbb/scalable_allocator.h>
#include <tbb/tbb.h>






template<typename scalar>
class matrix_base {

public:
  size_t rows;
  size_t cols;
  scalar* data;

protected:

  bool conjugated;
  bool transposed;
  bool owner;
  tbb::spin_mutex* reference_mutex;
  int64_t* references;



public:

matrix_base() {

  // The number of rows
  rows = 0;
  // The number of columns
  cols = 0;
  // pointer to the stored data
  data = NULL;
  // logical variable indicating whether the matrix needs to be conjugated in CBLAS operations
  conjugated = false;
  // logical variable indicating whether the matrix needs to be transposed in CBLAS operations
  transposed = false;
  // logical value indicating whether the class instance is the owner of the stored data or not. (If true, the data array is released in the destructor)
  owner = false;
  // mutual exclusion to count the references for class instances referring to the same data.
  /* memory allocation new/delete in pytest call somehow fall back to malloc/free. In global pytest call this end up with invalid pointer freeing.
  As a workaround these pointers are initialized by malloc and released by free*/
  reference_mutex = (tbb::spin_mutex*)malloc(sizeof(tbb::spin_mutex));
  new (reference_mutex) tbb::spin_mutex();
  // the number of the current references of the present object
  references = (int64_t*)malloc(sizeof(new int64_t));
  (*references)=1;
}


matrix_base( scalar* data_in, size_t rows_in, size_t cols_in) {

  // The number of rows
  rows = rows_in;
  // The number of columns
  cols = cols_in;
  // pointer to the stored data
  data = data_in;
  // logical variable indicating whether the matrix needs to be conjugated in CBLAS operations
  conjugated = false;
  // logical variable indicating whether the matrix needs to be transposed in CBLAS operations
  transposed = false;
  // logical value indicating whether the class instance is the owner of the stored data or not. (If true, the data array is released in the destructor)
  owner = false;
  // mutual exclusion to count the references for class instances referring to the same data.
  /* memory allocation new/delete in pytest call somehow fall back to malloc/free. In global pytest call this end up with invalid pointer freeing.
  As a workaround these pointers are initialized by malloc and released by free*/
  reference_mutex = (tbb::spin_mutex*)malloc(sizeof(tbb::spin_mutex));
  new (reference_mutex) tbb::spin_mutex();
  // the number of the current references of the present object
  references = (int64_t*)malloc(sizeof(new int64_t));
  (*references)=1;
}



matrix_base( size_t rows_in, size_t cols_in) {

  // The number of rows
  rows = rows_in;
  // The number of columns
  cols = cols_in;
  // pointer to the stored data
  data = (scalar*)scalable_aligned_malloc( rows*cols*sizeof(scalar), CACHELINE);
  assert(data);
  // logical variable indicating whether the matrix needs to be conjugated in CBLAS operations
  conjugated = false;
  // logical variable indicating whether the matrix needs to be transposed in CBLAS operations
  transposed = false;
  // logical value indicating whether the class instance is the owner of the stored data or not. (If true, the data array is released in the destructor)
  owner = true;
  // mutual exclusion to count the references for class instances referring to the same data.
  /* memory allocation new/delete in pytest call somehow fall back to malloc/free. In global pytest call this end up with invalid pointer freeing.
  As a workaround these pointers are initialized by malloc and released by free*/
  reference_mutex = (tbb::spin_mutex*)malloc(sizeof(tbb::spin_mutex));
  new (reference_mutex) tbb::spin_mutex();
  // the number of the current references of the present object
  references = (int64_t*)malloc(sizeof(new int64_t));
  (*references)=1;


}


matrix_base(const matrix_base<scalar> &in) {

    data = in.data;
    rows = in.rows;
    cols = in.cols;
    transposed = in.transposed;
    conjugated = in.conjugated;
    owner = in.owner;

    reference_mutex = in.reference_mutex;
      references = in.references;

    {
      tbb::spin_mutex::scoped_lock my_lock{*reference_mutex};
      (*references)++;
    }



}



~matrix_base() {
  release_data();
}

bool is_conjugated() {
  return conjugated;
}

void conjugate() {

  conjugated = !conjugated;

}


bool is_transposed() {

  return transposed;

}


void transpose()  {

  transposed = !transposed;

}




scalar* get_data() {

  return data;

}


void replace_data( scalar* data_in, bool owner_in) {

    release_data();
    data = data_in;
    owner = owner_in;

    /* memory allocation new/delete in pytest call somehow fall back to malloc/free. In global pytest call this end up with invalid pointer freeing.
    As a workaround these pointers are initialized by malloc and released by free*/
    reference_mutex = (tbb::spin_mutex*)malloc(sizeof(tbb::spin_mutex));
    new (reference_mutex) tbb::spin_mutex();
    references = (int64_t*)malloc(sizeof(new int64_t));
    (*references)=1;

}


void release_data() {

    if (references==NULL) return;
    bool call_delete = false;

{

    tbb::spin_mutex::scoped_lock my_lock{*reference_mutex};

    if (references==NULL) return;
    call_delete = ((*references)==1);


    if (call_delete) {
      // release the data when matrix is the owner
      if (owner) {
        scalable_aligned_free(data);
      }
      free(references);
    }
    else {
        (*references)--;
    }

    data = NULL;
    references = NULL;

}

  if ( call_delete && reference_mutex !=NULL) {
    reference_mutex->~spin_mutex();
    free(reference_mutex);
    reference_mutex=NULL;
  }

}



void set_owner( bool owner_in)  {

    owner=owner_in;

}

void operator= (const matrix_base& mtx ) {

  // releasing the containing data
  release_data();

  // The number of rows
  rows = mtx.rows;
  // The number of columns
  cols = mtx.cols;
  // pointer to the stored data
  data = mtx.data;
  // logical variable indicating whether the matrix needs to be conjugated in CBLAS operations
  conjugated = mtx.conjugated;
  // logical variable indicating whether the matrix needs to be transposed in CBLAS operations
  transposed = mtx.transposed;
  // logical value indicating whether the class instance is the owner of the stored data or not. (If true, the data array is released in the destructor)
  owner = mtx.owner;

  reference_mutex = mtx.reference_mutex;
  references = mtx.references;

  {
      tbb::spin_mutex::scoped_lock my_lock{*reference_mutex};
      (*references)++;
  }

}


scalar& operator[](size_t idx) {
    return data[idx];
}




matrix_base<scalar> copy() {

  matrix_base<scalar> ret = matrix_base<scalar>(rows, cols);

  // logical variable indicating whether the matrix needs to be conjugated in CBLAS operations
  ret.conjugated = conjugated;
  // logical variable indicating whether the matrix needs to be transposed in CBLAS operations
  ret.transposed = transposed;
  // logical value indicating whether the class instance is the owner of the stored data or not. (If true, the data array is released in the destructor)
  ret.owner = true;

  memcpy( ret.data, data, rows*cols*sizeof(scalar));

  return ret;

}



size_t size() {

  return rows*cols;

}


void print_matrix() {
    std::cout << std::endl << "The stored matrix:" << std::endl;
    for ( size_t row_idx=0; row_idx < rows; row_idx++ ) {
        for ( size_t col_idx=0; col_idx < cols; col_idx++ ) {
            size_t element_idx = row_idx*cols + col_idx;
              std::cout << " " << data[element_idx].real << " " << data[element_idx].imag << "*i";
        }
        std::cout << std::endl;
    }
    std::cout << std::endl << std::endl << std::endl;

}







}; //matrix_base





#endif