CKNMatrixOperation Class Reference

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

#include "KNMatrixOperation.h"

Collaboration diagram for CKNMatrixOperation:

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

Public Types
typedef std::vector< double, boost::alignment::aligned_allocator < double, 64 > >	double_vector_t
typedef std::vector< unsigned int, boost::alignment::aligned_allocator < unsigned int, 64 > >	uint_vector_t
typedef struct CKNMatrixOperation::CSR_ELEMENT_DATA *	LPCSR_ELEMENT_DATA
typedef struct CKNMatrixOperation::FILL_MATRIX_DATA *	LPFILL_MATRIX_DATA

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

Static Public Member Functions
static CKNMatrixOperation::CKNCSR *	BuildCSRFromOneDimArray (double *pReal, double *pImaginary, unsigned int nRowOrder, unsigned int nColumnOrder)
	Building CSR from one dimension array. More...
static CKNMatrixOperation::CKNCSR *	BuildCSRFromFileTemp (FILE *fDataFile, unsigned int nRowOrder, unsigned int nColumnOrder, int nDataCount)
	Building CSR from file using double, double, double, double order. More...
static CKNMatrixOperation::CKNCSR *	BuildCSRFromFile_ (FILE *fDataFile, unsigned int nRowOrder, unsigned int nColumnOrder, int nDataCount)
	Building CSR from file using int, int, double, double order. More...
static CKNMatrixOperation::CKNCSR *	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 (CKNMatrixOperation::CKNCSR *pCSR)
	Deallocating CSR memory. More...
static void	DumpCSR (CKNMatrixOperation::CKNCSR *pCSR, const char *pstrFileName)
	For dubugging save CSR information into file. More...
static void	AllocateLocalCSR (CKNMatrixOperation::CKNCSR **mine, CKNMatrixOperation::CKNCSR **left, CKNMatrixOperation::CKNCSR **right)
static void	FreeLocalCSR (CKNMatrixOperation::CKNCSR *mine, CKNMatrixOperation::CKNCSR *left, CKNMatrixOperation::CKNCSR *right)
static void	BuildLocalCSR (CKNMatrixOperation::CKNCSR *source, CKNMatrixOperation::CKNCSR *mine, CKNMatrixOperation::CKNCSR *left, CKNMatrixOperation::CKNCSR *right)
static void	UpdateLocalCSR (CKNMatrixOperation::CKNCSR *source, CKNMatrixOperation::CKNCSR *mine, CKNMatrixOperation::CKNCSR *left, CKNMatrixOperation::CKNCSR *right)
static int	Compare (const void *pA, const void *pB)
	For qick sort compare operation. More...
static void	MVMulEx_AsyncCommWithLocalBlocks (CKNMatrixOperation::CKNCSR *mylocalblock, CKNMatrixOperation::CKNCSR *leftlocalblock, CKNMatrixOperation::CKNCSR *rightlocalblock, CKNVector *pVector, CKNVector *pResult, double *X, double *Xrt, double *Xlt)
	Matrix and vector multiple operation using by block csr. More...
static void	MVMulOptimal (CKNCSR *pAMatrix, CKNVector *pVector, CKNVector *pResult)
	Matrix and vector multiple operation for multiple call. More...
static void	MVMulEx_Optimal (CKNCSR *pAMatrix, CKNVector *pVector, CKNVector *pResult, unsigned int, unsigned int, CKNVector *, int)
	Matrix and vector multiple operation for 1 layer exchanging communication. More...
static void	MVMul (CKNCSR *pAMatrix, CKNVector *pVector, CKNVector *pResult)
	Matrix and vector multiple operation. More...
static bool	VVDot (CKNVector *pVector1, CKNVector *pVector2, CKNComplex *pResult)
	Between vectors dot product operation. More...
static void	MVMul (CKNDMatrix *pMatrix, CKNVector *pVector, CKNVector *pResult)
	Matrix and vector multiple operation for dense matrix. More...
static void	MMMul (CKNDMatrix *pMatrix, CKNDMatrix *pMatrixOperand, CKNDMatrix *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 (CKNComplex operand1, CKNComplex operand2, double tol)
	Compare two vectors with tolerance. More...
static bool	IsSame (CKNVector *pVector1, CKNVector *pVector2)
	Compare two vectors with general tolerance(1e-8) More...
static int	Gram_schmidt (CKNVector *pVect1, CKNVector *pVect2)
	Doing gam schmidt orthogonalization. More...

Static Public Attributes
static CKNComplex *	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

Author

Kyu Nam Cho(mysto.nosp@m.us@k.nosp@m.orea..nosp@m.ac.k.nosp@m.r), Hoon Ryu(elec1.nosp@m.020@.nosp@m.gmail.nosp@m..com)

Definition at line 25 of file KNMatrixOperation.h.

Member Typedef Documentation

typedef std::vector<double, boost::alignment::aligned_allocator<double, 64> > CKNMatrixOperation::double_vector_t

Definition at line 29 of file KNMatrixOperation.h.

typedef struct CKNMatrixOperation::CSR_ELEMENT_DATA * CKNMatrixOperation::LPCSR_ELEMENT_DATA

typedef struct CKNMatrixOperation::FILL_MATRIX_DATA * CKNMatrixOperation::LPFILL_MATRIX_DATA

typedef std::vector<unsigned int, boost::alignment::aligned_allocator<unsigned int, 64> > CKNMatrixOperation::uint_vector_t

Definition at line 32 of file KNMatrixOperation.h.

Constructor & Destructor Documentation

CKNMatrixOperation::CKNMatrixOperation

(

)

Constructor.

---

        CKNCSR Class member function - End

        CKNMatrixOperation Class member function - End

---

Definition at line 1802 of file KNMatrixOperation.cpp.

{
}

CKNMatrixOperation::~CKNMatrixOperation

(

)

Destructor.

Definition at line 1806 of file KNMatrixOperation.cpp.

{
}

Member Function Documentation

void CKNMatrixOperation::AllocateLocalCSR ( CKNMatrixOperation::CKNCSR **  mine, CKNMatrixOperation::CKNCSR **  left, CKNMatrixOperation::CKNCSR **  right  )

static

---

        CKNMatrixOperation Class member function - End

---

Parameters

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

Definition at line 2874 of file KNMatrixOperation.cpp.

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

Referenced by CKNLanczosLaunching::LaunchingLanczos().

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

    nRowCount = CKNMPIManager::GetLoadBalanceCount(myrank);
    *mine = NULL; *left = NULL; *right = NULL;
    
    // Allocate mine
    *mine = new CKNMatrixOperation::CKNCSR();
    if (*mine == NULL)
        throw ERROR_MALLOC;
    nColumnCount = CKNMPIManager::GetLoadBalanceCount(myrank); 
    (*mine)->SetRowCount(nRowCount);
    (*mine)->SetColumnCount(nColumnCount);
    (*mine)->BuildDataBuffer(); temp = 0;
    for (int jj=0; jj<myrank; jj++)
        temp += CKNMPIManager::GetLoadBalanceCount(jj);
    (*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 CKNMatrixOperation::CKNCSR();
    if (*left == NULL)
        throw ERROR_MALLOC;
    nColumnCount = CKNMPIManager::GetLoadBalanceCount(left_neighbor);
    (*left)->SetRowCount(nRowCount);
    (*left)->SetColumnCount(nColumnCount);
    (*left)->BuildDataBuffer(); temp = 0;
    for (int jj=0; jj<left_neighbor; jj++)
        temp += CKNMPIManager::GetLoadBalanceCount(jj);
    (*left)->SetFirstRowIndex((double)temp); // FirstRowIndex will be used in a bit different way: Starting "column" index.

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

    MPI_Barrier(CKNMPIManager::GetMPIComm());   
}

Here is the call graph for this function:

Here is the caller graph for this function:

CKNMatrixOperation::CKNCSR * CKNMatrixOperation::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 1851 of file KNMatrixOperation.cpp.

References CKNMatrixOperation::CKNCSR::BuildDataBuffer(), CKNMatrixOperation::CKNCSR::FinishPush(), CKNMatrixOperation::CKNCSR::PushNoneZeroValue(), REPEAT_COUNT, CKNMatrixOperation::CKNCSR::SetColumnCount(), and CKNMatrixOperation::CKNCSR::SetRowCount().

{
    CKNMatrixOperation::CKNCSR              *pCSR = new CKNMatrixOperation::CKNCSR();
    size_t                                  readSize;
    unsigned int                            i;
    CKNMatrixOperation::CSR_ELEMENT_DATA    Data[REPEAT_COUNT];
    memset(Data, NULL, sizeof(CKNMatrixOperation::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:

CKNMatrixOperation::CKNCSR * CKNMatrixOperation::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 1819 of file KNMatrixOperation.cpp.

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

Referenced by CKNLanczosTest::LargeCSRBuildingViaFileForMPI().

{
    CKNMatrixOperation::CKNCSR              *pCSR = new CKNMatrixOperation::CKNCSR();
    size_t                                  readSize;
    unsigned int                            i;
    CKNMatrixOperation::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:

Here is the caller graph for this function:

CKNMatrixOperation::CKNCSR * CKNMatrixOperation::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 1917 of file KNMatrixOperation.cpp.

References CKNMatrixOperation::CKNCSR::BuildDataBuffer(), Compare(), CKNMatrixOperation::CKNCSR::FinishPush(), CKNMatrixOperation::CKNCSR::PushNoneZeroValue(), CKNMatrixOperation::CKNCSR::SetColumnCount(), and CKNMatrixOperation::CKNCSR::SetRowCount().

{
    LPCSR_ELEMENT_DATA                      lpData = (LPCSR_ELEMENT_DATA)malloc(sizeof(CSR_ELEMENT_DATA)* nDataCount);
    CKNMatrixOperation::CKNCSR              *pCSR = new CKNMatrixOperation::CKNCSR();
    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), CKNMatrixOperation::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:

CKNMatrixOperation::CKNCSR * CKNMatrixOperation::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 1953 of file KNMatrixOperation.cpp.

References CKNMatrixOperation::CKNCSR::BuildDataBuffer(), CKNMatrixOperation::CKNCSR::FinishPush(), CKNMatrixOperation::CKNCSR::PushNoneZeroValue(), CKNMatrixOperation::CKNCSR::SetColumnCount(), and CKNMatrixOperation::CKNCSR::SetRowCount().

Referenced by CKNLanczosTest::TestCSRBuildingViaArray(), CKNLanczosTest::TestCSRBuildingViaFileLoad(), CKNLanczosTest::TestCSRBuildingViaFileLoad_(), and CKNLanczosTest::TestCSRBuildingViaFileLoadOrigin().

{
    unsigned int                row, col;
    CKNMatrixOperation::CKNCSR  *pCSR = new CKNMatrixOperation::CKNCSR();

    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:

Here is the caller graph for this function:

void CKNMatrixOperation::BuildLocalCSR ( CKNMatrixOperation::CKNCSR *  source, CKNMatrixOperation::CKNCSR *  mine, CKNMatrixOperation::CKNCSR *  left, CKNMatrixOperation::CKNCSR *  right  )

static

Parameters

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

Definition at line 2933 of file KNMatrixOperation.cpp.

References CKNMatrixOperation::CKNCSR::FinishPush(), CKNMatrixOperation::CKNCSR::GetColumnCount(), CKNMatrixOperation::CKNCSR::GetFirstRowIndex(), CKNComplex::GetImaginaryNumber(), CKNComplex::GetRealNumber(), CKNMatrixOperation::CKNCSR::GetRowCount(), CKNMatrixOperation::CKNCSR::GetValue(), CKNMatrixOperation::CKNCSR::m_vectColumn, CKNMatrixOperation::CKNCSR::m_vectRow, pColumn, pRow, and CKNMatrixOperation::CKNCSR::PushNoneZeroValue().

Referenced by CKNLanczosLaunching::LaunchingLanczos().

{
    CKNMatrixOperation::pRow                = source->m_vectRow.data();
    CKNMatrixOperation::pColumn             = source->m_vectColumn.data();
    //CKNMemoryManager::LPVECTOR_ELEMENTS       lpMatrixValueElement = NULL;
    CKNComplex                              *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 = CKNMatrixOperation::pRow[ii], nSubEnd = CKNMatrixOperation::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 = CKNMatrixOperation::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(CKNMPIManager::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 = CKNMatrixOperation::pRow[ii], nSubEnd = CKNMatrixOperation::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 = CKNMatrixOperation::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(CKNMPIManager::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 = CKNMatrixOperation::pRow[ii], nSubEnd = CKNMatrixOperation::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 = CKNMatrixOperation::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(CKNMPIManager::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 CKNMatrixOperation::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 1887 of file KNMatrixOperation.cpp.

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

Referenced by BuildCSRFromFileUnsortdata().

{
    CKNMatrixOperation::LPCSR_ELEMENT_DATA              lpA = (CKNMatrixOperation::LPCSR_ELEMENT_DATA)pA;
    CKNMatrixOperation::LPCSR_ELEMENT_DATA              lpB = (CKNMatrixOperation::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 CKNMatrixOperation::DumpCSR ( CKNMatrixOperation::CKNCSR *  pCSR, const char *  pstrFileName  )

inlinestatic

For dubugging save CSR information into file.

Definition at line 243 of file KNMatrixOperation.h.

References CKNMatrixOperation::CKNCSR::DumpCSR().

Referenced by CKNLanczosTest::TestCSRBuilding().

Here is the call graph for this function:

Here is the caller graph for this function:

void CKNMatrixOperation::FreeCSR ( CKNMatrixOperation::CKNCSR *  pCSR )

static

Deallocating CSR memory.

Parameters

pCSR	CSR class pointer that want to deallocating memeory

Definition at line 2085 of file KNMatrixOperation.cpp.

References CKNMatrixOperation::CKNCSR::Finalize().

Referenced by CKNLanczosTest::CompareWithMatLabSeOrth(), CKNLanczosTest::COmpareWIthMatLabSeOrthMPI(), CKNTBMS_Solver::FinalEvn(), FreeLocalCSR(), CKNLanczosTest::LanczosThread(), CKNLanczosTest::LargeSizeMatrixMPI(), CKNLanczosTest::SolvingLargeSizeHamlitonian(), CKNLanczosTest::TestCSRBuilding(), CKNLanczosTest::TestCSRBuildingViaFileLoad_(), CKNLanczosTest::TestLanczos(), and CKNLanczosTest::TestSimpleLanczos().

{
    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 CKNMatrixOperation::FreeLocalCSR ( CKNMatrixOperation::CKNCSR *  mine, CKNMatrixOperation::CKNCSR *  left, CKNMatrixOperation::CKNCSR *  right  )

static

Parameters

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

Definition at line 3166 of file KNMatrixOperation.cpp.

References FreeCSR().

Referenced by CKNLanczosLaunching::LaunchingLanczos().

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

Here is the call graph for this function:

Here is the caller graph for this function:

int CKNMatrixOperation::Gram_schmidt ( CKNVector *  pVect1, CKNVector *  pVect2  )

static

Doing gam schmidt orthogonalization.

Parameters

pVect1	Orthogonalization standard
pVect2	Orthogonalization target

Definition at line 2814 of file KNMatrixOperation.cpp.

References GENERAL_TOLERANCE, CKNComplex::GetRealNumber(), IsSameA(), CKNMatrixOperation::CKNVector::MinusVector(), CKNMatrixOperation::CKNVector::Normalize(), CKNMatrixOperation::CKNVector::ScalarMultiple(), and VVDot().

Referenced by CKNLanczosMethod::MergeDegeneratedEigenvalues().

{
    CKNComplex              result;
    CKNVector               tempVector;

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

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

    CKNMatrixOperation::VVDot(pVect1, pVect2, &result);
    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 CKNMatrixOperation::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 2789 of file KNMatrixOperation.cpp.

Referenced by CKNLanczosTest::AuditResult(), CKNLanczosTest::AuditResult_Seorth(), CKNLanczosMethod::DoResidualCheck(), CKNLanczosMethod::IntegrateEigenvalues(), CKNLanczosMethod::IntegrateEigenvaluesEx(), IsSame(), and CKNLanczosMethod::MergeDegeneratedEigenvalues().

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

Here is the caller graph for this function:

bool CKNMatrixOperation::IsSame ( CKNComplex  operand1, CKNComplex  operand2, double  tol  )

static

Compare two vectors with tolerance.

Parameters

operand1	Comparing operand 1
operand2	Comparing operand 2

Returns

Comparing result

Definition at line 3190 of file KNMatrixOperation.cpp.

References CKNComplex::GetImaginaryNumber(), and CKNComplex::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 CKNMatrixOperation::IsSame ( CKNVector *  pVector1, CKNVector *  pVector2  )

static

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

Parameters

pVector1	Comparing vector operand 1
pVector2	Comparing vector operand 2

Returns

Comparing result

Definition at line 3206 of file KNMatrixOperation.cpp.

References GENERAL_TOLERANCE, CKNMatrixOperation::CKNVector::GetNorm(), IsSame(), and CKNMatrixOperation::CKNVector::MinusVector().

{
    CKNVector       vectorTemp = *pVector1;
    double          fNorm = 1.0;

    vectorTemp.MinusVector(pVector2);
#ifndef DISABLE_MPI_ROUTINE
    fNorm = vectorTemp.GetNorm(true);
#else //DISABLE_MPI_ROUTINE
    fNorm = vectorTemp.GetNorm();
#endif //DISABLE_MPI_ROUTINE
    
    if (IsSame(fNorm, 0.0, GENERAL_TOLERANCE))
        return true;
    else
        return false;
}

bool CKNMatrixOperation::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 2802 of file KNMatrixOperation.cpp.

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

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

Here is the caller graph for this function:

void CKNMatrixOperation::MMMul ( CKNDMatrix *  pMatrix, CKNDMatrix *  pMatrixOperand, CKNDMatrix *  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 2758 of file KNMatrixOperation.cpp.

References CKNComplex::Add(), CKNMatrixOperation::CKNDMatrix::BuildMatrixFirst(), CKNMatrixOperation::CKNDMatrix::GetColumnCount(), CKNMatrixOperation::CKNDMatrix::GetElement(), CKNMatrixOperation::CKNDMatrix::GetRowCount(), CKNComplex::MulltiplyComplex(), and CKNMatrixOperation::CKNDMatrix::SetElement().

Referenced by CKNHamiltonianBuilder::BuildACCANeighborFor10Band(), CKNHamiltonianBuilder::FillMatrixFor10Band(), and CKNGeometricShape::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)
        {
            CKNComplex          result;
            for (j = 0; j < nColumn; ++j)
            {
                result.Add(CKNComplex::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 CKNMatrixOperation::MVMul ( CKNCSR *  pAMatrix, CKNVector *  pVector, CKNVector *  pResult  )

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 2134 of file KNMatrixOperation.cpp.

References ERROR_WRONG_ORDER_OPERATION, CKNMatrixOperation::CKNCSR::GetColumnCount(), CKNMatrixOperation::CKNCSR::GetRowCount(), CKNMatrixOperation::CKNCSR::m_vectColumn, CKNMatrixOperation::CKNCSR::m_vectRow, CKNMatrixOperation::CKNVector::m_vectValueImaginaryBuffer, CKNMatrixOperation::CKNCSR::m_vectValueImaginaryBuffer, CKNMatrixOperation::CKNVector::m_vectValueRealBuffer, CKNMatrixOperation::CKNCSR::m_vectValueRealBuffer, CKNMPIManager::MergeVector(), and CKNMatrixOperation::CKNVector::SetSize().

Referenced by CKNLanczosResultAudit::AuditResult_EV(), CKNLanczosMethod::DoResidualCheck(), CKNLanczosMethod::MergeDegeneratedEigenvalues(), IKNGeometricUnitCellInfo::RotateAxis(), IKNGeometricUnitCellInfo::RotateNeighbor(), and CKNHamiltonianBuilder::RotateTransMatrixFor10Band().

{
    unsigned int                    i, j, nSize = pAMatrix->GetColumnCount();
    CKNVector                       *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());
    CKNMPIManager::MergeVector(pVector, &VOperand, pAMatrix->GetColumnCount());
    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 CKNMatrixOperation::MVMul ( CKNDMatrix *  pMatrix, CKNVector *  pVector, CKNVector *  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 2731 of file KNMatrixOperation.cpp.

References CKNComplex::Add(), CKNMatrixOperation::CKNVector::GetAt(), CKNMatrixOperation::CKNDMatrix::GetColumnCount(), CKNMatrixOperation::CKNDMatrix::GetElement(), CKNMatrixOperation::CKNDMatrix::GetRowCount(), CKNMatrixOperation::CKNVector::GetSize(), CKNComplex::MulltiplyComplex(), CKNMatrixOperation::CKNVector::SetAt(), and CKNMatrixOperation::CKNVector::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)
    {
        CKNComplex          result;
        for (j = 0; j < nColumn; ++j)
        {
            result.Add(CKNComplex::MulltiplyComplex(pMatrix->GetElement(i, j), pVector->GetAt(j)));
        }
        pResult->SetAt(i, result);
    }
}

Here is the call graph for this function:

void CKNMatrixOperation::MVMulEx_AsyncCommWithLocalBlocks ( CKNMatrixOperation::CKNCSR *  mylocalblock, CKNMatrixOperation::CKNCSR *  leftlocalblock, CKNMatrixOperation::CKNCSR *  rightlocalblock, CKNVector *  pVector, CKNVector *  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 2211 of file KNMatrixOperation.cpp.

References ERROR_WRONG_ORDER_OPERATION, CKNMPIManager::GetCurrentRank(), CKNMPIManager::GetMPIComm(), CKNMatrixOperation::CKNCSR::GetRowCount(), CKNMatrixOperation::CKNVector::GetSize(), CKNMPIManager::GetTotalNodeCount(), CKNMatrixOperation::CKNCSR::m_vectColumn, CKNMatrixOperation::CKNCSR::m_vectRow, CKNMatrixOperation::CKNVector::m_vectValueImaginaryBuffer, CKNMatrixOperation::CKNCSR::m_vectValueImaginaryBuffer, CKNMatrixOperation::CKNVector::m_vectValueRealBuffer, CKNMatrixOperation::CKNCSR::m_vectValueRealBuffer, CKNTimeMeasurement::MeasurementEnd(), CKNTimeMeasurement::MeasurementStart(), CKNTimeMeasurement::MV_COMM, pColumn, pRow, and X_largest.

{
    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 = CKNMPIManager::GetCurrentRank();
    int                                     ncpus = CKNMPIManager::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];
    }

    CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::MV_COMM);

    MPI_Irecv(&Brt, 1, MPI_INT, right_neighbor, tag, CKNMPIManager::GetMPIComm(), &req_sr[0]);
    MPI_Isend(&B, 1, MPI_INT, left_neighbor, tag, CKNMPIManager::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, CKNMPIManager::GetMPIComm(), &req_sr[0]); // receive from bottom neighbor
    MPI_Isend(X, 2 * B, MPI_DOUBLE, left_neighbor, tag, CKNMPIManager::GetMPIComm(), &req_sr[1]);   // send to top neighbor

    CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::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

    CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::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, CKNMPIManager::GetMPIComm(), &req_sr[0]);
    MPI_Isend(&B, 1, MPI_INT, right_neighbor, tag, CKNMPIManager::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, CKNMPIManager::GetMPIComm(), &req_sr[0]);
    MPI_Isend(X, 2 * B, MPI_DOUBLE, right_neighbor, tag, CKNMPIManager::GetMPIComm(), &req_sr[1]);

    CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::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

    CKNTimeMeasurement::MeasurementStart(CKNTimeMeasurement::MV_COMM);
    MPI_Waitall(2, req_sr, stat_sr); // now Xlt has X of left neighbor.
    CKNTimeMeasurement::MeasurementEnd(CKNTimeMeasurement::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
}

Here is the call graph for this function:

void CKNMatrixOperation::MVMulEx_Optimal ( CKNCSR *  pAMatrix, CKNVector *  pVector, CKNVector *  pResult, unsigned int  nSizeFromPrevRank, unsigned int  nSizeFromNextRank, CKNVector *  VTemp, int  nSizePHI  )

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 2452 of file KNMatrixOperation.cpp.

References ERROR_WRONG_ORDER_OPERATION, CKNMatrixOperation::CKNCSR::GetColumnCount(), CKNMatrixOperation::CKNCSR::GetRowCount(), CKNMPIManager::GetTotalNodeCount(), CKNMatrixOperation::CKNCSR::m_fFirstRowIndex, CKNMatrixOperation::CKNCSR::m_vectColumn, CKNMatrixOperation::CKNCSR::m_vectRow, CKNMatrixOperation::CKNVector::m_vectValueImaginaryBuffer, CKNMatrixOperation::CKNCSR::m_vectValueImaginaryBuffer, CKNMatrixOperation::CKNVector::m_vectValueRealBuffer, CKNMatrixOperation::CKNCSR::m_vectValueRealBuffer, CKNMPIManager::MergeVectorEx_Optimal(), CKNMatrixOperation::CKNCSR::nComponentsFirstUnitCell, and CKNMatrixOperation::CKNCSR::nComponentsLastUnitCell.

Referenced by CKNLanczosMethod::LanczosIterationLoop().

{
    unsigned int                    nSize = pAMatrix->GetColumnCount();
    CKNVector                       *pOperandVector = NULL;
    double                          *pMatrixReal = NULL, *pMatrixImaginary = NULL;
    double                          *pVectorReal = NULL, *pVectorImaginary = NULL;
    double                          *pResultReal = NULL, *pResultImaginary = NULL;
    unsigned int                    *pMatrixRow = NULL, *pMatrixColumn = NULL;
    char                            sigval;
    unsigned int                    input_size1, input_size2, input_size3;
    unsigned int                    input_offset1, input_offset2, input_offset3, offsettmp[3];
    unsigned int                    output_size, output_offset;

#ifndef DISABLE_MPI_ROUTINE
    pOperandVector = VTemp;
    pVectorReal = pOperandVector->m_vectValueRealBuffer.data();
    pVectorImaginary = pOperandVector->m_vectValueImaginaryBuffer.data();

    //  memset(pVectorReal, 0, sizeof(double)*pOperandVector->GetSize());
    //  memset(pVectorImaginary, 0, sizeof(double)*pOperandVector->GetSize());  

    CKNMPIManager::MergeVectorEx_Optimal(pVector, pOperandVector, pAMatrix->GetColumnCount(), pAMatrix->m_fFirstRowIndex, nSizeFromPrevRank, nSizeFromNextRank, pAMatrix->nComponentsFirstUnitCell, pAMatrix->nComponentsLastUnitCell, offsettmp);

#else
    pOperandVector = pVector;
#endif

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

    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();

    if (CKNMPIManager::GetTotalNodeCount() <= 3)
    {
        input_size1 = pOperandVector->m_vectValueRealBuffer.size();
        input_offset1 = 0;

#pragma offload_transfer target(mic:phi_tid) in(pVectorReal[input_offset1:input_size1]      : REUSE)
#pragma offload_transfer target(mic:phi_tid) in(pVectorImaginary[input_offset1:input_size1] : REUSE)
    }
    else
    {
        input_size1 = nSizeFromPrevRank;
        input_size2 = nSize;
        input_size3 = nSizeFromNextRank;
        input_offset1 = offsettmp[0];
        input_offset2 = offsettmp[1];
        input_offset3 = offsettmp[2];

#pragma offload_transfer target(mic:phi_tid) in(pVectorReal[input_offset1:input_size1]      : REUSE)
#pragma offload_transfer target(mic:phi_tid) in(pVectorImaginary[input_offset1:input_size1] : REUSE)
#pragma offload_transfer target(mic:phi_tid) in(pVectorReal[input_offset2:input_size2]      : REUSE)
#pragma offload_transfer target(mic:phi_tid) in(pVectorImaginary[input_offset2:input_size2] : REUSE)
#pragma offload_transfer target(mic:phi_tid) in(pVectorReal[input_offset3:input_size3]      : REUSE)
#pragma offload_transfer target(mic:phi_tid) in(pVectorImaginary[input_offset3:input_size3] : REUSE)
    }

    output_size = nSizePHI;
    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[output_offset:output_size]      : REUSE) \
    out(pResultImaginary[output_offset:output_size] : REUSE) \
    signal(&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;
    }

#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;
    }

#pragma offload_wait target(mic:phi_tid) wait(&sigval)

}

Here is the call graph for this function:

Here is the caller graph for this function:

void CKNMatrixOperation::MVMulOptimal ( CKNCSR *  pAMatrix, CKNVector *  pVector, CKNVector *  pResult  )

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 2600 of file KNMatrixOperation.cpp.

References ERROR_WRONG_ORDER_OPERATION, CKNMatrixOperation::CKNVector::Finalize(), CKNMatrixOperation::CKNCSR::GetColumnCount(), CKNMatrixOperation::CKNCSR::GetRowCount(), CKNMatrixOperation::CKNCSR::m_fFirstRowIndex, CKNMatrixOperation::CKNCSR::m_vectColumn, CKNMatrixOperation::CKNCSR::m_vectRow, CKNMatrixOperation::CKNVector::m_vectValueImaginaryBuffer, CKNMatrixOperation::CKNCSR::m_vectValueImaginaryBuffer, CKNMatrixOperation::CKNVector::m_vectValueRealBuffer, CKNMatrixOperation::CKNCSR::m_vectValueRealBuffer, CKNMPIManager::MergeVectorOptimal(), and CKNMatrixOperation::CKNVector::SetSize().

Referenced by CKNLanczosMethod::LanczosIterationLoop().

{
    unsigned int                    i, j, nSize = pAMatrix->GetColumnCount();
    CKNVector                       *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
    CKNVector                       VOperand;

    VOperand.SetSize(pAMatrix->GetColumnCount());
    CKNMPIManager::MergeVectorOptimal(pVector, &VOperand, pAMatrix->GetColumnCount(), pAMatrix->m_fFirstRowIndex);
    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();

// 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) \
    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)
//*/
#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 CKNMatrixOperation::UpdateLocalCSR ( CKNMatrixOperation::CKNCSR *  source, CKNMatrixOperation::CKNCSR *  mine, CKNMatrixOperation::CKNCSR *  left, CKNMatrixOperation::CKNCSR *  right  )

static

Parameters

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

Definition at line 3050 of file KNMatrixOperation.cpp.

References CKNMatrixOperation::CKNCSR::GetColumnCount(), CKNMatrixOperation::CKNCSR::GetFirstRowIndex(), CKNComplex::GetImaginaryNumber(), CKNComplex::GetRealNumber(), CKNMatrixOperation::CKNCSR::GetRowCount(), CKNMatrixOperation::CKNCSR::GetValue(), CKNMatrixOperation::CKNCSR::m_vectColumn, CKNMatrixOperation::CKNCSR::m_vectRow, pColumn, pRow, CKNMatrixOperation::CKNCSR::SetAt(), CKNComplex::SetImaginaryNumber(), and CKNComplex::SetRealNumber().

Referenced by CKNLanczosLaunching::LaunchingLanczos().

{   
    CKNMatrixOperation::pRow                = source->m_vectRow.data();
    CKNMatrixOperation::pColumn             = source->m_vectColumn.data();
    //CKNMemoryManager::LPVECTOR_ELEMENTS       lpMatrixValueElement = NULL;
    CKNComplex                              *pData = NULL;
    unsigned int my_nnz, left_nnz, right_nnz;
    CKNComplex 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 = CKNMatrixOperation::pRow[ii], nSubEnd = CKNMatrixOperation::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 = CKNMatrixOperation::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(CKNMPIManager::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 = CKNMatrixOperation::pRow[ii], nSubEnd = CKNMatrixOperation::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 = CKNMatrixOperation::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(CKNMPIManager::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 = CKNMatrixOperation::pRow[ii], nSubEnd = CKNMatrixOperation::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 = CKNMatrixOperation::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(CKNMPIManager::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 CKNMatrixOperation::VVDot ( CKNVector *  pVector1, CKNVector *  pVector2, CKNComplex *  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 2691 of file KNMatrixOperation.cpp.

References CKNMPIManager::AllReduceComlex(), ERROR_WRONG_ORDER_OPERATION, CKNMatrixOperation::CKNVector::GetSize(), CKNMatrixOperation::CKNVector::m_vectValueImaginaryBuffer, CKNMatrixOperation::CKNVector::m_vectValueRealBuffer, CKNComplex::SetComplexNumber(), and CKNTimeMeasurement::VV_COMM.

Referenced by Gram_schmidt(), CKNLanczosMethod::LanczosIterationLoop(), and CKNLanczosMethod::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);
    CKNMPIManager::AllReduceComlex(pResult, CKNTimeMeasurement::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 * CKNMatrixOperation::pColumn = NULL

static

For MPI Optimized operation using.

Definition at line 269 of file KNMatrixOperation.h.

Referenced by BuildLocalCSR(), MVMulEx_AsyncCommWithLocalBlocks(), and UpdateLocalCSR().

unsigned int * CKNMatrixOperation::pRow = NULL

static

For MPI Optimized operation using.

Definition at line 268 of file KNMatrixOperation.h.

Referenced by BuildLocalCSR(), MVMulEx_AsyncCommWithLocalBlocks(), and UpdateLocalCSR().

CKNComplex * CKNMatrixOperation::pValueBuffer = NULL

static

For MPI Optimized operation using.

Definition at line 266 of file KNMatrixOperation.h.

---

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

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