CMatrixOperation Class Reference

This class include matrix operations, matrix data type and related data. More...

#include "MatrixOperation.h"

Collaboration diagram for CMatrixOperation:

Classes
class	CCSR
	Data and operation representation of CSR(Compressed Sparse Row) More...
class	CDMatrix
	Data and operation representation of Matrix. More...
struct	CSR_ELEMENT_DATA
	CSR element data. More...
class	CVector
	This class for describing vector for Lanczos method. More...
struct	FILL_MATRIX_DATA
	Hamiltonian building data. More...

Public Types
typedef std::vector< double >	double_vector_t
typedef std::vector< unsigned int >	uint_vector_t
typedef struct CMatrixOperation::CSR_ELEMENT_DATA *	LPCSR_ELEMENT_DATA
typedef struct CMatrixOperation::FILL_MATRIX_DATA *	LPFILL_MATRIX_DATA

Public Member Functions
	CMatrixOperation ()
	Constructor. More...
	~CMatrixOperation ()
	Destructor. More...

Static Public Member Functions
static CMatrixOperation::CCSR *	BuildCSRFromOneDimArray (double *pReal, double *pImaginary, unsigned int nRowOrder, unsigned int nColumnOrder)
	Building CSR from one dimension array. More...
static CMatrixOperation::CCSR *	BuildCSRFromFileTemp (FILE *fDataFile, unsigned int nRowOrder, unsigned int nColumnOrder, int nDataCount)
	Building CSR from file using double, double, double, double order. More...
static CMatrixOperation::CCSR *	BuildCSRFromFile_ (FILE *fDataFile, unsigned int nRowOrder, unsigned int nColumnOrder, int nDataCount)
	Building CSR from file using int, int, double, double order. More...
static CMatrixOperation::CCSR *	BuildCSRFromFileUnsortdata (FILE *fDataFile, unsigned int nRowOrder, unsigned int nColumnOrder, int nDataCount)
	uilding CSR form file and before building CSR sorting data More...
static void	FreeCSR (CMatrixOperation::CCSR *pCSR)
	Deallocating CSR memory. More...
static void	DumpCSR (CMatrixOperation::CCSR *pCSR, const char *pstrFileName)
	For dubugging save CSR information into file. More...
static void	AllocateLocalCSR (CMatrixOperation::CCSR **mine, CMatrixOperation::CCSR **left, CMatrixOperation::CCSR **right, int nLBIndex)
static void	FreeLocalCSR (CMatrixOperation::CCSR *mine, CMatrixOperation::CCSR *left, CMatrixOperation::CCSR *right)
static void	BuildLocalCSR (CMatrixOperation::CCSR *source, CMatrixOperation::CCSR *mine, CMatrixOperation::CCSR *left, CMatrixOperation::CCSR *right)
static void	UpdateLocalCSR (CMatrixOperation::CCSR *source, CMatrixOperation::CCSR *mine, CMatrixOperation::CCSR *left, CMatrixOperation::CCSR *right)
static int	Compare (const void *pA, const void *pB)
	For qick sort compare operation. More...
static void	MVMulEx_AsyncCommWithLocalBlocks (CMatrixOperation::CCSR *mylocalblock, CMatrixOperation::CCSR *leftlocalblock, CMatrixOperation::CCSR *rightlocalblock, CVector *pVector, CVector *pResult, double *X, double *Xrt, double *Xlt)
	Matrix and vector multiple operation using by block csr. More...
static void	MVMulOptimal (CCSR *pAMatrix, CVector *pVector, CVector *pResult, int nLBIndex)
	Matrix and vector multiple operation for multiple call. More...
static void	MVMulEx_Optimal (CCSR *pAMatrix, CVector *pVector, CVector *pResult, unsigned int, unsigned int, CVector *, int nSizePHI, int nLBIndex)
	Matrix and vector multiple operation for 1 layer exchanging communication. More...
static void	MVMulOptimal_Nooffload (CCSR *pAMatrix, CVector *pVector, CVector *pResult, int nLBIndex)
	Added by jhkang end. More...
static void	MVMul (CCSR *pAMatrix, CVector *pVector, CVector *pResult, int nLBIndex)
	Matrix and vector multiple operation. More...
static bool	VVDot (CVector *pVector1, CVector *pVector2, CComplex *pResult)
	Between vectors dot product operation. More...
static void	MVMul (CDMatrix *pMatrix, CVector *pVector, CVector *pResult)
	Matrix and vector multiple operation for dense matrix. More...
static void	MMMul (CDMatrix *pMatrix, CDMatrix *pMatrixOperand, CDMatrix *pResult)
	Matrix and matrix multiple operation. More...
static bool	IsSame (double operand1, double operand2, double tol)
	Compare two double variable. More...
static bool	IsSameA (double operand1, double operand2, double tol)
	Compare two double variable. More...
static bool	IsSame (CComplex operand1, CComplex operand2, double tol)
	Compare two vectors with tolerance. More...
static bool	IsSame (CVector *pVector1, CVector *pVector2)
	Compare two vectors with general tolerance(1e-8) More...
static int	Gram_schmidt (CVector *pVect1, CVector *pVect2)
	Added by jhkang, matrix operation. More...
static void	AddVectors (CVector *pVector1, CVector *pVector2, CVector *pResult)
static void	SubstractVectors (CVector *pVector1, CVector *pVector2, CVector *pResult)
static void	ScalarMulVectors (double fValue, CVector *pVector1, CVector *pResult)
	Added by jhkang end. More...

Static Public Attributes
static CComplex *	pValueBuffer = NULL
	For MPI Optimized operation using. More...
static unsigned int *	pRow = NULL
	For MPI Optimized operation using. More...
static unsigned int *	pColumn = NULL
	For MPI Optimized operation using. More...

Detailed Description

This class include matrix operations, matrix data type and related data.

Date

27/May/2014

Definition at line 22 of file MatrixOperation.h.

Member Typedef Documentation

typedef std::vector<double> CMatrixOperation::double_vector_t

Definition at line 26 of file MatrixOperation.h.

typedef struct CMatrixOperation::CSR_ELEMENT_DATA * CMatrixOperation::LPCSR_ELEMENT_DATA

typedef struct CMatrixOperation::FILL_MATRIX_DATA * CMatrixOperation::LPFILL_MATRIX_DATA

typedef std::vector<unsigned int> CMatrixOperation::uint_vector_t

Definition at line 29 of file MatrixOperation.h.

Constructor & Destructor Documentation

CMatrixOperation::CMatrixOperation

(

)

Constructor.

---

        CCSR Class member function - End

        CMatrixOperation Class member function - End

---

Definition at line 1836 of file MatrixOperation.cpp.

{
}

CMatrixOperation::~CMatrixOperation

(

)

Destructor.

Definition at line 1840 of file MatrixOperation.cpp.

{
}

Member Function Documentation

void CMatrixOperation::AddVectors ( CVector *  pVector1, CVector *  pVector2, CVector *  pResult  )

static

Definition at line 3297 of file MatrixOperation.cpp.

References ERROR_WRONG_ORDER_OPERATION, CMatrixOperation::CVector::GetAt(), CMatrixOperation::CVector::GetSize(), and CMatrixOperation::CVector::SetAt().

{
    unsigned int nSize = pVector1->GetSize();
    if (nSize != pVector2->GetSize())
    {
        throw ERROR_WRONG_ORDER_OPERATION;
    }

    for (unsigned int i = 0; i < nSize; i++)
    {
        pResult->SetAt(i, pVector1->GetAt(i) + pVector2->GetAt(i));
    }
}

Here is the call graph for this function:

void CMatrixOperation::AllocateLocalCSR ( CMatrixOperation::CCSR **  mine, CMatrixOperation::CCSR **  left, CMatrixOperation::CCSR **  right, int  nLBIndex  )

static

---

        CMatrixOperation Class member function - End

---

Parameters

mine	Local CSR buffer
left	Left node CSR buffer
right	right node CSR buffer

Definition at line 2946 of file MatrixOperation.cpp.

References ERROR_MALLOC, CMPIManager::GetCurrentRank(), CMPIManager::GetLoadBalanceCount(), CMPIManager::GetMPIComm(), and CMPIManager::GetTotalNodeCount().

Referenced by CLanczosLaunching::LaunchingLanczos().

{
    unsigned int                    nRowCount, nColumnCount;
    int                             myrank = CMPIManager::GetCurrentRank();
    int                             ncpus = CMPIManager::GetTotalNodeCount();
    int                             left_neighbor = (myrank-1+ncpus)%ncpus; // top neighbor
    int                             right_neighbor = (myrank+1)%ncpus; // bottom neighbor
    unsigned int                    temp;

    nRowCount = CMPIManager::GetLoadBalanceCount(myrank, nLBIndex);
    *mine = NULL; *left = NULL; *right = NULL;
    
    // Allocate mine
    *mine = new CMatrixOperation::CCSR();
    if (*mine == NULL)
        throw ERROR_MALLOC;
    nColumnCount = CMPIManager::GetLoadBalanceCount(myrank, nLBIndex);
    (*mine)->SetRowCount(nRowCount);
    (*mine)->SetColumnCount(nColumnCount);
    (*mine)->BuildDataBuffer(); temp = 0;
    for (int jj=0; jj<myrank; jj++)
        temp += CMPIManager::GetLoadBalanceCount(jj, nLBIndex);
    (*mine)->SetFirstRowIndex((double)temp); // FirstRowIndex will be used in a bit different way: Starting "column" index.

//  printf("%d %d %d %d %d %d\n", myrank, left_neighbor, right_neighbor, (int)(*mine)->GetFirstRowIndex(), (*mine)->GetColumnCount(), (*mine)->GetNoneZeroCount());

    // Allocate left
    *left = new CMatrixOperation::CCSR();
    if (*left == NULL)
        throw ERROR_MALLOC;
    nColumnCount = CMPIManager::GetLoadBalanceCount(left_neighbor, nLBIndex);
    (*left)->SetRowCount(nRowCount);
    (*left)->SetColumnCount(nColumnCount);
    (*left)->BuildDataBuffer(); temp = 0;
    for (int jj=0; jj<left_neighbor; jj++)
        temp += CMPIManager::GetLoadBalanceCount(jj, nLBIndex);
    (*left)->SetFirstRowIndex((double)temp); // FirstRowIndex will be used in a bit different way: Starting "column" index.

    //Allocate right
    *right = new CMatrixOperation::CCSR();
    if (*right == NULL)
        throw ERROR_MALLOC;
    nColumnCount = CMPIManager::GetLoadBalanceCount(right_neighbor, nLBIndex);
    (*right)->SetRowCount(nRowCount);
    (*right)->SetColumnCount(nColumnCount);
    (*right)->BuildDataBuffer(); temp = 0;
    for(int jj=0; jj<right_neighbor; jj++)
        temp += CMPIManager::GetLoadBalanceCount(jj, nLBIndex);
    (*right)->SetFirstRowIndex((double)temp); // FirstRowIndex will be used in a bit different way: Starting "column" index.

    MPI_Barrier(CMPIManager::GetMPIComm());
}

Here is the call graph for this function:

Here is the caller graph for this function:

CMatrixOperation::CCSR * CMatrixOperation::BuildCSRFromFile_ ( FILE *  fDataFile, unsigned int  nRowOrder, unsigned int  nColumnOrder, int  nDataCount  )

static

Building CSR from file using int, int, double, double order.

Parameters

fDataFile	Source file name
nRowOrder	The row order of matrix
nColumnOrder	The column order of matrix
nDataCount	Nonzero value count

Returns

CSR

Definition at line 1885 of file MatrixOperation.cpp.

References CMatrixOperation::CCSR::BuildDataBuffer(), CMatrixOperation::CCSR::FinishPush(), CMatrixOperation::CCSR::PushNoneZeroValue(), REPEAT_COUNT, CMatrixOperation::CCSR::SetColumnCount(), and CMatrixOperation::CCSR::SetRowCount().

{
    CMatrixOperation::CCSR                  *pCSR = new CMatrixOperation::CCSR();
    size_t                                  readSize;
    unsigned int                            i;
    CMatrixOperation::CSR_ELEMENT_DATA  Data[REPEAT_COUNT];
    memset(Data, NULL, sizeof(CMatrixOperation::CSR_ELEMENT_DATA)*REPEAT_COUNT);

    if (NULL == pCSR)
        return pCSR;

    pCSR->SetRowCount(nRowOrder);
    pCSR->SetColumnCount(nColumnOrder);
    pCSR->BuildDataBuffer();

    while (0 != (readSize = fread(Data, sizeof(CSR_ELEMENT_DATA), REPEAT_COUNT, fDataFile)))
    {
        for (i = 0; i < readSize; i++)
        {
            if (0 == Data[i].nRow && 0 == Data[i].nColumn)
                break;

            pCSR->PushNoneZeroValue(Data[i].fReal, Data[i].fImaginary, (unsigned int)Data[i].nRow - 1, (unsigned int)Data[i].nColumn - 1);
        }
    }

    pCSR->FinishPush();

    return pCSR;
}

Here is the call graph for this function:

CMatrixOperation::CCSR * CMatrixOperation::BuildCSRFromFileTemp ( FILE *  fDataFile, unsigned int  nRowOrder, unsigned int  nColumnOrder, int  nDataCount  )

static

Building CSR from file using double, double, double, double order.

Parameters

fDataFile	Source file name
nRowOrder	The row order of matrix
nColumnOrder	The column order of matrix
nDataCount	Nonzero value count

Returns

CSR

Definition at line 1853 of file MatrixOperation.cpp.

References CMatrixOperation::CCSR::BuildDataBuffer(), CMatrixOperation::CSR_ELEMENT_DATA::fImaginary, CMatrixOperation::CCSR::FinishPush(), CMatrixOperation::CSR_ELEMENT_DATA::fReal, CMatrixOperation::CSR_ELEMENT_DATA::nColumn, CMatrixOperation::CSR_ELEMENT_DATA::nRow, CMatrixOperation::CCSR::PushNoneZeroValue(), REPEAT_COUNT, CMatrixOperation::CCSR::SetColumnCount(), and CMatrixOperation::CCSR::SetRowCount().

{
    CMatrixOperation::CCSR                  *pCSR = new CMatrixOperation::CCSR();
    size_t                                  readSize;
    unsigned int                            i;
    CMatrixOperation::CSR_ELEMENT_DATA  Data[REPEAT_COUNT];

    if (NULL == pCSR)
        return pCSR;

    pCSR->SetRowCount(nRowOrder);
    pCSR->SetColumnCount(nColumnOrder);
    pCSR->BuildDataBuffer();

    while (0 != (readSize = fread(Data, sizeof(CSR_ELEMENT_DATA), REPEAT_COUNT, fDataFile)))
    {
        for (i = 0; i < readSize; i++)
            pCSR->PushNoneZeroValue(Data[i].fReal, Data[i].fImaginary, (unsigned int)Data[i].nRow - 1, (unsigned int)Data[i].nColumn - 1);
    }

    pCSR->FinishPush();

    return pCSR;
}

Here is the call graph for this function:

CMatrixOperation::CCSR * CMatrixOperation::BuildCSRFromFileUnsortdata ( FILE *  fDataFile, unsigned int  nRowOrder, unsigned int  nColumnOrder, int  nDataCount  )

static

uilding CSR form file and before building CSR sorting data

Parameters

fDataFile	Source file name
nRowOrder	The row order of matrix
nColumnOrder	The column order of matrix
nDataCount	Nonzero value count

Returns

CSR

Definition at line 1951 of file MatrixOperation.cpp.

References CMatrixOperation::CCSR::BuildDataBuffer(), Compare(), CMatrixOperation::CCSR::FinishPush(), CMatrixOperation::CCSR::PushNoneZeroValue(), CMatrixOperation::CCSR::SetColumnCount(), and CMatrixOperation::CCSR::SetRowCount().

{
    LPCSR_ELEMENT_DATA                      lpData = (LPCSR_ELEMENT_DATA)malloc(sizeof(CSR_ELEMENT_DATA)* nDataCount);
    CMatrixOperation::CCSR                  *pCSR = new CMatrixOperation::CCSR();
    int                                     i;

    if (lpData == NULL)
        return pCSR;

    for (i = 0; i < nDataCount; i++)
    {
        fread(&lpData[i], sizeof(CSR_ELEMENT_DATA), 1, fDataFile);
    }

    pCSR->SetRowCount(nRowOrder);
    pCSR->SetColumnCount(nColumnOrder);
    pCSR->BuildDataBuffer();

    qsort(lpData, nDataCount, sizeof(CSR_ELEMENT_DATA), CMatrixOperation::Compare);

    for (i = 0; i < nDataCount; i++)
    {
        pCSR->PushNoneZeroValue(lpData[i].fReal, lpData[i].fImaginary, (unsigned int)lpData[i].nRow - 1, (unsigned int)lpData[i].nColumn - 1);
    }
    pCSR->FinishPush();

    return pCSR;

}

Here is the call graph for this function:

CMatrixOperation::CCSR * CMatrixOperation::BuildCSRFromOneDimArray ( double *  pReal, double *  pImaginary, unsigned int  nRowOrder, unsigned int  nColumnOrder  )

static

Building CSR from one dimension array.

Parameters

pReal	Real number part of Source of matrix
pImaginary	Imaginary number part of Source of matrix
nRowOrder	The row order of matrix
nColumnOrder	The column order of matrix

Returns

CSR

Definition at line 1987 of file MatrixOperation.cpp.

References CMatrixOperation::CCSR::BuildDataBuffer(), CMatrixOperation::CCSR::FinishPush(), CMatrixOperation::CCSR::PushNoneZeroValue(), CMatrixOperation::CCSR::SetColumnCount(), and CMatrixOperation::CCSR::SetRowCount().

{
    unsigned int                row, col;
    CMatrixOperation::CCSR      *pCSR = new CMatrixOperation::CCSR();

    if (NULL == pCSR)
        return pCSR;

    pCSR->SetRowCount(nRowOrder);
    pCSR->SetColumnCount(nColumnOrder);
    pCSR->BuildDataBuffer();

    unsigned int nIndex = 0;
    bool bPushedInRow = false;
    for (row = 0; row < nRowOrder; row++)
    {
        for (col = 0; col < nColumnOrder; col++)
        {
            if (0 != pReal[row*nColumnOrder + col] || 0 != pImaginary[row*nColumnOrder + col])
            {
                pCSR->PushNoneZeroValue(pReal[nIndex], pImaginary[nIndex], row, col);
                bPushedInRow = true;
            }
            nIndex++;
        }
    }
    pCSR->FinishPush();

    return pCSR;
}

Here is the call graph for this function:

void CMatrixOperation::BuildLocalCSR ( CMatrixOperation::CCSR *  source, CMatrixOperation::CCSR *  mine, CMatrixOperation::CCSR *  left, CMatrixOperation::CCSR *  right  )

static

Parameters

source	Copying source CSR
mine	Local CSR buffer
left	Left node CSR buffer
right	right node CSR buffer

Definition at line 3005 of file MatrixOperation.cpp.

References CMatrixOperation::CCSR::FinishPush(), CMatrixOperation::CCSR::GetColumnCount(), CMatrixOperation::CCSR::GetFirstRowIndex(), CComplex::GetImaginaryNumber(), CComplex::GetRealNumber(), CMatrixOperation::CCSR::GetRowCount(), CMatrixOperation::CCSR::GetValue(), CMatrixOperation::CCSR::m_vectColumn, CMatrixOperation::CCSR::m_vectRow, pColumn, pRow, and CMatrixOperation::CCSR::PushNoneZeroValue().

Referenced by CLanczosLaunching::LaunchingLanczos().

{
    CMatrixOperation::pRow = source->m_vectRow.data();
    CMatrixOperation::pColumn = source->m_vectColumn.data();
    //CKNMemoryManager::LPVECTOR_ELEMENTS       lpMatrixValueElement = NULL;
    CComplex                                *pData = NULL;
    unsigned int my_nnz, left_nnz, right_nnz;
    int isthisrowfilled;

    //lpMatrixValueElement = source->GetValueElement();

    // 1. Build left local block.
    
    left_nnz = 0;   

    for (unsigned int ii = 0; ii < source->GetRowCount(); ii++)
    {
        isthisrowfilled = -1;
        unsigned int nSubStart = CMatrixOperation::pRow[ii], nSubEnd = CMatrixOperation::pRow[ii + 1];
        unsigned int startColIndex = (int)left->GetFirstRowIndex(), endColIndex = startColIndex + left->GetColumnCount() - 1;

        for (unsigned int jj = nSubStart; jj < nSubEnd; jj++)
        {
            unsigned int nColIndex = CMatrixOperation::pColumn[jj];

            if(startColIndex <= nColIndex && nColIndex <= endColIndex)
            {   
                isthisrowfilled = 0;
                left_nnz++;
                pData = source->GetValue(jj);
                //left->PushNoneZeroValue(lpMatrixValueElement->pfReal[jj], lpMatrixValueElement->pfImaginary[jj], ii, nColIndex-startColIndex);
                left->PushNoneZeroValue(pData->GetRealNumber(), pData->GetImaginaryNumber(), ii, nColIndex-startColIndex);
            }
        }

        if(isthisrowfilled == -1)
        {
            left_nnz++;
            left->PushNoneZeroValue(0.0, 0.0, ii, 0);
        }
    }

    left->FinishPush();

//  if(CMPIManager::IsRootRank())
//      printf("Left block conversion completed: left_nnz = %d (computed), %d (CSR-allocated)\n", left_nnz, left->GetNoneZeroCount());  
                        
    // 2. Build right block
    
    right_nnz = 0;

    for (unsigned int ii = 0; ii < source->GetRowCount(); ii++)
    {
        isthisrowfilled = -1;
        unsigned int nSubStart = CMatrixOperation::pRow[ii], nSubEnd = CMatrixOperation::pRow[ii + 1];
        unsigned int startColIndex = (int)right->GetFirstRowIndex(), endColIndex = startColIndex + right->GetColumnCount() - 1;
        
        for (unsigned int jj = nSubStart; jj < nSubEnd; jj++)
        {
            unsigned int nColIndex = CMatrixOperation::pColumn[jj];
            if(startColIndex <= nColIndex && nColIndex <= endColIndex)
            {   
                isthisrowfilled = 0;
                right_nnz++;
                pData = source->GetValue(jj);
                //right->PushNoneZeroValue(lpMatrixValueElement->pfReal[jj], lpMatrixValueElement->pfImaginary[jj], ii, nColIndex-startColIndex);
                right->PushNoneZeroValue(pData->GetRealNumber(), pData->GetImaginaryNumber(), ii, nColIndex-startColIndex);
            }
        }

        if(isthisrowfilled == -1)
        {
            right_nnz++;
            right->PushNoneZeroValue(0.0, 0.0, ii, 0);
        }
    }
                    
    right->FinishPush();

//  if(CMPIManager::IsRootRank())
//      printf("Right block conversion completed: right_nnz = %d (computed), %d (CSR-allocated)\n", right_nnz, right->GetNoneZeroCount());

    // 3. Build my block
    
    my_nnz = 0;

    for (unsigned int ii = 0; ii < source->GetRowCount(); ii++)
    {
        unsigned int nSubStart = CMatrixOperation::pRow[ii], nSubEnd = CMatrixOperation::pRow[ii + 1];
        unsigned int startColIndex = (int)mine->GetFirstRowIndex(), endColIndex = startColIndex + mine->GetColumnCount() - 1;

        for(unsigned int jj = nSubStart; jj < nSubEnd; jj++)
        {
            unsigned int nColIndex = CMatrixOperation::pColumn[jj];
            if(startColIndex <= nColIndex && nColIndex <= endColIndex)
            {
                my_nnz++;
                pData = source->GetValue(jj);
                //mine->PushNoneZeroValue(lpMatrixValueElement->pfReal[jj], lpMatrixValueElement->pfImaginary[jj], ii, nColIndex-startColIndex);
                mine->PushNoneZeroValue(pData->GetRealNumber(), pData->GetImaginaryNumber(), ii, nColIndex-startColIndex);
            }               
        }
    }

    mine->FinishPush();

//  if(CMPIManager::IsRootRank())
//      printf("My block conversion completed: my_nnz = %d (computed), %d (CSR-allocated)\n", my_nnz, mine->GetNoneZeroCount());

}

Here is the call graph for this function:

Here is the caller graph for this function:

int CMatrixOperation::Compare ( const void *  pA, const void *  pB  )

static

For qick sort compare operation.

Parameters

pA	Compare target CSR element
pB	Compare target CSR element

Returns

Comparing result

Definition at line 1921 of file MatrixOperation.cpp.

References CMatrixOperation::CSR_ELEMENT_DATA::nColumn, and CMatrixOperation::CSR_ELEMENT_DATA::nRow.

Referenced by BuildCSRFromFileUnsortdata().

{
    CMatrixOperation::LPCSR_ELEMENT_DATA                lpA = (CMatrixOperation::LPCSR_ELEMENT_DATA)pA;
    CMatrixOperation::LPCSR_ELEMENT_DATA                lpB = (CMatrixOperation::LPCSR_ELEMENT_DATA)pB;

    if (lpA->nRow > lpB->nRow)
        return 1;
    else if (lpA->nRow < lpB->nRow)
        return -1;

    if (lpA->nRow == lpB->nRow)
    {
        if (lpA->nColumn > lpB->nColumn)
            return 1;
        else if (lpA->nColumn < lpB->nColumn)
            return -1;
        else if (lpB->nColumn == lpB->nColumn)
            return 0;
    }

    return -1;
}

Here is the caller graph for this function:

static void CMatrixOperation::DumpCSR ( CMatrixOperation::CCSR *  pCSR, const char *  pstrFileName  )

inlinestatic

For dubugging save CSR information into file.

Definition at line 247 of file MatrixOperation.h.

References CMatrixOperation::CCSR::DumpCSR().

Here is the call graph for this function:

void CMatrixOperation::FreeCSR ( CMatrixOperation::CCSR *  pCSR )

static

Deallocating CSR memory.

Parameters

pCSR	CSR class pointer that want to deallocating memeory

Definition at line 2138 of file MatrixOperation.cpp.

References CMatrixOperation::CCSR::Finalize().

Referenced by CTBMS_Solver::FinalEvn(), CSPLoop::Finalize(), and FreeLocalCSR().

{
    if (NULL == pCSR)
        return;

    pCSR->Finalize();

    delete pCSR;
    pCSR = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CMatrixOperation::FreeLocalCSR ( CMatrixOperation::CCSR *  mine, CMatrixOperation::CCSR *  left, CMatrixOperation::CCSR *  right  )

static

Parameters

mine	Local CSR buffer
left	Left node CSR buffer
right	right node CSR buffer

Definition at line 3238 of file MatrixOperation.cpp.

References FreeCSR().

Referenced by CLanczosLaunching::LaunchingLanczos().

{
    if (mine != NULL)
    {
        CMatrixOperation::FreeCSR(mine);
        mine = NULL;
    }
    if (left != NULL)
    {
        CMatrixOperation::FreeCSR(left);
        left = NULL;
    }
    if (right != NULL)
    {
        CMatrixOperation::FreeCSR(right);
        right = NULL;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CMatrixOperation::Gram_schmidt ( CVector *  pVect1, CVector *  pVect2  )

static

Added by jhkang, matrix operation.

Doing gam schmidt orthogonalization

Parameters

pVect1	Orthogonalization standard
pVect2	Orthogonalization target

Definition at line 2880 of file MatrixOperation.cpp.

References GENERAL_TOLERANCE, CComplex::GetRealNumber(), IsSameA(), CTimeMeasurement::MeasurementEnd(), CTimeMeasurement::MeasurementStart(), CMatrixOperation::CVector::MinusVector(), CMatrixOperation::CVector::Normalize(), CMatrixOperation::CVector::ScalarMultiple(), CTimeMeasurement::VVDOT, and VVDot().

Referenced by CLanczosMethod::MergeDegeneratedEigenvalues().

{
    CComplex                result;
    CVector                 tempVector;

    CTimeMeasurement::MeasurementStart(CTimeMeasurement::VVDOT);
    CMatrixOperation::VVDot(pVect1, pVect2, &result);
    CTimeMeasurement::MeasurementEnd(CTimeMeasurement::VVDOT);
    if( IsSameA(result.GetRealNumber(), 0, GENERAL_TOLERANCE ))
        return 1;
        
    tempVector = *pVect1;
    tempVector.Normalize(true);
    pVect2->Normalize(true);
    
    CTimeMeasurement::MeasurementStart(CTimeMeasurement::VVDOT);
    CMatrixOperation::VVDot(&tempVector, pVect2, &result);
    CTimeMeasurement::MeasurementEnd(CTimeMeasurement::VVDOT);
    tempVector.ScalarMultiple(result);

    pVect2->MinusVector(&tempVector);
    pVect2->Normalize(true);

    CTimeMeasurement::MeasurementStart(CTimeMeasurement::VVDOT);
    CMatrixOperation::VVDot(pVect1, pVect2, &result);
    CTimeMeasurement::MeasurementEnd(CTimeMeasurement::VVDOT);
    if( IsSameA(result.GetRealNumber(), 0, GENERAL_TOLERANCE ))
        return 1;
    else
        return 0;


}

Here is the call graph for this function:

Here is the caller graph for this function:

bool CMatrixOperation::IsSame ( double  operand1, double  operand2, double  tol  )

static

Compare two double variable.

Parameters

operand1	First operand
operand2	Second operand
tol	Difference tolerance

Definition at line 2855 of file MatrixOperation.cpp.

Referenced by CLanczosMethod::DoResidualCheck(), CLanczosMethod::IntegrateEigenvalues(), CLanczosMethod::IntegrateEigenvaluesEx(), IsSame(), CSPLoop::MapZBandCB(), and CLanczosMethod::MergeDegeneratedEigenvalues().

{
    if (fabs(operand1 - operand2) > tol)
        return false;
    else
        return true;
}

Here is the caller graph for this function:

bool CMatrixOperation::IsSame ( CComplex  operand1, CComplex  operand2, double  tol  )

static

Compare two vectors with tolerance.

Parameters

operand1	Comparing operand 1
operand2	Comparing operand 2

Returns

Comparing result

Definition at line 3262 of file MatrixOperation.cpp.

References CComplex::GetImaginaryNumber(), and CComplex::GetRealNumber().

{
    if( fabs(fabs(operand1.GetRealNumber()) - fabs(operand2.GetRealNumber())) > tol )
        return false;

    if( fabs(fabs(operand1.GetImaginaryNumber()) - fabs(operand2.GetImaginaryNumber())) > tol )
        return false;
    else
        return true;
}

Here is the call graph for this function:

bool CMatrixOperation::IsSame ( CVector *  pVector1, CVector *  pVector2  )

static

Compare two vectors with general tolerance(1e-8)

Added by jhkang, Vector operration.

Parameters

pVector1	Comparing vector operand 1
pVector2	Comparing vector operand 2

Returns

Comparing result

Definition at line 3278 of file MatrixOperation.cpp.

References GENERAL_TOLERANCE, CMatrixOperation::CVector::GetNorm(), IsSame(), and CMatrixOperation::CVector::MinusVector().

Here is the call graph for this function:

bool CMatrixOperation::IsSameA ( double  operand1, double  operand2, double  tol  )

static

Compare two double variable.

Parameters

operand1	First operand
operand2	Second operand
tol	Difference tolerance

Definition at line 2868 of file MatrixOperation.cpp.

Referenced by Gram_schmidt(), and CLanczosMethod::MergeDegeneratedEigenvalues().

{
    if (fabs(fabs(operand1) - fabs(operand2)) > tol)
        return false;
    else
        return true;
}

Here is the caller graph for this function:

void CMatrixOperation::MMMul ( CDMatrix *  pMatrix, CDMatrix *  pMatrixOperand, CDMatrix *  pResult  )

static

Matrix and matrix multiple operation.

Parameters

pMatrix	Matrix class pointer that want to operation
pMatrixOperand	Matrix class pointer that want to operation
pResult	Matrix class pointer that saving operation result

Definition at line 2824 of file MatrixOperation.cpp.

References CComplex::Add(), CMatrixOperation::CDMatrix::BuildMatrixFirst(), CMatrixOperation::CDMatrix::GetColumnCount(), CMatrixOperation::CDMatrix::GetElement(), CMatrixOperation::CDMatrix::GetRowCount(), CComplex::MulltiplyComplex(), and CMatrixOperation::CDMatrix::SetElement().

Referenced by CHamiltonianBuilder::BuildACCANeighborFor10Band(), CHamiltonianBuilder::FillMatrixFor10Band(), and CGeometricShape::RotateMatrix().

{
    int                 i, j, k;
    int                 nRow, nColumn, nL;
    if (pMatrix->GetColumnCount() != pMatrixOperand->GetRowCount())
        return;

    pResult->BuildMatrixFirst(pMatrix->GetRowCount(), pMatrixOperand->GetColumnCount());

    nL = pMatrixOperand->GetColumnCount();
    nRow = pMatrix->GetRowCount();
    nColumn = pMatrix->GetColumnCount();
    for (k = 0; k < nL; ++k)
    {
        for (i = 0; i < nRow; ++i)
        {
            CComplex            result;
            for (j = 0; j < nColumn; ++j)
            {
                result.Add(CComplex::MulltiplyComplex(pMatrix->GetElement(i, j), pMatrixOperand->GetElement(j, k)));
            }
            pResult->SetElement(i, k, result);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CMatrixOperation::MVMul ( CCSR *  pAMatrix, CVector *  pVector, CVector *  pResult, int  nLBIndex  )

static

Matrix and vector multiple operation.

Parameters

pAMatrix	Matrix class pointer that want to operation
pVector	Vector class pointer that want to operation
pResult	Vector class pointer that saving operation result

Definition at line 2187 of file MatrixOperation.cpp.

References ERROR_WRONG_ORDER_OPERATION, CMatrixOperation::CCSR::GetColumnCount(), CMatrixOperation::CCSR::GetRowCount(), CMatrixOperation::CCSR::m_vectColumn, CMatrixOperation::CCSR::m_vectRow, CMatrixOperation::CVector::m_vectValueImaginaryBuffer, CMatrixOperation::CCSR::m_vectValueImaginaryBuffer, CMatrixOperation::CVector::m_vectValueRealBuffer, CMatrixOperation::CCSR::m_vectValueRealBuffer, CMPIManager::MergeVector(), and CMatrixOperation::CVector::SetSize().

Referenced by CLanczosResultAudit::AuditResult_EV(), CLanczosMethod::DoResidualCheck(), CLanczosMethod::MergeDegeneratedEigenvalues(), IGeometricUnitCellInfo::RotateAxis(), IGeometricUnitCellInfo::RotateNeighbor(), and CHamiltonianBuilder::RotateTransMatrixFor10Band().

{
    unsigned int                    i, j, nSize = pAMatrix->GetColumnCount();
    CVector                         *pOperandVector = NULL, VOperand;
    double                          *pMatrixReal = NULL, *pMatrixImaginary = NULL;
    double                          *pVectorReal = NULL, *pVectorImaginary = NULL;
    double                          *pResultReal = NULL, *pResultImaginary = NULL;
    unsigned int                    *pMatrixRow = NULL, *pMatrixColumn = NULL;

    VOperand = *pVector;
    pOperandVector = &VOperand;

#ifndef DISABLE_MPI_ROUTINE
    
    VOperand.SetSize(pAMatrix->GetColumnCount());
    CMPIManager::MergeVector(pVector, &VOperand, pAMatrix->GetColumnCount(), nLBIndex);
    pOperandVector = &VOperand;
#else
    pOperandVector = pVector;
#endif

    if (nSize != pOperandVector->GetSize())
    {
        throw ERROR_WRONG_ORDER_OPERATION;
        return;
    }

    nSize = pAMatrix->GetRowCount();
    pMatrixReal = pAMatrix->m_vectValueRealBuffer.data();
    pMatrixImaginary = pAMatrix->m_vectValueImaginaryBuffer.data();
    pMatrixRow = pAMatrix->m_vectRow.data();
    pMatrixColumn = pAMatrix->m_vectColumn.data();
    pVectorReal = pOperandVector->m_vectValueRealBuffer.data();
    pVectorImaginary = pOperandVector->m_vectValueImaginaryBuffer.data();
    pResultReal = pResult->m_vectValueRealBuffer.data();
    pResultImaginary = pResult->m_vectValueImaginaryBuffer.data();

    unsigned int input_real_size       = pOperandVector->m_vectValueRealBuffer.size();
    unsigned int input_imaginary_size  = pOperandVector->m_vectValueImaginaryBuffer.size();
    unsigned int output_real_size      = pResult->m_vectValueRealBuffer.size();
    unsigned int output_imaginary_size = pResult->m_vectValueImaginaryBuffer.size();

    #pragma omp parallel for
    for ( i = 0; i < nSize; i++)
    {
        double real_sum      = 0.0;
        double imaginary_sum = 0.0;
        const unsigned int nSubStart = pMatrixRow[i];
        const unsigned int nSubEnd   = pMatrixRow[i + 1];
        

        for ( j = nSubStart; j < nSubEnd; j++)
        {
            const unsigned int nColIndex = pMatrixColumn[j];
            const double m_real      = pMatrixReal[j];
            const double m_imaginary = pMatrixImaginary[j];
            const double v_real      = pVectorReal[nColIndex];
            const double v_imaginary = pVectorImaginary[nColIndex];

            real_sum      += m_real * v_real      - m_imaginary * v_imaginary;
            imaginary_sum += m_real * v_imaginary + m_imaginary * v_real;
        }

        pResultReal[i] = real_sum;
        pResultImaginary[i] = imaginary_sum;
    }
#ifndef DISABLE_MPI_ROUTINE
    VOperand.Finalize();
#endif //DISABLE_MPI_ROUTINE
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CMatrixOperation::MVMul ( CDMatrix *  pMatrix, CVector *  pVector, CVector *  pResult  )

static

Matrix and vector multiple operation for dense matrix.

Parameters

pAMatrix	Matrix class pointer that want to operation
pVector	Vector class pointer that want to operation
pResult	Vector class pointer that saving operation result

Definition at line 2797 of file MatrixOperation.cpp.

References CComplex::Add(), CMatrixOperation::CVector::GetAt(), CMatrixOperation::CDMatrix::GetColumnCount(), CMatrixOperation::CDMatrix::GetElement(), CMatrixOperation::CDMatrix::GetRowCount(), CMatrixOperation::CVector::GetSize(), CComplex::MulltiplyComplex(), CMatrixOperation::CVector::SetAt(), and CMatrixOperation::CVector::SetSize().

{
    int                 i, j, nRow, nColumn;

    if (pMatrix->GetColumnCount() != pVector->GetSize())
        return;

    pResult->SetSize(pVector->GetSize());

    nRow = pMatrix->GetRowCount();
    nColumn = pMatrix->GetColumnCount();
    for (i = 0; i < nRow; ++i)
    {
        CComplex            result;
        for (j = 0; j < nColumn; ++j)
        {
            result.Add(CComplex::MulltiplyComplex(pMatrix->GetElement(i, j), pVector->GetAt(j)));
        }
        pResult->SetAt(i, result);
    }
}

Here is the call graph for this function:

void CMatrixOperation::MVMulEx_AsyncCommWithLocalBlocks ( CMatrixOperation::CCSR *  mylocalblock, CMatrixOperation::CCSR *  leftlocalblock, CMatrixOperation::CCSR *  rightlocalblock, CVector *  pVector, CVector *  pResult, double *  X, double *  Xrt, double *  Xlt  )

static

Matrix and vector multiple operation using by block csr.

Parameters

pAMatrix	Matrix class pointer that want to operation
pVector	Vector class pointer that want to operation
pResult	Vector class pointer that saving operation result

Remarks

This function optimized for multiple call than MVMul

Definition at line 2264 of file MatrixOperation.cpp.

{
/*
    unsigned int                            nSize, B, Brt, Blt;
    double                                  *pMatrixValueReal = NULL, *pOperandVectorReal = NULL, *pResultVectorReal = NULL;
    double                                  *pMatrixValueImaginary = NULL, *pOperandVectorImaginary = NULL, *pResultVectorImaginary = NULL;
    int                                     tag = 1002;
    int                                     myrank = CMPIManager::GetCurrentRank();
    int                                     ncpus = CMPIManager::GetTotalNodeCount();
    int                                     left_neighbor = (myrank - 1 + ncpus) % ncpus;
    int                                     right_neighbor = (myrank + 1) % ncpus;
    MPI_Request                             req_sr[2];
    MPI_Status                              stat_sr[2];
    // XXX jinpil: pRow, pColumn should be local in offload directives
    unsigned int                            *pRow = mylocalblock->m_vectRow.data();
    unsigned int                            *pColumn = mylocalblock->m_vectColumn.data();

#ifndef _WIN32
    __assume_aligned(X,   64);
    __assume_aligned(X,   64);
    __assume_aligned(Xrt, 64);

    __assume_aligned(pMatrixValueReal,        64);
    __assume_aligned(pMatrixValueImaginary,   64);
    __assume_aligned(pOperandVectorReal,      64);
    __assume_aligned(pOperandVectorImaginary, 64);
    __assume_aligned(pResultVectorReal,       64);
    __assume_aligned(pResultVectorImaginary,  64);
    __assume_aligned(pRow,                    64);
    __assume_aligned(pColumn,                 64);
#endif //_WIN32

    pMatrixValueReal = mylocalblock->m_vectValueRealBuffer.data();
    pOperandVectorReal = pVector->m_vectValueRealBuffer.data();
    pResultVectorReal = pResult->m_vectValueRealBuffer.data();

    pMatrixValueImaginary = mylocalblock->m_vectValueImaginaryBuffer.data();
    pOperandVectorImaginary = pVector->m_vectValueImaginaryBuffer.data();
    pResultVectorImaginary = pResult->m_vectValueImaginaryBuffer.data();;

    nSize = mylocalblock->GetRowCount();

    if (nSize != pVector->GetSize())
    {
        throw ERROR_WRONG_ORDER_OPERATION;
        return;
    }

    B = nSize;
    Brt = 0;
    Blt = 0;

    for (int ii = 0; ii< nSize; ii++)
    {
        X[2 * ii] = pOperandVectorReal[ii];
        X[2 * ii + 1] = pOperandVectorImaginary[ii];
    }

    CTimeMeasurement::MeasurementStart(CTimeMeasurement::MV_COMM);

    MPI_Irecv(&Brt, 1, MPI_INT, right_neighbor, tag, CMPIManager::GetMPIComm(), &req_sr[0]);
    MPI_Isend(&B, 1, MPI_INT, left_neighbor, tag, CMPIManager::GetMPIComm(), &req_sr[1]);
    MPI_Waitall(2, req_sr, stat_sr); // now Brt has B of right neighbor.

    MPI_Irecv(Xrt, 2 * Brt, MPI_DOUBLE, right_neighbor, tag, CMPIManager::GetMPIComm(), &req_sr[0]); // receive from bottom neighbor
    MPI_Isend(X, 2 * B, MPI_DOUBLE, left_neighbor, tag, CMPIManager::GetMPIComm(), &req_sr[1]);   // send to top neighbor

    CTimeMeasurement::MeasurementEnd(CTimeMeasurement::MV_COMM);

    unsigned int input_size = X_largest * 2;
    unsigned int output_real_size = pResult->m_vectValueRealBuffer.size();
    unsigned int output_imaginary_size = pResult->m_vectValueImaginaryBuffer.size();


#ifdef _ENABLE_PAPI
    long long papi_values[4];
    PAPI_start(papi_event_set);
#endif

#pragma offload target(mic:phi_tid) \
    nocopy(*pMatrixValueReal       : REUSE) \
    nocopy(*pMatrixValueImaginary  : REUSE) \
    nocopy(*pRow                   : REUSE) \
    nocopy(*pColumn                : REUSE) \
    in(X[0:input_size]             : REUSE) \
    nocopy(*pResultVectorReal      : REUSE) \
    nocopy(*pResultVectorImaginary : REUSE)

#pragma omp parallel for
    for (unsigned int i = 0; i < nSize; i++)
    {
        double real_sum      = 0.0;
        double imaginary_sum = 0.0;
        const unsigned int nSubStart = pRow[i    ];
        const unsigned int nSubEnd = pRow[i + 1];
        for (unsigned int j = nSubStart; j < nSubEnd; j++)
        {
            const unsigned int nColIndex = pColumn[j];
            const double m_real = pMatrixValueReal[j];
            const double m_imaginary = pMatrixValueImaginary[j];
            const double v_real = X[2 * nColIndex];
            const double v_imaginary = X[2 * nColIndex + 1];

            real_sum += m_real * v_real - m_imaginary * v_imaginary;
            imaginary_sum += m_real * v_imaginary + m_imaginary * v_real;
        }

        pResultVectorReal[i] = real_sum;
        pResultVectorImaginary[i] = imaginary_sum;
    }

#ifdef _ENABLE_PAPI
    PAPI_stop(papi_event_set, papi_values);
    printf("[LOCAL] L2 access = %lld | L2 miss = %lld | L2 miss rate = %g %\n", papi_values[0], papi_values[1], (papi_values[1] * 100.0) / papi_values[0]);
    printf("[LOCAL] L3 access = %lld | L3 miss = %lld | L3 miss rate = %g %\n", papi_values[2], papi_values[3], (papi_values[3] * 100.0) / papi_values[2]);
#endif

    CTimeMeasurement::MeasurementStart(CTimeMeasurement::MV_COMM);

    MPI_Waitall(2, req_sr, stat_sr); // now Xrt has X of right neighbor.

    MPI_Irecv(&Blt, 1, MPI_INT, left_neighbor, tag, CMPIManager::GetMPIComm(), &req_sr[0]);
    MPI_Isend(&B, 1, MPI_INT, right_neighbor, tag, CMPIManager::GetMPIComm(), &req_sr[1]);
    MPI_Waitall(2, req_sr, stat_sr); // now Blt has B of left neighbor.


    MPI_Irecv(Xlt, 2 * Blt, MPI_DOUBLE, left_neighbor, tag, CMPIManager::GetMPIComm(), &req_sr[0]);
    MPI_Isend(X, 2 * B, MPI_DOUBLE, right_neighbor, tag, CMPIManager::GetMPIComm(), &req_sr[1]);

    CTimeMeasurement::MeasurementEnd(CTimeMeasurement::MV_COMM);

    pMatrixValueReal = rightlocalblock->m_vectValueRealBuffer.data();
    pMatrixValueImaginary = rightlocalblock->m_vectValueImaginaryBuffer.data();
    pRow = rightlocalblock->m_vectRow.data();
    pColumn = rightlocalblock->m_vectColumn.data();

#ifdef _ENABLE_PAPI
    PAPI_start(papi_event_set);
#endif

#pragma offload target(mic:phi_tid) \
    nocopy(*pMatrixValueReal       : REUSE) \
    nocopy(*pMatrixValueImaginary  : REUSE) \
    nocopy(*pRow                   : REUSE) \
    nocopy(*pColumn                : REUSE) \
    in(Xrt[0:input_size]           : REUSE) \
    nocopy(*pResultVectorReal      : REUSE) \
    nocopy(*pResultVectorImaginary : REUSE)

#pragma omp parallel for
    for (unsigned int i = 0; i < nSize; i++)
    {
        double real_sum = 0.0;
        double imaginary_sum = 0.0;
        const unsigned int nSubStart = pRow[i    ];
        const unsigned int nSubEnd = pRow[i + 1];
        for (unsigned int j = nSubStart; j < nSubEnd; j++)
        {
            const unsigned int nColIndex = pColumn[j];
            const double m_real = pMatrixValueReal[j];
            const double m_imaginary = pMatrixValueImaginary[j];
            const double v_real = Xrt[2 * nColIndex];
            const double v_imaginary = Xrt[2 * nColIndex + 1];

            real_sum += m_real * v_real - m_imaginary * v_imaginary;
            imaginary_sum += m_real * v_imaginary + m_imaginary * v_real;
        }

        pResultVectorReal[i] += real_sum;
        pResultVectorImaginary[i] += imaginary_sum;
    }

#ifdef _ENABLE_PAPI
    PAPI_stop(papi_event_set, papi_values);
    printf("[RIGHT] L2 access = %lld | L2 miss = %lld | L2 miss rate = %g %\n", papi_values[0], papi_values[1], (papi_values[1] * 100.0) / papi_values[0]);
    printf("[RIGHT] L3 access = %lld | L3 miss = %lld | L3 miss rate = %g %\n", papi_values[2], papi_values[3], (papi_values[3] * 100.0) / papi_values[2]);
#endif

    CTimeMeasurement::MeasurementStart(CTimeMeasurement::MV_COMM);
    MPI_Waitall(2, req_sr, stat_sr); // now Xlt has X of left neighbor.
    CTimeMeasurement::MeasurementEnd(CTimeMeasurement::MV_COMM);

    pMatrixValueReal = leftlocalblock->m_vectValueRealBuffer.data();
    pMatrixValueImaginary = leftlocalblock->m_vectValueImaginaryBuffer.data();
    pRow = leftlocalblock->m_vectRow.data();
    pColumn = leftlocalblock->m_vectColumn.data();

#ifdef _ENABLE_PAPI
    PAPI_start(papi_event_set);
#endif

#pragma offload target(mic:phi_tid) \
    nocopy(*pMatrixValueReal      : REUSE) \
    nocopy(*pMatrixValueImaginary : REUSE) \
    nocopy(*pRow                  : REUSE) \
    nocopy(*pColumn               : REUSE) \
    in(Xlt[0:input_size]                                : REUSE) \
    out(pResultVectorReal[0:output_real_size]           : REUSE) \
    out(pResultVectorImaginary[0:output_imaginary_size] : REUSE)

#pragma omp parallel for
    for (unsigned int i = 0; i < nSize; i++)
    {
        double real_sum = 0.0;
        double imaginary_sum = 0.0;
        const unsigned int nSubStart = pRow[i    ];
        const unsigned int nSubEnd = pRow[i + 1];
        for (unsigned int j = nSubStart; j < nSubEnd; j++)
        {
            const unsigned int nColIndex = pColumn[j];
            const double m_real = pMatrixValueReal[j];
            const double m_imaginary = pMatrixValueImaginary[j];
            const double v_real = Xlt[2 * nColIndex];
            const double v_imaginary = Xlt[2 * nColIndex + 1];

            real_sum += m_real * v_real - m_imaginary * v_imaginary;
            imaginary_sum += m_real * v_imaginary + m_imaginary * v_real;
        }

        pResultVectorReal[i] += real_sum;
        pResultVectorImaginary[i] += imaginary_sum;
    }

#ifdef _ENABLE_PAPI
    PAPI_stop(papi_event_set, papi_values);
    printf("[LEFT] L2 access = %lld | L2 miss = %lld | L2 miss rate = %g %\n", papi_values[0], papi_values[1], (papi_values[1] * 100.0) / papi_values[0]);
    printf("[LEFT] L3 access = %lld | L3 miss = %lld | L3 miss rate = %g %\n", papi_values[2], papi_values[3], (papi_values[3] * 100.0) / papi_values[2]);
#endif
*/
}

void CMatrixOperation::MVMulEx_Optimal ( CCSR *  pAMatrix, CVector *  pVector, CVector *  pResult, unsigned int  nSizeFromPrevRank, unsigned int  nSizeFromNextRank, CVector *  VTemp, int  nSizePHI, int  nLBIndex  )

static

Matrix and vector multiple operation for 1 layer exchanging communication.

Parameters

pAMatrix	Matrix class pointer that want to operation
pVector	Vector class pointer that want to operation
pResult	Vector class pointer that saving operation result
nSizeFromPrevRank	Exchanging size with previous node
nSizeFromNextRank	Exchanging size with next node
VTemp	Mering buffer MVMul vector operand
nSizePHI	Ratio for MIC operation

Definition at line 2504 of file MatrixOperation.cpp.

References ERROR_WRONG_ORDER_OPERATION, CMatrixOperation::CCSR::GetColumnCount(), CMatrixOperation::CCSR::GetRowCount(), CMPIManager::GetTotalNodeCount(), CMatrixOperation::CCSR::m_fFirstRowIndex, CMatrixOperation::CCSR::m_vectColumn, CMatrixOperation::CCSR::m_vectRow, CMatrixOperation::CVector::m_vectValueImaginaryBuffer, CMatrixOperation::CCSR::m_vectValueImaginaryBuffer, CMatrixOperation::CVector::m_vectValueRealBuffer, CMatrixOperation::CCSR::m_vectValueRealBuffer, CMPIManager::MergeVectorEx_Optimal(), CMatrixOperation::CCSR::nComponentsFirstUnitCell, and CMatrixOperation::CCSR::nComponentsLastUnitCell.

Referenced by CLanczosMethod::LanczosIterationLoop().

{
    unsigned int                        nSize = pAMatrix->GetColumnCount();
    CVector                         *pOperandVector = NULL;
    unsigned int                                            offsettmp[3];

    double                          *pMatrixReal = NULL, *pMatrixImaginary = NULL;
    double                          *pVectorReal = NULL, *pVectorImaginary = NULL;
    double                          *pResultReal = NULL, *pResultImaginary = NULL;
    unsigned int                        *pMatrixRow = NULL,  *pMatrixColumn = NULL;

#ifdef USE_XEONPHI
    char                            phi_sigval;
    unsigned int                        phi_input_offset1, phi_input_offset2, phi_input_offset3;
    unsigned int                        phi_input_size1, phi_input_size2, phi_input_size3;
    unsigned int                                            phi_output_size, phi_output_offset;
#endif //USE_XEONPHI

#ifndef DISABLE_MPI_ROUTINE
    pOperandVector = VTemp;
    CMPIManager::MergeVectorEx_Optimal(pVector, pOperandVector, pAMatrix->GetColumnCount(), pAMatrix->m_fFirstRowIndex, nSizeFromPrevRank, nSizeFromNextRank, pAMatrix->nComponentsFirstUnitCell, pAMatrix->nComponentsLastUnitCell, offsettmp, nLBIndex);
#else
    pOperandVector = pVector;
#endif

    if (nSize != pOperandVector->GetSize())
    {
        throw ERROR_WRONG_ORDER_OPERATION;
        return;
    }

    pVectorReal = pOperandVector->m_vectValueRealBuffer.data();
    pVectorImaginary = pOperandVector->m_vectValueImaginaryBuffer.data();
    pMatrixReal = pAMatrix->m_vectValueRealBuffer.data();
    pMatrixImaginary = pAMatrix->m_vectValueImaginaryBuffer.data();
    pMatrixRow = pAMatrix->m_vectRow.data();
    pMatrixColumn = pAMatrix->m_vectColumn.data();
    pResultReal = pResult->m_vectValueRealBuffer.data();
    pResultImaginary = pResult->m_vectValueImaginaryBuffer.data();
    
    nSize = pAMatrix->GetRowCount();

#ifdef USE_XEONPHI
    if (CMPIManager::GetTotalNodeCount() <= 3)
    {
        phi_input_size1 = pOperandVector->m_vectValueRealBuffer.size();
        phi_input_offset1 = 0;

#pragma offload_transfer target(mic:phi_tid) in(pVectorReal[phi_input_offset1:phi_input_size1]      : REUSE)
#pragma offload_transfer target(mic:phi_tid) in(pVectorImaginary[phi_input_offset1:phi_input_size1] : REUSE)
    }
    else
    {
        phi_input_size1 = nSizeFromPrevRank;
        phi_input_size2 = nSize;
        phi_input_size3 = nSizeFromNextRank;
        phi_input_offset1 = offsettmp[0];
        phi_input_offset2 = offsettmp[1];
        phi_input_offset3 = offsettmp[2];

#pragma offload_transfer target(mic:phi_tid) in(pVectorReal[phi_input_offset1:phi_input_size1]      : REUSE)
#pragma offload_transfer target(mic:phi_tid) in(pVectorImaginary[phi_input_offset1:phi_input_size1] : REUSE)
#pragma offload_transfer target(mic:phi_tid) in(pVectorReal[phi_input_offset2:phi_input_size2]      : REUSE)
#pragma offload_transfer target(mic:phi_tid) in(pVectorImaginary[phi_input_offset2:phi_input_size2] : REUSE)
#pragma offload_transfer target(mic:phi_tid) in(pVectorReal[phi_input_offset3:phi_input_size3]      : REUSE)
#pragma offload_transfer target(mic:phi_tid) in(pVectorImaginary[phi_input_offset3:phi_input_size3] : REUSE)
    }

    phi_output_size = nSizePHI;
    phi_output_offset = 0;

    // FIXME jinpil:
    // nocopy(pMatrixReal : REUSE)
    // correct directive syntax, but segmentation fault without *
    // Xeon Phi device cannot find the correct pointer value
    // compiler bug?
    // FIXME allocate pVectorReal, pVectorImaginary outside the Lanczos loop

#pragma offload target(mic:phi_tid) \
    nocopy(*pMatrixReal                 : REUSE) \
    nocopy(*pMatrixImaginary            : REUSE) \
    nocopy(*pMatrixRow                  : REUSE) \
    nocopy(*pMatrixColumn               : REUSE) \
    nocopy(*pVectorReal             : REUSE) \
    nocopy(*pVectorImaginary            : REUSE) \
    out(pResultReal[phi_output_offset:phi_output_size]      : REUSE) \
    out(pResultImaginary[phi_output_offset:phi_output_size] : REUSE) \
    signal(&phi_sigval)
    //*/

#pragma omp parallel for
    for (unsigned int i = 0; i < nSizePHI; i++)
    {
        double real_sum = 0.0;
        double imaginary_sum = 0.0;
        const unsigned int nSubStart = pMatrixRow[i];
        const unsigned int nSubEnd = pMatrixRow[i + 1];


        for (unsigned int j = nSubStart; j < nSubEnd; j++)
        {
            const unsigned int nColIndex = pMatrixColumn[j];
            const double m_real = pMatrixReal[j];
            const double m_imaginary = pMatrixImaginary[j];
            const double v_real = pVectorReal[nColIndex];
            const double v_imaginary = pVectorImaginary[nColIndex];

            real_sum += m_real * v_real - m_imaginary * v_imaginary;
            imaginary_sum += m_real * v_imaginary + m_imaginary * v_real;
        }

        pResultReal[i] = real_sum;
        pResultImaginary[i] = imaginary_sum;
    }
#endif // USE_XEONPHI


#pragma omp parallel for
    for (unsigned int i = nSizePHI; i < nSize; i++)
    {
        double real_sum = 0.0;
        double imaginary_sum = 0.0;
        const unsigned int nSubStart = pMatrixRow[i];
        const unsigned int nSubEnd = pMatrixRow[i + 1];


        for (unsigned int j = nSubStart; j < nSubEnd; j++)
        {
            const unsigned int nColIndex = pMatrixColumn[j];
            const double m_real = pMatrixReal[j];
            const double m_imaginary = pMatrixImaginary[j];
            const double v_real = pVectorReal[nColIndex];
            const double v_imaginary = pVectorImaginary[nColIndex];

            real_sum += m_real * v_real - m_imaginary * v_imaginary;
            imaginary_sum += m_real * v_imaginary + m_imaginary * v_real;
        }

        pResultReal[i] = real_sum;
        pResultImaginary[i] = imaginary_sum;
    }

#ifdef USE_XEONPHI
#pragma offload_wait target(mic:phi_tid) wait(&phi_sigval)
#endif // USE_XEONPHI

}

Here is the call graph for this function:

Here is the caller graph for this function:

void CMatrixOperation::MVMulOptimal ( CCSR *  pAMatrix, CVector *  pVector, CVector *  pResult, int  nLBIndex  )

static

Matrix and vector multiple operation for multiple call.

Parameters

pAMatrix	Matrix class pointer that want to operation
pVector	Vector class pointer that want to operation
pResult	Vector class pointer that saving operation result

Definition at line 2658 of file MatrixOperation.cpp.

References ERROR_WRONG_ORDER_OPERATION, CMatrixOperation::CVector::Finalize(), CMatrixOperation::CCSR::GetColumnCount(), CMatrixOperation::CCSR::GetRowCount(), CMatrixOperation::CCSR::m_fFirstRowIndex, CMatrixOperation::CCSR::m_vectColumn, CMatrixOperation::CCSR::m_vectRow, CMatrixOperation::CVector::m_vectValueImaginaryBuffer, CMatrixOperation::CCSR::m_vectValueImaginaryBuffer, CMatrixOperation::CVector::m_vectValueRealBuffer, CMatrixOperation::CCSR::m_vectValueRealBuffer, CMPIManager::MergeVectorOptimal(), and CMatrixOperation::CVector::SetSize().

Referenced by CLanczosMethod::LanczosIterationLoop().

{
    unsigned int                        i, j, nSize = pAMatrix->GetColumnCount();
    CVector                         *pOperandVector = NULL;
    double                          *pMatrixReal = NULL, *pMatrixImaginary = NULL;
    double                          *pVectorReal = NULL, *pVectorImaginary = NULL;
    double                          *pResultReal = NULL, *pResultImaginary = NULL;
    unsigned int                        *pMatrixRow = NULL, *pMatrixColumn = NULL;
#ifndef DISABLE_MPI_ROUTINE
    CVector                         VOperand;

    VOperand.SetSize(pAMatrix->GetColumnCount());
    CMPIManager::MergeVectorOptimal(pVector, &VOperand, pAMatrix->GetColumnCount(), pAMatrix->m_fFirstRowIndex, nLBIndex);
    pOperandVector = &VOperand;
#else
    pOperandVector = pVector;
#endif

    if (nSize != pOperandVector->GetSize())
    {
        throw ERROR_WRONG_ORDER_OPERATION;
        return;
    }

    nSize = pAMatrix->GetRowCount();
    pMatrixReal = pAMatrix->m_vectValueRealBuffer.data();
    pMatrixImaginary = pAMatrix->m_vectValueImaginaryBuffer.data();
    pMatrixRow = pAMatrix->m_vectRow.data();
    pMatrixColumn = pAMatrix->m_vectColumn.data();
    pVectorReal = pOperandVector->m_vectValueRealBuffer.data();
    pVectorImaginary = pOperandVector->m_vectValueImaginaryBuffer.data();
    pResultReal = pResult->m_vectValueRealBuffer.data();
    pResultImaginary = pResult->m_vectValueImaginaryBuffer.data();

#ifdef USE_XEONPHI
    unsigned int input_real_size       = pOperandVector->m_vectValueRealBuffer.size();
    unsigned int input_imaginary_size  = pOperandVector->m_vectValueImaginaryBuffer.size();
    unsigned int output_real_size      = pResult->m_vectValueRealBuffer.size();
    unsigned int output_imaginary_size = pResult->m_vectValueImaginaryBuffer.size();
#endif

// FIXME jinpil:
// nocopy(pMatrixReal : REUSE)
// correct directive syntax, but segmentation fault without *
// Xeon Phi device cannot find the correct pointer value
// compiler bug?
// FIXME allocate pVectorReal, pVectorImaginary outside the Lanczos loop

#ifdef USE_XEONPHI

#pragma offload target(mic:phi_tid) \
    nocopy(*pMatrixReal      : REUSE) \
    nocopy(*pMatrixImaginary : REUSE) \
    nocopy(*pMatrixRow       : REUSE) \
    nocopy(*pMatrixColumn    : REUSE) \
    in(pVectorReal[0:input_real_size]             : LOCAL) \
    in(pVectorImaginary[0:input_imaginary_size]   : LOCAL) \
    out(pResultReal[0:output_real_size]           : REUSE) \
    out(pResultImaginary[0:output_imaginary_size] : REUSE)
//*/

#endif

#pragma omp parallel for
    for ( i = 0; i < nSize; i++)
    {
        double real_sum      = 0.0;
        double imaginary_sum = 0.0;
        const unsigned int nSubStart = pMatrixRow[i];
        const unsigned int nSubEnd   = pMatrixRow[i + 1];
        

        for ( j = nSubStart; j < nSubEnd; j++)
        {
            const unsigned int nColIndex = pMatrixColumn[j];
            const double m_real      = pMatrixReal[j];
            const double m_imaginary = pMatrixImaginary[j];
            const double v_real      = pVectorReal[nColIndex];
            const double v_imaginary = pVectorImaginary[nColIndex];

            real_sum      += m_real * v_real      - m_imaginary * v_imaginary;
            imaginary_sum += m_real * v_imaginary + m_imaginary * v_real;
        }

        pResultReal[i] = real_sum;
        pResultImaginary[i] = imaginary_sum;
    }
#ifndef DISABLE_MPI_ROUTINE
    VOperand.Finalize();
#endif //DISABLE_MPI_ROUTINE
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CMatrixOperation::MVMulOptimal_Nooffload ( CCSR *  pAMatrix, CVector *  pVector, CVector *  pResult, int  nLBIndex  )

static

Added by jhkang end.

Definition at line 3336 of file MatrixOperation.cpp.

References ERROR_WRONG_ORDER_OPERATION, CMatrixOperation::CVector::Finalize(), CMatrixOperation::CCSR::GetColumnCount(), CMatrixOperation::CCSR::GetRowCount(), CMatrixOperation::CCSR::m_fFirstRowIndex, CMatrixOperation::CCSR::m_vectColumn, CMatrixOperation::CCSR::m_vectRow, CMatrixOperation::CVector::m_vectValueImaginaryBuffer, CMatrixOperation::CCSR::m_vectValueImaginaryBuffer, CMatrixOperation::CVector::m_vectValueRealBuffer, CMatrixOperation::CCSR::m_vectValueRealBuffer, CMPIManager::MergeVectorOptimal(), and CMatrixOperation::CVector::SetSize().

Here is the call graph for this function:

void CMatrixOperation::ScalarMulVectors ( double  fValue, CVector *  pVector1, CVector *  pResult  )

static

Added by jhkang end.

Definition at line 3325 of file MatrixOperation.cpp.

References CMatrixOperation::CVector::GetAt(), CComplex::GetImaginaryNumber(), CComplex::GetRealNumber(), CMatrixOperation::CVector::GetSize(), and CMatrixOperation::CVector::SetAt().

{
    unsigned int nSize = pVector1->GetSize();

    for (unsigned int i = 0; i < nSize; i++)
    {
        pResult->SetAt(i, fValue * pVector1->GetAt(i).GetRealNumber(), fValue * pVector1->GetAt(i).GetImaginaryNumber());
    }
}

Here is the call graph for this function:

void CMatrixOperation::SubstractVectors ( CVector *  pVector1, CVector *  pVector2, CVector *  pResult  )

static

Definition at line 3311 of file MatrixOperation.cpp.

References ERROR_WRONG_ORDER_OPERATION, CMatrixOperation::CVector::GetAt(), CMatrixOperation::CVector::GetSize(), and CMatrixOperation::CVector::SetAt().

{
    unsigned int nSize = pVector1->GetSize();
    if (nSize != pVector2->GetSize())
    {
        throw ERROR_WRONG_ORDER_OPERATION;
    }

    for (unsigned int i = 0; i < nSize; i++)
    {
        pResult->SetAt(i, pVector1->GetAt(i) - pVector2->GetAt(i));
    }
}

Here is the call graph for this function:

void CMatrixOperation::UpdateLocalCSR ( CMatrixOperation::CCSR *  source, CMatrixOperation::CCSR *  mine, CMatrixOperation::CCSR *  left, CMatrixOperation::CCSR *  right  )

static

Parameters

source	Copying source CSR
mine	Local CSR buffer
left	Left node CSR buffer
right	right node CSR buffer

Definition at line 3122 of file MatrixOperation.cpp.

References CMatrixOperation::CCSR::GetColumnCount(), CMatrixOperation::CCSR::GetFirstRowIndex(), CComplex::GetImaginaryNumber(), CComplex::GetRealNumber(), CMatrixOperation::CCSR::GetRowCount(), CMatrixOperation::CCSR::GetValue(), CMatrixOperation::CCSR::m_vectColumn, CMatrixOperation::CCSR::m_vectRow, pColumn, pRow, CMatrixOperation::CCSR::SetAt(), CComplex::SetImaginaryNumber(), and CComplex::SetRealNumber().

Referenced by CLanczosLaunching::LaunchingLanczos().

{   
    CMatrixOperation::pRow = source->m_vectRow.data();
    CMatrixOperation::pColumn = source->m_vectColumn.data();
    //CKNMemoryManager::LPVECTOR_ELEMENTS       lpMatrixValueElement = NULL;
    CComplex                                *pData = NULL;
    unsigned int my_nnz, left_nnz, right_nnz;
    CComplex curval;
    int isthisrowfilled;

    //lpMatrixValueElement = source->GetValueElement();

    // 1. Update left block
    
    left_nnz = 0;   

    for (unsigned int ii = 0; ii < source->GetRowCount(); ii++)
    {
        isthisrowfilled = -1;
        unsigned int nSubStart = CMatrixOperation::pRow[ii], nSubEnd = CMatrixOperation::pRow[ii + 1];
        unsigned int startColIndex = (int)left->GetFirstRowIndex(), endColIndex = startColIndex + left->GetColumnCount() - 1;

        for (unsigned int jj = nSubStart; jj < nSubEnd; jj++)
        {
            unsigned int nColIndex = CMatrixOperation::pColumn[jj];

            if(startColIndex <= nColIndex && nColIndex <= endColIndex)
            {   
                isthisrowfilled = 0;
                left_nnz++;
                //curval.SetRealNumber(lpMatrixValueElement->pfReal[jj]); curval.SetImaginaryNumber(lpMatrixValueElement->pfImaginary[jj]);
                pData = source->GetValue(jj);
                curval.SetRealNumber(pData->GetRealNumber()); curval.SetImaginaryNumber(pData->GetImaginaryNumber());
                left->SetAt(curval, ii, nColIndex-startColIndex);
            }
        }

        if(isthisrowfilled == -1)
        {
            left_nnz++;
            curval.SetRealNumber(0.0); curval.SetImaginaryNumber(0.0);
            left->SetAt(curval, ii, 0);
        }
    }

//  if(CMPIManager::IsRootRank())
//      printf("Left block update completed: left_nnz = %d (computed), %d (CSR-allocated)\n", left_nnz, left->GetNoneZeroCount());  
                        
    // 2. Figure out nnz: right block
    
    right_nnz = 0;

    for (unsigned int ii = 0; ii < source->GetRowCount(); ii++)
    {
        isthisrowfilled = -1;
        unsigned int nSubStart = CMatrixOperation::pRow[ii], nSubEnd = CMatrixOperation::pRow[ii + 1];
        unsigned int startColIndex = (int)right->GetFirstRowIndex(), endColIndex = startColIndex + right->GetColumnCount() - 1;
        
        for (unsigned int jj = nSubStart; jj < nSubEnd; jj++)
        {
            unsigned int nColIndex = CMatrixOperation::pColumn[jj];
            if(startColIndex <= nColIndex && nColIndex <= endColIndex)
            {   
                isthisrowfilled = 0;
                right_nnz++;
                //curval.SetRealNumber(lpMatrixValueElement->pfReal[jj]); curval.SetImaginaryNumber(lpMatrixValueElement->pfImaginary[jj]);
                pData = source->GetValue(jj);
                curval.SetRealNumber(pData->GetRealNumber()); curval.SetImaginaryNumber(pData->GetImaginaryNumber());
                right->SetAt(curval, ii, nColIndex-startColIndex);
            }

        }

        if(isthisrowfilled == -1)
        {
            right_nnz++;
            curval.SetRealNumber(0.0); curval.SetImaginaryNumber(0.0);
            right->SetAt(curval, ii, 0);
        }
    }

//  if(CMPIManager::IsRootRank())
//      printf("Right block update completed: right_nnz = %d (computed), %d (CSR-allocated)\n", right_nnz, right->GetNoneZeroCount());

    // 3. Figure out nnz: my block
    
    my_nnz = 0;

    for (unsigned int ii = 0; ii < source->GetRowCount(); ii++)
    {
        unsigned int nSubStart = CMatrixOperation::pRow[ii], nSubEnd = CMatrixOperation::pRow[ii + 1];
        unsigned int startColIndex = (int)mine->GetFirstRowIndex(), endColIndex = startColIndex + mine->GetColumnCount() - 1;

        for(unsigned int jj = nSubStart; jj < nSubEnd; jj++)
        {
            unsigned int nColIndex = CMatrixOperation::pColumn[jj];
            if(startColIndex <= nColIndex && nColIndex <= endColIndex)
            {
                my_nnz++;
                //curval.SetRealNumber(lpMatrixValueElement->pfReal[jj]); curval.SetImaginaryNumber(lpMatrixValueElement->pfImaginary[jj]);
                pData = source->GetValue(jj);
                curval.SetRealNumber(pData->GetRealNumber()); curval.SetImaginaryNumber(pData->GetImaginaryNumber());
                mine->SetAt(curval, ii, nColIndex-startColIndex);
            }               
        }
    }

//  if(CMPIManager::IsRootRank())
//      printf("My block update completed: my_nnz = %d (computed), %d (CSR-allocated)\n", my_nnz, mine->GetNoneZeroCount());
};

Here is the call graph for this function:

Here is the caller graph for this function:

bool CMatrixOperation::VVDot ( CVector *  pVector1, CVector *  pVector2, CComplex *  pResult  )

static

Between vectors dot product operation.

Parameters

pVector1	Vector class pointer that want to operation
pVector2	Vector class pointer that want to operation
pResult	A result of operation

Returns

If operation success return true or return false

Definition at line 2757 of file MatrixOperation.cpp.

References CMPIManager::AllReduceComlex(), ERROR_WRONG_ORDER_OPERATION, CMatrixOperation::CVector::GetSize(), CMatrixOperation::CVector::m_vectValueImaginaryBuffer, CMatrixOperation::CVector::m_vectValueRealBuffer, CComplex::SetComplexNumber(), and CTimeMeasurement::VV_COMM.

Referenced by Gram_schmidt(), CLanczosMethod::LanczosIterationLoop(), and CLanczosMethod::MergeDegeneratedEigenvalues().

{
    double              *pOp1Real = NULL, *pOp1Imaginary = NULL;
    double              *pOp2Real = NULL, *pOp2Imaginary = NULL;
    unsigned int        i, nSize = pVector1->GetSize();

    if (nSize != pVector2->GetSize())
    {
        throw ERROR_WRONG_ORDER_OPERATION;
        return false;
    }

    pOp1Real = pVector1->m_vectValueRealBuffer.data();
    pOp1Imaginary = pVector1->m_vectValueImaginaryBuffer.data();

    pOp2Real = pVector2->m_vectValueRealBuffer.data();
    pOp2Imaginary = pVector2->m_vectValueImaginaryBuffer.data();

    double          fReal = 0., fImaginary = 0.;
#pragma omp parallel for reduction(+:fReal, fImaginary)
    for (i = 0; i < nSize; i++)
    {
        /*fReal += pOp1Real[i] * pOp2Real[i] - pOp1Imaginary[i] * (-1 * pOp2Imaginary[i]);
        fImaginary += pOp1Real[i] * (-1 * pOp2Imaginary[i]) + pOp1Imaginary[i] * pOp2Real[i];*/
        fReal += pOp1Real[i] * pOp2Real[i] - (-1*pOp1Imaginary[i]) * pOp2Imaginary[i];
        fImaginary += pOp1Real[i] * pOp2Imaginary[i] + (-1*pOp1Imaginary[i]) * pOp2Real[i];
    }

    pResult->SetComplexNumber(fReal, fImaginary);
    CMPIManager::AllReduceComlex(pResult, CTimeMeasurement::VV_COMM);

    return true;

}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

unsigned int * CMatrixOperation::pColumn = NULL

static

For MPI Optimized operation using.

Definition at line 280 of file MatrixOperation.h.

Referenced by BuildLocalCSR(), and UpdateLocalCSR().

unsigned int * CMatrixOperation::pRow = NULL

static

For MPI Optimized operation using.

Definition at line 279 of file MatrixOperation.h.

Referenced by BuildLocalCSR(), and UpdateLocalCSR().

CComplex * CMatrixOperation::pValueBuffer = NULL

static

For MPI Optimized operation using.

Definition at line 278 of file MatrixOperation.h.

---

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

• D:/For Doxygen/MatrixOperation.h
• D:/For Doxygen/MatrixOperation.cpp