|
COMBINATORIAL_BLAS 1.6
|
|
|
COMBINATORIAL_BLAS 1.6
|
|
Typedefs | |
| typedef struct combblas::packed_edge | packed_edge |
Enumerations | |
| enum | Dim { Column , Row , Column , Row , Column , Row } |
| enum | Dim { Column , Row , Column , Row , Column , Row } |
| enum | Dim { Column , Row , Column , Row , Column , Row } |
Variables | |
| MPIOpCache | mpioc |
| MPIDataTypeCache | mpidtc |
Connected components based on Awerbuch-Shiloach algorithm
Operations used in parallel reductions and scans
Functions that are used by multiple parallel matrix classes, but don't need the "this" pointer
From Graph 500 reference implementation v2.1.1
| void combblas::AllGatherVector | ( | MPI_Comm & | ColWorld, |
| int | trxlocnz, | ||
| IU | lenuntil, | ||
| int32_t *& | trxinds, | ||
| NV *& | trxnums, | ||
| int32_t *& | indacc, | ||
| NV *& | numacc, | ||
| int & | accnz, | ||
| bool | indexisvalue | ||
| ) |
Step 2 of the sparse SpMV algorithm
| [in,out] | trxinds,trxnums | { deallocated } |
| [in,out] | indacc,numacc | { allocated } |
| [in,out] | accnz | { set } |
| [in] | trxlocnz,lenuntil,indexisvalue |
Definition at line 1099 of file ParFriends.h.
| void combblas::AugmentLevel | ( | FullyDistVec< IT, IT > & | mateRow2Col, |
| FullyDistVec< IT, IT > & | mateCol2Row, | ||
| FullyDistVec< IT, IT > & | parentsRow, | ||
| FullyDistVec< IT, IT > & | leaves | ||
| ) |
Definition at line 129 of file BPMaximumMatching.h.
| void combblas::AugmentPath | ( | FullyDistVec< IT, IT > & | mateRow2Col, |
| FullyDistVec< IT, IT > & | mateCol2Row, | ||
| FullyDistVec< IT, IT > & | parentsRow, | ||
| FullyDistVec< IT, IT > & | leaves | ||
| ) |
Definition at line 168 of file BPMaximumMatching.h.
| void combblas::AWPM | ( | SpParMat< IT, NT, SpDCCols< IT, NT > > & | A1, |
| FullyDistVec< IT, IT > & | mateRow2Col, | ||
| FullyDistVec< IT, IT > & | mateCol2Row, | ||
| bool | optimizeProd = true |
||
| ) |
Definition at line 1116 of file ApproxWeightPerfectMatching.h.
| void combblas::BottomUpStep | ( | SpParMat< IT, bool, UDER > & | A, |
| FullyDistSpVec< IT, VT > & | x, | ||
| BitMapFringe< int64_t, int64_t > & | bm_fringe, | ||
| FullyDistVec< IT, VT > & | parents, | ||
| BitMapCarousel< IT, VT > & | done, | ||
| SpDCCols< int, bool >::SpColIter * | starts | ||
| ) |
Definition at line 458 of file BFSFriends.h.
| SpDCCols< int, bool >::SpColIter * combblas::CalcSubStarts | ( | SpParMat< IT, bool, UDER > & | A, |
| FullyDistSpVec< IT, VT > & | x, | ||
| BitMapCarousel< IT, VT > & | done | ||
| ) |
Definition at line 397 of file BFSFriends.h.
| bool combblas::CheckMatching | ( | FullyDistVec< IT, IT > & | mateRow2Col, |
| FullyDistVec< IT, IT > & | mateCol2Row | ||
| ) |
Definition at line 159 of file ParFriends.h.
Definition at line 1020 of file ParFriends.h.
| FullyDistVec< IT, NT > combblas::Concatenate | ( | std::vector< FullyDistVec< IT, NT > > & | vecs | ) |
Concatenate all the FullyDistVec<IT,NT> objects into a single one
Definition at line 59 of file ParFriends.h.
| void combblas::dcsc_gespmv_threaded_setbuffers | ( | const SpDCCols< IT, bool > & | A, |
| const int32_t * | indx, | ||
| const VT * | numx, | ||
| int32_t | nnzx, | ||
| int32_t * | sendindbuf, | ||
| VT * | sendnumbuf, | ||
| int * | cnts, | ||
| int * | dspls, | ||
| int | p_c | ||
| ) |
Multithreaded SpMV with sparse vector and preset buffers the assembly of outgoing buffers sendindbuf/sendnumbuf are done here
Definition at line 59 of file BFSFriends.h.
Definition at line 211 of file mtSpGEMM.h.
| int64_t combblas::EstPerProcessNnzSUMMA | ( | SpParMat< IU, NU1, UDERA > & | A, |
| SpParMat< IU, NU2, UDERB > & | B | ||
| ) |
Estimate the maximum nnz needed to store in a process from all stages of SUMMA before reduction
Definition at line 916 of file ParFriends.h.
| Dcsc< IU, RETT > combblas::EWiseApply | ( | const Dcsc< IU, NU1 > * | Ap, |
| const Dcsc< IU, NU2 > * | Bp, | ||
| _BinaryOperation | __binary_op, | ||
| _BinaryPredicate | do_op, | ||
| bool | allowANulls, | ||
| bool | allowBNulls, | ||
| const NU1 & | ANullVal, | ||
| const NU2 & | BNullVal, | ||
| const bool | allowIntersect | ||
| ) |
Implementation based on operator += Element wise apply with the following constraints The operation to be performed is __binary_op The operation c = __binary_op(a, b) is only performed if do_op(a, b) returns true If allowANulls is true, then if A is missing an element that B has, then ANullVal is used In that case the operation becomes c[i,j] = __binary_op(ANullVal, b[i,j]) If both allowANulls and allowBNulls is false then the function degenerates into intersection
| FullyDistSpVec< IU, RET > combblas::EWiseApply | ( | const FullyDistSpVec< IU, NU1 > & | V, |
| const FullyDistSpVec< IU, NU2 > & | W, | ||
| _BinaryOperation | _binary_op, | ||
| _BinaryPredicate | _doOp, | ||
| bool | allowVNulls, | ||
| bool | allowWNulls, | ||
| NU1 | Vzero, | ||
| NU2 | Wzero, | ||
| const bool | allowIntersect, | ||
| const bool | useExtendedBinOp | ||
| ) |
Performs an arbitrary binary operation _binary_op on the corresponding elements of two vectors with the result stored in a return vector ret. The binary operatiation is only performed if the binary predicate _doOp returns true for those elements. Otherwise the binary operation is not performed and ret does not contain an element at that position. More formally the operation is defined as: if (_doOp(V[i], W[i])) ret[i] = _binary_op(V[i], W[i]) else // ret[i] is not set Hence _doOp can be used to implement a filter on either of the vectors.
The above is only defined if both V[i] and W[i] exist (i.e. an intersection). To allow a union operation (ex. when V[i] doesn't exist but W[i] does) the allowVNulls flag is set to true and the Vzero argument is used as the missing V[i] value. !allowVNulls && !allowWNulls => intersection !allowVNulls && allowWNulls => operate on all elements of V allowVNulls && !allowWNulls => operate on all elements of W allowVNulls && allowWNulls => union
The type of each element of ret must not necessarily be related to the types of V or W, so the return type must be explicitly specified as a template parameter: FullyDistSpVec<int, double> r = EWiseApply<double>(V, W, plus, ...) For intersection, Vzero and Wzero are irrelevant ABAB:
Performs an arbitrary binary operation _binary_op on the corresponding elements of two vectors with the result stored in a return vector ret. The binary operatiation is only performed if the binary predicate _doOp returns true for those elements. Otherwise the binary operation is not performed and ret does not contain an element at that position. More formally the operation is defined as: if (_doOp(V[i], W[i])) ret[i] = _binary_op(V[i], W[i]) else // ret[i] is not set Hence _doOp can be used to implement a filter on either of the vectors.
The above is only defined if both V[i] and W[i] exist (i.e. an intersection). To allow a union operation (ex. when V[i] doesn't exist but W[i] does) the allowVNulls flag is set to true and the Vzero argument is used as the missing V[i] value. !allowVNulls && !allowWNulls => intersection !allowVNulls && allowWNulls => operate on all elements of V allowVNulls && !allowWNulls => operate on all elements of W allowVNulls && allowWNulls => union
The type of each element of ret must not necessarily be related to the types of V or W, so the return type must be explicitly specified as a template parameter: FullyDistSpVec<int, double> r = EWiseApply<double>(V, W, plus, ...) For intersection, Vzero and Wzero are irrelevant ABAB:
Performs an arbitrary binary operation _binary_op on the corresponding elements of two vectors with the result stored in a return vector ret. The binary operatiation is only performed if the binary predicate _doOp returns true for those elements. Otherwise the binary operation is not performed and ret does not contain an element at that position. More formally the operation is defined as: if (_doOp(V[i], W[i])) ret[i] = _binary_op(V[i], W[i]) else // ret[i] is not set Hence _doOp can be used to implement a filter on either of the vectors.
The above is only defined if both V[i] and W[i] exist (i.e. an intersection). To allow a union operation (ex. when V[i] doesn't exist but W[i] does) the allowVNulls flag is set to true and the Vzero argument is used as the missing V[i] value. !allowVNulls && !allowWNulls => intersection !allowVNulls && allowWNulls => operate on all elements of V allowVNulls && !allowWNulls => operate on all elements of W allowVNulls && allowWNulls => union
The type of each element of ret must not necessarily be related to the types of V or W, so the return type must be explicitly specified as a template parameter: FullyDistSpVec<int, double> r = EWiseApply<double>(V, W, plus, ...) For intersection, Vzero and Wzero are irrelevant ABAB:
Definition at line 2227 of file ParFriends.h.
| FullyDistSpVec< IU, RET > combblas::EWiseApply | ( | const FullyDistSpVec< IU, NU1 > & | V, |
| const FullyDistSpVec< IU, NU2 > & | W, | ||
| _BinaryOperation | _binary_op, | ||
| _BinaryPredicate | _doOp, | ||
| bool | allowVNulls, | ||
| bool | allowWNulls, | ||
| NU1 | Vzero, | ||
| NU2 | Wzero, | ||
| const bool | allowIntersect = true |
||
| ) |
Definition at line 2339 of file ParFriends.h.
| FullyDistSpVec< IU, RET > combblas::EWiseApply | ( | const FullyDistSpVec< IU, NU1 > & | V, |
| const FullyDistVec< IU, NU2 > & | W, | ||
| _BinaryOperation | _binary_op, | ||
| _BinaryPredicate | _doOp, | ||
| bool | allowVNulls, | ||
| NU1 | Vzero | ||
| ) |
Definition at line 2325 of file ParFriends.h.
| FullyDistSpVec< IU, RET > combblas::EWiseApply | ( | const FullyDistSpVec< IU, NU1 > & | V, |
| const FullyDistVec< IU, NU2 > & | W, | ||
| _BinaryOperation | _binary_op, | ||
| _BinaryPredicate | _doOp, | ||
| bool | allowVNulls, | ||
| NU1 | Vzero, | ||
| const bool | useExtendedBinOp | ||
| ) |
Performs an arbitrary binary operation _binary_op on the corresponding elements of two vectors with the result stored in a return vector ret. The binary operatiation is only performed if the binary predicate _doOp returns true for those elements. Otherwise the binary operation is not performed and ret does not contain an element at that position. More formally the operation is defined as: if (_doOp(V[i], W[i])) ret[i] = _binary_op(V[i], W[i]) else // ret[i] is not set Hence _doOp can be used to implement a filter on either of the vectors.
The above is only defined if both V[i] and W[i] exist (i.e. an intersection). To allow a union operation (ex. when V[i] doesn't exist but W[i] does) the allowVNulls flag is set to true and the Vzero argument is used as the missing V[i] value.
The type of each element of ret must not necessarily be related to the types of V or W, so the return type must be explicitly specified as a template parameter: FullyDistSpVec<int, double> r = EWiseApply<double>(V, W, plus, retTrue, false, 0)
Definition at line 2126 of file ParFriends.h.
| SpDCCols< IU, RETT > combblas::EWiseApply | ( | const SpDCCols< IU, NU1 > & | A, |
| const SpDCCols< IU, NU2 > & | B, | ||
| _BinaryOperation | __binary_op, | ||
| _BinaryPredicate | do_op, | ||
| bool | allowANulls, | ||
| bool | allowBNulls, | ||
| const NU1 & | ANullVal, | ||
| const NU2 & | BNullVal, | ||
| const bool | allowIntersect | ||
| ) |
| SpParMat< IU, RETT, RETDER > combblas::EWiseApply | ( | const SpParMat< IU, NU1, UDERA > & | A, |
| const SpParMat< IU, NU2, UDERB > & | B, | ||
| _BinaryOperation | __binary_op, | ||
| _BinaryPredicate | do_op, | ||
| bool | allowANulls, | ||
| bool | allowBNulls, | ||
| const NU1 & | ANullVal, | ||
| const NU2 & | BNullVal, | ||
| const bool | allowIntersect, | ||
| const bool | useExtendedBinOp | ||
| ) |
Definition at line 1858 of file ParFriends.h.
| SpParMat< IU, RETT, RETDER > combblas::EWiseApply | ( | const SpParMat< IU, NU1, UDERA > & | A, |
| const SpParMat< IU, NU2, UDERB > & | B, | ||
| _BinaryOperation | __binary_op, | ||
| _BinaryPredicate | do_op, | ||
| bool | allowANulls, | ||
| bool | allowBNulls, | ||
| const NU1 & | ANullVal, | ||
| const NU2 & | BNullVal, | ||
| const bool | allowIntersect = true |
||
| ) |
Definition at line 1877 of file ParFriends.h.
| SpParMat< IU, RETT, RETDER > combblas::EWiseApply | ( | const SpParMat< IU, NU1, UDERA > & | A, |
| const SpParMat< IU, NU2, UDERB > & | B, | ||
| _BinaryOperation | __binary_op, | ||
| bool | notB, | ||
| const NU2 & | defaultBVal | ||
| ) |
Definition at line 1841 of file ParFriends.h.
| FullyDistSpVec< IU, RET > combblas::EWiseApply_threaded | ( | const FullyDistSpVec< IU, NU1 > & | V, |
| const FullyDistVec< IU, NU2 > & | W, | ||
| _BinaryOperation | _binary_op, | ||
| _BinaryPredicate | _doOp, | ||
| bool | allowVNulls, | ||
| NU1 | Vzero, | ||
| const bool | useExtendedBinOp | ||
| ) |
Threaded EWiseApply. Only called internally from EWiseApply.
Definition at line 1980 of file ParFriends.h.
| FullyDistSpVec< IU, typename promote_trait< NU1, NU2 >::T_promote > combblas::EWiseMult | ( | const FullyDistSpVec< IU, NU1 > & | V, |
| const FullyDistVec< IU, NU2 > & | W, | ||
| bool | exclude, | ||
| NU2 | zero | ||
| ) |
if exclude is true, then we prune all entries W[i] != zero from V if exclude is false, then we perform a proper elementwise multiplication
Definition at line 1891 of file ParFriends.h.
| SpParMat< IU, typename promote_trait< NU1, NU2 >::T_promote, typename promote_trait< UDERA, UDERB >::T_promote > combblas::EWiseMult | ( | const SpParMat< IU, NU1, UDERA > & | A, |
| const SpParMat< IU, NU2, UDERB > & | B, | ||
| bool | exclude | ||
| ) |
Definition at line 1821 of file ParFriends.h.
| std::vector< std::tuple< IT, IT, NT > > combblas::ExchangeData | ( | std::vector< std::vector< std::tuple< IT, IT, NT > > > & | tempTuples, |
| MPI_Comm | World | ||
| ) |
Definition at line 43 of file ApproxWeightPerfectMatching.h.
| std::vector< std::tuple< IT, IT, IT, NT > > combblas::ExchangeData1 | ( | std::vector< std::vector< std::tuple< IT, IT, IT, NT > > > & | tempTuples, |
| MPI_Comm | World | ||
| ) |
Definition at line 91 of file ApproxWeightPerfectMatching.h.
Definition at line 17 of file MultiwayMerge.h.
| void combblas::Generator | ( | unsigned | scale, |
| unsigned | EDGEFACTOR, | ||
| double | initiator[4], | ||
| CCGrid & | CMG, | ||
| SpDCCols< IT, NT > & | splitmat, | ||
| bool | trans, | ||
| bool | scramble | ||
| ) |
| [out] | splitmat | {generated RMAT matrix, split into CMG.GridLayers pieces} |
Definition at line 68 of file GenRmatDist.h.
| void combblas::generic_gespmv | ( | const SpMat< MIND, NUM, DER > & | A, |
| const VIND * | indx, | ||
| const IVT * | numx, | ||
| VIND | nnzx, | ||
| std::vector< VIND > & | indy, | ||
| std::vector< OVT > & | numy, | ||
| PreAllocatedSPA< OVT > & | SPA | ||
| ) |
| SpDCCols< IT, NT > * combblas::GenMat | ( | CCGrid & | CMG, |
| unsigned | scale, | ||
| unsigned | EDGEFACTOR, | ||
| double | initiator[4], | ||
| bool | permute | ||
| ) |
Definition at line 83 of file SplitMatDist.h.
| SpDCCols< IT, NT > * combblas::GenRMat | ( | unsigned | scale, |
| unsigned | EDGEFACTOR, | ||
| double | initiator[4], | ||
| MPI_Comm & | layerworld, | ||
| bool | scramble | ||
| ) |
Definition at line 29 of file GenRmatDist.h.
| bool combblas::isMatching | ( | FullyDistVec< IT, NT > & | mateCol2Row, |
| FullyDistVec< IT, NT > & | mateRow2Col | ||
| ) |
| bool combblas::isMaximalmatching | ( | Par_DCSC_Bool & | A, |
| FullyDistVec< IT, NT > & | mateRow2Col, | ||
| FullyDistVec< IT, NT > & | mateCol2Row | ||
| ) |
Definition at line 399 of file BPMaximalMatching.h.
| IT combblas::LabelCC | ( | FullyDistVec< IT, IT > & | father, |
| FullyDistVec< IT, IT > & | cclabel | ||
| ) |
| SpTuples< IT, NTO > * combblas::LocalSpGEMM | ( | const SpDCCols< IT, NT1 > & | A, |
| const SpDCCols< IT, NT2 > & | B, | ||
| bool | clearA, | ||
| bool | clearB | ||
| ) |
Definition at line 77 of file mtSpGEMM.h.
| void combblas::LocalSpMV | ( | const SpParMat< IT, bool, UDER > & | A, |
| int | rowneighs, | ||
| OptBuf< int32_t, VT > & | optbuf, | ||
| int32_t *& | indacc, | ||
| VT *& | numacc, | ||
| int * | sendcnt, | ||
| int | accnz | ||
| ) |
Step 3 of the sparse SpMV algorithm, without the semiring (BFS only)
| [in,out] | optbuf | {scratch space for all-to-all (fold) communication} |
| [in,out] | indacc,numacc | {index and values of the input vector, deleted upon exit} |
| [in,out] | sendindbuf,sendnumbuf | {index and values of the output vector, created} |
Definition at line 184 of file BFSFriends.h.
| void combblas::LocalSpMV | ( | const SpParMat< IU, NUM, UDER > & | A, |
| int | rowneighs, | ||
| OptBuf< int32_t, OVT > & | optbuf, | ||
| int32_t *& | indacc, | ||
| IVT *& | numacc, | ||
| int32_t *& | sendindbuf, | ||
| OVT *& | sendnumbuf, | ||
| int *& | sdispls, | ||
| int * | sendcnt, | ||
| int | accnz, | ||
| bool | indexisvalue, | ||
| PreAllocatedSPA< OVT > & | SPA | ||
| ) |
Step 3 of the sparse SpMV algorithm, with the semiring
| [in,out] | optbuf | {scratch space for all-to-all (fold) communication} |
| [in,out] | indacc,numacc | {index and values of the input vector, deleted upon exit} |
| [in,out] | sendindbuf,sendnumbuf | {index and values of the output vector, created} |
Definition at line 1158 of file ParFriends.h.
Definition at line 330 of file ApproxWeightPerfectMatching.h.
| std::vector< std::tuple< IT, IT > > combblas::MateBcast | ( | std::vector< std::tuple< IT, IT > > | sendTuples, |
| MPI_Comm | World | ||
| ) |
Definition at line 184 of file ApproxWeightPerfectMatching.h.
| void combblas::MaximalMatching | ( | Par_DCSC_Bool & | A, |
| Par_DCSC_Bool & | AT, | ||
| FullyDistVec< IT, IT > & | mateRow2Col, | ||
| FullyDistVec< IT, IT > & | mateCol2Row, | ||
| FullyDistVec< IT, IT > & | degColRecv, | ||
| int | type, | ||
| bool | rand = true |
||
| ) |
Definition at line 23 of file BPMaximalMatching.h.
| void combblas::maximumMatching | ( | SpParMat< IT, NT, DER > & | A, |
| FullyDistVec< IT, IT > & | mateRow2Col, | ||
| FullyDistVec< IT, IT > & | mateCol2Row, | ||
| bool | prune = true, |
||
| bool | randMM = false, |
||
| bool | maximizeWeight = false |
||
| ) |
Definition at line 230 of file BPMaximumMatching.h.
| void combblas::MCLPruneRecoverySelect | ( | SpParMat< IT, NT, DER > & | A, |
| NT | hardThreshold, | ||
| IT | selectNum, | ||
| IT | recoverNum, | ||
| NT | recoverPct, | ||
| int | kselectVersion | ||
| ) |
Definition at line 184 of file ParFriends.h.
| SpParMat< IU, NUO, UDERO > combblas::MemEfficientSpGEMM | ( | SpParMat< IU, NU1, UDERA > & | A, |
| SpParMat< IU, NU2, UDERB > & | B, | ||
| int | phases, | ||
| NUO | hardThreshold, | ||
| IU | selectNum, | ||
| IU | recoverNum, | ||
| NUO | recoverPct, | ||
| int | kselectVersion, | ||
| int64_t | perProcessMemory | ||
| ) |
Broadcasts A multiple times (#phases) in order to save storage in the output Only uses 1/phases of C memory if the threshold/max limits are proper
Definition at line 349 of file ParFriends.h.
| void combblas::MergeContributions | ( | FullyDistSpVec< IU, VT > & | y, |
| int *& | recvcnt, | ||
| int *& | rdispls, | ||
| int32_t *& | recvindbuf, | ||
| VT *& | recvnumbuf, | ||
| int | rowneighs | ||
| ) |
Definition at line 224 of file BFSFriends.h.
| void combblas::MergeContributions | ( | int * | listSizes, |
| std::vector< int32_t * > & | indsvec, | ||
| std::vector< OVT * > & | numsvec, | ||
| std::vector< IU > & | mergedind, | ||
| std::vector< OVT > & | mergednum | ||
| ) |
Definition at line 1226 of file ParFriends.h.
| void combblas::MergeContributions_threaded | ( | int *& | listSizes, |
| std::vector< int32_t * > & | indsvec, | ||
| std::vector< OVT * > & | numsvec, | ||
| std::vector< IU > & | mergedind, | ||
| std::vector< OVT > & | mergednum, | ||
| IU | maxindex | ||
| ) |
Definition at line 1298 of file ParFriends.h.
Definition at line 118 of file RestrictionOp.h.
| MPI_Datatype combblas::MPIType | ( | void | ) |
| MPI_Datatype combblas::MPIType< bool > | ( | void | ) |
Definition at line 84 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< bool > | ( | void | ) |
Definition at line 84 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< bool > | ( | void | ) |
Definition at line 84 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< bool > | ( | void | ) |
Definition at line 84 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< double > | ( | void | ) |
Definition at line 76 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< double > | ( | void | ) |
Definition at line 76 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< double > | ( | void | ) |
Definition at line 76 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< double > | ( | void | ) |
Definition at line 76 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< float > | ( | void | ) |
Definition at line 72 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< float > | ( | void | ) |
Definition at line 72 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< float > | ( | void | ) |
Definition at line 72 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< float > | ( | void | ) |
Definition at line 72 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< int32_t > | ( | void | ) |
Definition at line 56 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< int32_t > | ( | void | ) |
Definition at line 56 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< int32_t > | ( | void | ) |
Definition at line 56 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< int32_t > | ( | void | ) |
Definition at line 56 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< int64_t > | ( | void | ) |
Definition at line 64 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< int64_t > | ( | void | ) |
Definition at line 64 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< int64_t > | ( | void | ) |
Definition at line 64 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< int64_t > | ( | void | ) |
Definition at line 64 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< long double > | ( | void | ) |
Definition at line 80 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< long double > | ( | void | ) |
Definition at line 80 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< long double > | ( | void | ) |
Definition at line 80 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< long double > | ( | void | ) |
Definition at line 80 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< signed char > | ( | void | ) |
Definition at line 40 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< signed char > | ( | void | ) |
Definition at line 40 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< signed char > | ( | void | ) |
Definition at line 40 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< signed char > | ( | void | ) |
Definition at line 40 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< signed short int > | ( | void | ) |
Definition at line 48 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< signed short int > | ( | void | ) |
Definition at line 48 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< signed short int > | ( | void | ) |
Definition at line 48 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< signed short int > | ( | void | ) |
Definition at line 48 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< uint32_t > | ( | void | ) |
Definition at line 60 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< uint32_t > | ( | void | ) |
Definition at line 60 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< uint32_t > | ( | void | ) |
Definition at line 60 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< uint32_t > | ( | void | ) |
Definition at line 60 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< uint64_t > | ( | void | ) |
Definition at line 68 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< uint64_t > | ( | void | ) |
Definition at line 68 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< uint64_t > | ( | void | ) |
Definition at line 68 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< uint64_t > | ( | void | ) |
Definition at line 68 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< unsigned char > | ( | void | ) |
Definition at line 44 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< unsigned char > | ( | void | ) |
Definition at line 44 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< unsigned char > | ( | void | ) |
Definition at line 44 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< unsigned char > | ( | void | ) |
Definition at line 44 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< unsigned short int > | ( | void | ) |
Definition at line 52 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< unsigned short int > | ( | void | ) |
Definition at line 52 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< unsigned short int > | ( | void | ) |
Definition at line 52 of file MPIType.cpp.
| MPI_Datatype combblas::MPIType< unsigned short int > | ( | void | ) |
Definition at line 52 of file MPIType.cpp.
| SpParMat< IU, typename promote_trait< NU1, NU2 >::T_promote, typename promote_trait< UDERA, UDERB >::T_promote > combblas::Mult_AnXBn_ActiveTarget | ( | const SpParMat< IU, NU1, UDERA > & | A, |
| const SpParMat< IU, NU2, UDERB > & | B | ||
| ) |
Parallel A = B*C routine that uses one-sided MPI-2 features General active target syncronization via MPI_Win_Post, MPI_Win_Start, MPI_Win_Complete, MPI_Win_Wait Tested on my dual core Macbook with 1,4,9,16,25 MPI processes No memory hog: splits the matrix into two along the column, prefetches the next half matrix while computing on the current one
Definition at line 58 of file ParFriendsExt.h.
| SpParMat< IU, NUO, UDERO > combblas::Mult_AnXBn_DoubleBuff | ( | SpParMat< IU, NU1, UDERA > & | A, |
| SpParMat< IU, NU2, UDERB > & | B, | ||
| bool | clearA = false, |
||
| bool | clearB = false |
||
| ) |
Parallel C = A*B routine that uses a double buffered broadcasting scheme
Definition at line 617 of file ParFriends.h.
| SpParMat< IU, typename promote_trait< NU1, NU2 >::T_promote, typename promote_trait< UDERA, UDERB >::T_promote > combblas::Mult_AnXBn_Fence | ( | const SpParMat< IU, NU1, UDERA > & | A, |
| const SpParMat< IU, NU2, UDERB > & | B | ||
| ) |
Parallel A = B*C routine that uses one-sided MPI-2 features Syncronization is through MPI_Win_Fence Buggy as of September, 2009
Definition at line 448 of file ParFriendsExt.h.
| SpParMat< IU, typename promote_trait< NU1, NU2 >::T_promote, typename promote_trait< UDERA, UDERB >::T_promote > combblas::Mult_AnXBn_PassiveTarget | ( | const SpParMat< IU, NU1, UDERA > & | A, |
| const SpParMat< IU, NU2, UDERB > & | B | ||
| ) |
Parallel A = B*C routine that uses one-sided MPI-2 features This function implements an asynchronous 2D algorithm, in the sense that there is no notion of stages.
The process that completes its submatrix update, requests subsequent matrices from their owners w/out waiting to sychronize with other processors
This partially remedies the severe load balancing problem in sparse matrices.
The class uses MPI-2 to achieve one-sided asynchronous communication
The algorithm treats each submatrix as a single block
Local data structure can be any SpMat that has a constructor with array sizes and getarrs() member Passive target syncronization via MPI_Win_Lock, MPI_Win_Unlock No memory hog: splits the matrix into two along the column, prefetches the next half matrix while computing on the current one
Definition at line 291 of file ParFriendsExt.h.
| SpParMat< IU, NUO, UDERO > combblas::Mult_AnXBn_Synch | ( | SpParMat< IU, NU1, UDERA > & | A, |
| SpParMat< IU, NU2, UDERB > & | B, | ||
| bool | clearA = false, |
||
| bool | clearB = false |
||
| ) |
Parallel A = B*C routine that uses only MPI-1 features Relies on simple blocking broadcast
Definition at line 792 of file ParFriends.h.
| SpDCCols< IT, NT > * combblas::multiply | ( | SpDCCols< IT, NT > & | splitA, |
| SpDCCols< IT, NT > & | splitB, | ||
| CCGrid & | CMG, | ||
| bool | isBT, | ||
| bool | threaded | ||
| ) |
Definition at line 11 of file Multiplier.h.
| SpTuples< IU, NUO > * combblas::MultiplyReturnTuples | ( | const SpMat< IU, NU1, DER1 > & | A, |
| const SpMat< IU, NU2, DER2 > & | B, | ||
| bool | isAT, | ||
| bool | isBT, | ||
| bool | clearA = false, |
||
| bool | clearB = false |
||
| ) |
| SpTuples< IT, NT > * combblas::MultiwayMerge | ( | std::vector< SpTuples< IT, NT > * > & | ArrSpTups, |
| IT | mdim = 0, |
||
| IT | ndim = 0, |
||
| bool | delarrs = false |
||
| ) |
Definition at line 147 of file MultiwayMerge.h.
| ofstream & combblas::operator<< | ( | ofstream & | outfile, |
| const MemoryPool & | mpool | ||
| ) |
Dump the contents of the pinned memory.
Definition at line 140 of file MemoryPool.cpp.
| std::ofstream & combblas::operator<< | ( | std::ofstream & | outfile, |
| const SpParMat< IU, NU, UDER > & | s | ||
| ) |
Definition at line 4255 of file SpParMat.cpp.
| std::ifstream & combblas::operator>> | ( | std::ifstream & | infile, |
| SpMat< UIT, UNT, UDER > & | s | ||
| ) |
Definition at line 140 of file ApproxWeightPerfectMatching.h.
| SpTuples< IT, NT > * combblas::ParallelReduce_Alltoall_threaded | ( | MPI_Comm & | fibWorld, |
| SpTuples< IT, NT > *& | localmerged | ||
| ) |
Definition at line 37 of file Reductions.h.
|
inline |
Definition at line 52 of file FileHeader.h.
| void combblas::PermEdges | ( | DistEdgeList< IT > & | DEL | ) |
Randomly permutes the distributed edge list. Once we call Viral's psort on this vector, everything will go to the right place [tuples are sorted lexicographically] and you can reconstruct the int64_t * edges in an embarrassingly parallel way. As I understood, the entire purpose of this function is to destroy any locality. It does not rename any vertices and edges are not named anyway. For an example, think about the edge (0,1). It will eventually (at the end of kernel 1) be owned by processor P(0,0). However, assume that processor P(r1,c1) has a copy of it before the call to PermEdges. After this call, some other irrelevant processor P(r2,c2) will own it. So we gained nothing, it is just a scrambled egg.
Definition at line 294 of file DistEdgeList.cpp.
| void combblas::PermEdges | ( | DistEdgeList< IU > & | DEL | ) |
Create a boolean matrix A (not necessarily a permutation matrix) Input: ri: a dense vector (actual values in FullyDistVec should be IT) ncol: number of columns in the output matrix A Output: a boolean matrix A with m=size(ri) and n=ncol (input) and A[k,ri[k]]=1 This can be done by Matlab like constructor, no?
Definition at line 26 of file BPMaximumMatching.h.
| std::vector< std::tuple< IT, IT, NT > > combblas::Phase1 | ( | const AWPM_param< IT > & | param, |
| Dcsc< IT, NT > * | dcsc, | ||
| const std::vector< IT > & | colptr, | ||
| const std::vector< IT > & | RepMateR2C, | ||
| const std::vector< IT > & | RepMateC2R, | ||
| const std::vector< NT > & | RepMateWR2C, | ||
| const std::vector< NT > & | RepMateWC2R | ||
| ) |
Definition at line 412 of file ApproxWeightPerfectMatching.h.
| std::vector< std::tuple< IT, IT, IT, NT > > combblas::Phase2 | ( | const AWPM_param< IT > & | param, |
| std::vector< std::tuple< IT, IT, NT > > & | recvTuples, | ||
| Dcsc< IT, NT > * | dcsc, | ||
| const std::vector< IT > & | colptr, | ||
| const std::vector< IT > & | RepMateR2C, | ||
| const std::vector< IT > & | RepMateC2R, | ||
| const std::vector< NT > & | RepMateWR2C, | ||
| const std::vector< NT > & | RepMateWC2R | ||
| ) |
Definition at line 552 of file ApproxWeightPerfectMatching.h.
| std::vector< std::vector< std::tuple< IT, IT, IT, NT > > > combblas::Phase2_old | ( | const AWPM_param< IT > & | param, |
| std::vector< std::tuple< IT, IT, NT > > & | recvTuples, | ||
| Dcsc< IT, NT > * | dcsc, | ||
| const std::vector< IT > & | colptr, | ||
| const std::vector< IT > & | RepMateR2C, | ||
| const std::vector< IT > & | RepMateC2R, | ||
| const std::vector< NT > & | RepMateWR2C, | ||
| const std::vector< NT > & | RepMateWC2R | ||
| ) |
Definition at line 747 of file ApproxWeightPerfectMatching.h.
Definition at line 24 of file mtSpGEMM.h.
| shared_ptr< CommGrid > combblas::ProductGrid | ( | CommGrid * | gridA, |
| CommGrid * | gridB, | ||
| int & | innerdim, | ||
| int & | Aoffset, | ||
| int & | Boffset | ||
| ) |
Definition at line 164 of file CommGrid.cpp.
| SpParMat< IU, typename promote_trait< NU1, NU2 >::T_promote, typename promote_trait< UDER2, UDER2 >::T_promote > combblas::PSpGEMM | ( | SpParMat< IU, NU1, UDER1 > & | A, |
| SpParMat< IU, NU2, UDER2 > & | B, | ||
| bool | clearA = false, |
||
| bool | clearB = false |
||
| ) |
Definition at line 413 of file SpParMat.h.
| void combblas::PSpGEMM | ( | SpParMat< IU, NU1, UDER1 > & | A, |
| SpParMat< IU, NU2, UDER2 > & | B, | ||
| SpParMat< IU, NUO, UDERO > & | out, | ||
| bool | clearA = false, |
||
| bool | clearB = false |
||
| ) |
Definition at line 406 of file SpParMat.h.
| void combblas::Reader | ( | string | filename, |
| CCGrid & | CMG, | ||
| SpDCCols< IT, NT > & | splitmat, | ||
| bool | trans, | ||
| bool | permute, | ||
| FullyDistVec< IT, IT > & | p | ||
| ) |
| [out] | splitmat | {read matrix market file into layer 0, and split into CMG.GridLayers pieces} |
Definition at line 41 of file ReadMatDist.h.
| SpDCCols< IT, NT > * combblas::ReadMat | ( | std::string | filename, |
| CCGrid & | CMG, | ||
| bool | permute, | ||
| FullyDistVec< IT, IT > & | p | ||
| ) |
Definition at line 30 of file SplitMatDist.h.
| SpDCCols< IT, NT > * combblas::ReduceAll_threaded | ( | std::vector< SpTuples< IT, NT > * > & | unreducedC, |
| CCGrid & | CMG | ||
| ) |
Definition at line 134 of file Reductions.h.
| void combblas::RenameVertices | ( | DistEdgeList< IU > & | DEL | ) |
Rename vertices globally. You first need to do create a random permutation distributed on all processors. Then the p round robin algorithm will do the renaming: For all processors P(i,i) Broadcast local_p to all p processors For j= i*N/p to min((i+1)*N/p, N) Rename the all j's with local_p(j) inside the edgelist (and mark them "renamed" so that yeach vertex id is renamed only once)
Definition at line 364 of file DistEdgeList.cpp.
| void combblas::ReplicateMateWeights | ( | const AWPM_param< IT > & | param, |
| Dcsc< IT, NT > * | dcsc, | ||
| const std::vector< IT > & | colptr, | ||
| std::vector< IT > & | RepMateC2R, | ||
| std::vector< NT > & | RepMateWR2C, | ||
| std::vector< NT > & | RepMateWC2R | ||
| ) |
Definition at line 225 of file ApproxWeightPerfectMatching.h.
| void combblas::RestrictionOp | ( | CCGrid & | CMG, |
| SpDCCols< IT, NT > * | localmat, | ||
| SpDCCols< IT, NT > *& | R, | ||
| SpDCCols< IT, NT > *& | RT | ||
| ) |
Definition at line 197 of file RestrictionOp.h.
| void combblas::SerialMerge | ( | const std::vector< SpTuples< IT, NT > * > & | ArrSpTups, |
| std::tuple< IT, IT, NT > * | ntuples | ||
| ) |
Definition at line 94 of file MultiwayMerge.h.
Definition at line 40 of file MultiwayMerge.h.
| void combblas::SplitMat | ( | CCGrid & | CMG, |
| SpDCCols< IT, NT > * | localmat, | ||
| SpDCCols< IT, NT > & | splitmat, | ||
| bool | rowsplit = false |
||
| ) |
| [in] | rowsplit | {split along the row? true for B matrix} |
| [out] | splitmat | {split a matrix from layer 0 into CMG.GridLayers pieces} |
Definition at line 144 of file SplitMatDist.h.
| FullyDistSpVec< IT, VT > combblas::SpMV | ( | const SpParMat< IT, bool, UDER > & | A, |
| const FullyDistSpVec< IT, VT > & | x, | ||
| OptBuf< int32_t, VT > & | optbuf | ||
| ) |
This is essentially a SpMV for BFS because it lacks the semiring. It naturally justs selects columns of A (adjacencies of frontier) and merges with the minimum entry succeeding. SpParMat has to be boolean input and output vectors are of type VT but their indices are IT
Definition at line 328 of file BFSFriends.h.
| FullyDistSpVec< IU, typename promote_trait< NUM, IU >::T_promote > combblas::SpMV | ( | const SpParMat< IU, NUM, UDER > & | A, |
| const FullyDistSpVec< IU, IU > & | x, | ||
| bool | indexisvalue | ||
| ) |
Definition at line 1043 of file ParFriends.h.
| FullyDistSpVec< IU, typename promote_trait< NUM, IU >::T_promote > combblas::SpMV | ( | const SpParMat< IU, NUM, UDER > & | A, |
| const FullyDistSpVec< IU, IU > & | x, | ||
| bool | indexisvalue, | ||
| OptBuf< int32_t, typename promote_trait< NUM, IU >::T_promote > & | optbuf | ||
| ) |
Automatic type promotion is ONLY done here, all the callee functions (in Friends.h and below) are initialized with the promoted type If indexisvalues = true, then we do not need to transfer values for x (happens for BFS iterations with boolean matrices and integer rhs vectors)
Definition at line 1581 of file ParFriends.h.
| void combblas::SpMV | ( | const SpParMat< IU, NUM, UDER > & | A, |
| const FullyDistSpVec< IU, IVT > & | x, | ||
| FullyDistSpVec< IU, OVT > & | y, | ||
| bool | indexisvalue | ||
| ) |
Definition at line 1561 of file ParFriends.h.
| void combblas::SpMV | ( | const SpParMat< IU, NUM, UDER > & | A, |
| const FullyDistSpVec< IU, IVT > & | x, | ||
| FullyDistSpVec< IU, OVT > & | y, | ||
| bool | indexisvalue, | ||
| OptBuf< int32_t, OVT > & | optbuf | ||
| ) |
Definition at line 1569 of file ParFriends.h.
| void combblas::SpMV | ( | const SpParMat< IU, NUM, UDER > & | A, |
| const FullyDistSpVec< IU, IVT > & | x, | ||
| FullyDistSpVec< IU, OVT > & | y, | ||
| bool | indexisvalue, | ||
| OptBuf< int32_t, OVT > & | optbuf, | ||
| PreAllocatedSPA< OVT > & | SPA | ||
| ) |
This version is the most flexible sparse matrix X sparse vector [Used in KDT] It accepts different types for the matrix (NUM), the input vector (IVT) and the output vector (OVT) without relying on automatic type promotion Input (x) and output (y) vectors can be ALIASED because y is not written until the algorithm is done with x.
Definition at line 1394 of file ParFriends.h.
| void combblas::SpMV | ( | const SpParMat< IU, NUM, UDER > & | A, |
| const FullyDistSpVec< IU, IVT > & | x, | ||
| FullyDistSpVec< IU, OVT > & | y, | ||
| bool | indexisvalue, | ||
| PreAllocatedSPA< OVT > & | SPA | ||
| ) |
Definition at line 1554 of file ParFriends.h.
| FullyDistSpVec< IU, typename promote_trait< NUM, NUV >::T_promote > combblas::SpMV | ( | const SpParMat< IU, NUM, UDER > & | A, |
| const FullyDistSpVec< IU, NUV > & | x | ||
| ) |
\TODO: Old version that is no longer considered optimal Kept for legacy purposes To be removed when other functionals are fully tested.
Definition at line 1674 of file ParFriends.h.
| FullyDistVec< IU, typename promote_trait< NUM, NUV >::T_promote > combblas::SpMV | ( | const SpParMat< IU, NUM, UDER > & | A, |
| const FullyDistVec< IU, NUV > & | x | ||
| ) |
Parallel dense SpMV
Definition at line 1594 of file ParFriends.h.
| void combblas::SpMXSpV_Bucket | ( | const Csc< IT, NT > & | Acsc, |
| int32_t | mA, | ||
| const int32_t * | indx, | ||
| const IVT * | numx, | ||
| int32_t | veclen, | ||
| std::vector< int32_t > & | indy, | ||
| std::vector< OVT > & | numy, | ||
| PreAllocatedSPA< OVT > & | SPA | ||
| ) |
Definition at line 390 of file SpImpl.cpp.
| void combblas::SpMXSpV_Bucket | ( | const Csc< IT, NUM > & | Acsc, |
| int32_t | mA, | ||
| const int32_t * | indx, | ||
| const IVT * | numx, | ||
| int32_t | veclen, | ||
| std::vector< int32_t > & | indy, | ||
| std::vector< OVT > & | numy, | ||
| PreAllocatedSPA< OVT > & | SPA | ||
| ) |
| void combblas::SpMXSpV_HeapSort | ( | const Csc< IT, NT > & | Acsc, |
| int32_t | mA, | ||
| const int32_t * | indx, | ||
| const IVT * | numx, | ||
| int32_t | veclen, | ||
| std::vector< int32_t > & | indy, | ||
| std::vector< OVT > & | numy, | ||
| int32_t | offset | ||
| ) |
SpMXSpV with HeapSort Simply insert entries from columns corresponsing to nonzeros of the input vector into a minHeap Then extract entries from the minHeap Complexity: O(flops*log(flops)) offset is the offset of indices in the matrix in case the matrix is split This version is likely to be more memory efficient than the other one (the one that uses preallocated memory buffers) Because here we don't use a dense accumulation vector but a heap. It will probably be slower though.
Definition at line 345 of file SpImpl.cpp.
| void combblas::SpMXSpV_HeapSort | ( | const Csc< IT, NUM > & | Acsc, |
| int32_t | mA, | ||
| const int32_t * | indx, | ||
| const IVT * | numx, | ||
| int32_t | veclen, | ||
| std::vector< int32_t > & | indy, | ||
| std::vector< OVT > & | numy, | ||
| int32_t | offset | ||
| ) |
| void combblas::SUMMALayer | ( | SpDCCols< IT, NT > & | SplitA, |
| SpDCCols< IT, NT > & | SplitB, | ||
| std::vector< SpTuples< IT, NT > * > & | C, | ||
| CCGrid & | CMG, | ||
| bool | isBT, | ||
| bool | threaded | ||
| ) |
Definition at line 25 of file SUMMALayer.h.
Definition at line 29 of file ReadMatDist.h.
Definition at line 391 of file ApproxWeightPerfectMatching.h.
Definition at line 272 of file ApproxWeightPerfectMatching.h.
Definition at line 1094 of file ApproxWeightPerfectMatching.h.
| void combblas::TransposeVector | ( | MPI_Comm & | World, |
| const FullyDistSpVec< IU, NV > & | x, | ||
| int32_t & | trxlocnz, | ||
| IU & | lenuntil, | ||
| int32_t *& | trxinds, | ||
| NV *& | trxnums, | ||
| bool | indexisvalue | ||
| ) |
Step 1 of the sparse SpMV algorithm
| [in,out] | trxlocnz,lenuntil,trxinds,trxnums | { set or allocated } |
| [in] | indexisvalue |
Definition at line 1057 of file ParFriends.h.
| void combblas::TwoThirdApprox | ( | SpParMat< IT, NT, DER > & | A, |
| FullyDistVec< IT, IT > & | mateRow2Col, | ||
| FullyDistVec< IT, IT > & | mateCol2Row | ||
| ) |
be very careful here
be very careful here
be very careful here
be very careful here
be very careful here
be very careful here
be very careful here
Definition at line 782 of file ApproxWeightPerfectMatching.h.
| void combblas::UpdateMatching | ( | FullyDistVec< IT, IT > & | mateRow2Col, |
| FullyDistVec< IT, IT > & | mateCol2Row, | ||
| std::vector< IT > & | RepMateR2C, | ||
| std::vector< IT > & | RepMateC2R | ||
| ) |
Definition at line 355 of file ApproxWeightPerfectMatching.h.
| void combblas::UpdateParents | ( | MPI_Comm & | RowWorld, |
| std::pair< IT, IT > * | updates, | ||
| int | num_updates, | ||
| FullyDistVec< IT, VT > & | parents, | ||
| int | source, | ||
| int | dest, | ||
| BitMapFringe< int64_t, int64_t > & | bm_fringe | ||
| ) |
Definition at line 436 of file BFSFriends.h.
| void combblas::WeightedGreedy | ( | Par_MAT_Double & | A, |
| FullyDistVec< IT, IT > & | mateRow2Col, | ||
| FullyDistVec< IT, IT > & | mateCol2Row, | ||
| FullyDistVec< IT, IT > & | degCol | ||
| ) |
Definition at line 238 of file BPMaximalMatching.h.
| void combblas::WriteMCLClusters | ( | std::string | ofName, |
| FullyDistVec< IT, IT > | clustIdForVtx, | ||
| FullyDistVec< IT, std::array< char, MAXVERTNAME > > | vtxLabels | ||
| ) |
Write clusters to file: vertices belonging to a cluster are written in a single line separated by space. TODO: sort clusters by their sizes
| [in] | ofName | {output file name} |
| [in] | clustIdForVtx | {the ith entry stores the cluster id of the ith vertex} |
| [in] | vtxLabels | {labels of vertices} |
Definition at line 45 of file WriteMCLClusters.h.
| void combblas::WriteMCLClusters | ( | std::string | ofName, |
| FullyDistVec< IT, IT > | clustIdForVtx, | ||
| int | base | ||
| ) |
Write clusters to file: vertices belonging to a cluster are written in a single line separated by space. Ids of vertices are used as labels TODO: sort clusters by their sizes
| [in] | ofName | {output file name} |
| [in] | clustIdForVtx | {the ith entry stores the cluster id of the ith vertex} |
Definition at line 149 of file WriteMCLClusters.h.
| MPIDataTypeCache combblas::mpidtc |
C++ type to MPIType conversion is done through functions returning the mpi types The templated function is explicitly instantiated for every C++ type that has a correspoinding MPI type. For all others, a data type is created assuming it's some sort of struct. Each created data type is committed only once
| MPIOpCache combblas::mpioc |
1.9.8