combblas Namespace Reference

Classes
struct	absdiff
struct	Arr
struct	AWPM_param
struct	bintotality
class	BitMap
class	BitMapCarousel
class	BitMapFringe
struct	bitwise_and
	Compute the bitwise AND of two integral values. More...
struct	bitwise_or
	Compute the bitwise OR of two integral values. More...
struct	bitwise_xor
	Compute the bitwise exclusive OR of two integral values. More...
struct	BoolCopy1stSRing
struct	BoolCopy2ndSRing
class	CCGrid
struct	ColCompare
struct	ColLexiCompare
struct	ColLexiCompareWithID
class	CommGrid
struct	create_trait
struct	create_trait< SpCCols< OIT, ONT >, NIT, NNT >
struct	create_trait< SpDCCols< OIT, ONT >, NIT, NNT >
class	Csc
class	Dcsc
struct	DeletePtrIf
class	DenseParMat
class	DenseVectorLocalIterator
struct	disable_if
struct	disable_if< true, T >
class	DistEdgeList
struct	enable_if
struct	enable_if< true, T >
struct	equal_first
struct	ErrorTolerantEqual
struct	exponentiate
class	FullyDist
class	FullyDist< IT, NT, typename combblas::disable_if< combblas::is_boolean< NT >::value, NT >::type >
class	FullyDistSpVec
class	FullyDistVec
struct	HeaderInfo
class	HeapEntry
class	HipMCLClusterSaveHandler
struct	identity
struct	inf_plus
struct	is_boolean
struct	is_boolean< bool >
class	Isect
struct	LocArr
struct	logical_xor
	Compute the logical exclusive OR of two integral values. More...
struct	maximum
	Compute the maximum of two values. More...
class	Memory
class	MemoryPool
struct	minimum
	Compute the minimum of two values. More...
struct	MinPlusSRing
struct	MIS2verifySR
struct	MMmul
class	MPIDataTypeCache
struct	MPIOp
struct	MPIOp< bitwise_and< T >, T, typename std::enable_if< std::is_pod< T >::value, void >::type >
struct	MPIOp< bitwise_or< T >, T, typename std::enable_if< std::is_pod< T >::value, void >::type >
struct	MPIOp< bitwise_xor< T >, T, typename std::enable_if< std::is_pod< T >::value, void >::type >
struct	MPIOp< logical_xor< T >, T, typename std::enable_if< std::is_pod< T >::value, void >::type >
struct	MPIOp< maximum< T >, T, typename std::enable_if< std::is_pod< T >::value, void >::type >
struct	MPIOp< minimum< T >, T, typename std::enable_if< std::is_pod< T >::value, void >::type >
struct	MPIOp< std::logical_and< T >, T, typename std::enable_if< std::is_pod< T >::value, void >::type >
struct	MPIOp< std::logical_or< T >, T, typename std::enable_if< std::is_pod< T >::value, void >::type >
struct	MPIOp< std::multiplies< T >, T, typename std::enable_if< std::is_pod< T >::value, void >::type >
struct	MPIOp< std::plus< T >, T, typename std::enable_if< std::is_pod< T >::value, void >::type >
class	MPIOpCache
struct	myidentity
struct	myset
class	OptBuf
class	outofrangeexception
struct	packed_edge
struct	PlusTimesSRing
class	PreAllocatedSPA
struct	promote_trait
struct	promote_trait< bool, NT, typename combblas::disable_if< combblas::is_boolean< NT >::value >::type >
struct	promote_trait< NT, bool, typename combblas::disable_if< combblas::is_boolean< NT >::value >::type >
struct	promote_trait< SpCCols< IT, bool >, SpCCols< IT, NT >, typename combblas::disable_if< combblas::is_boolean< NT >::value >::type >
struct	promote_trait< SpCCols< IT, double >, SpCCols< IT, int > >
struct	promote_trait< SpCCols< IT, float >, SpCCols< IT, int > >
struct	promote_trait< SpCCols< IT, int >, SpCCols< IT, double > >
struct	promote_trait< SpCCols< IT, int >, SpCCols< IT, float > >
struct	promote_trait< SpCCols< IT, NT >, SpCCols< IT, bool >, typename combblas::disable_if< combblas::is_boolean< NT >::value >::type >
struct	promote_trait< SpCCols< IT, NT >, SpCCols< IT, NT > >
struct	promote_trait< SpDCCols< IT, bool >, SpDCCols< IT, NT >, typename combblas::disable_if< combblas::is_boolean< NT >::value >::type >
struct	promote_trait< SpDCCols< IT, double >, SpDCCols< IT, int > >
struct	promote_trait< SpDCCols< IT, float >, SpDCCols< IT, int > >
struct	promote_trait< SpDCCols< IT, int >, SpDCCols< IT, double > >
struct	promote_trait< SpDCCols< IT, int >, SpDCCols< IT, float > >
struct	promote_trait< SpDCCols< IT, NT >, SpDCCols< IT, bool >, typename combblas::disable_if< combblas::is_boolean< NT >::value >::type >
struct	promote_trait< SpDCCols< IT, NT >, SpDCCols< IT, NT > >
struct	promote_trait< SpTuples< int, bool >, SpTuples< int, double > >
struct	promote_trait< SpTuples< int, bool >, SpTuples< int, float > >
struct	promote_trait< SpTuples< int, bool >, SpTuples< int, int > >
struct	promote_trait< SpTuples< int, bool >, SpTuples< int, unsigned > >
struct	promote_trait< SpTuples< int, double >, SpTuples< int, bool > >
struct	promote_trait< SpTuples< int, double >, SpTuples< int, double > >
struct	promote_trait< SpTuples< int, double >, SpTuples< int, int > >
struct	promote_trait< SpTuples< int, float >, SpTuples< int, bool > >
struct	promote_trait< SpTuples< int, float >, SpTuples< int, float > >
struct	promote_trait< SpTuples< int, float >, SpTuples< int, int > >
struct	promote_trait< SpTuples< int, int >, SpTuples< int, bool > >
struct	promote_trait< SpTuples< int, int >, SpTuples< int, double > >
struct	promote_trait< SpTuples< int, int >, SpTuples< int, float > >
struct	promote_trait< SpTuples< int, int >, SpTuples< int, int > >
struct	promote_trait< SpTuples< int, unsigned >, SpTuples< int, bool > >
struct	promote_trait< SpTuples< int64_t, bool >, SpTuples< int64_t, double > >
struct	promote_trait< SpTuples< int64_t, bool >, SpTuples< int64_t, float > >
struct	promote_trait< SpTuples< int64_t, bool >, SpTuples< int64_t, int > >
struct	promote_trait< SpTuples< int64_t, bool >, SpTuples< int64_t, unsigned > >
struct	promote_trait< SpTuples< int64_t, double >, SpTuples< int64_t, bool > >
struct	promote_trait< SpTuples< int64_t, double >, SpTuples< int64_t, double > >
struct	promote_trait< SpTuples< int64_t, double >, SpTuples< int64_t, int > >
struct	promote_trait< SpTuples< int64_t, float >, SpTuples< int64_t, bool > >
struct	promote_trait< SpTuples< int64_t, float >, SpTuples< int64_t, float > >
struct	promote_trait< SpTuples< int64_t, float >, SpTuples< int64_t, int > >
struct	promote_trait< SpTuples< int64_t, int >, SpTuples< int64_t, bool > >
struct	promote_trait< SpTuples< int64_t, int >, SpTuples< int64_t, double > >
struct	promote_trait< SpTuples< int64_t, int >, SpTuples< int64_t, float > >
struct	promote_trait< SpTuples< int64_t, int >, SpTuples< int64_t, int > >
struct	promote_trait< SpTuples< int64_t, int64_t >, SpTuples< int64_t, int64_t > >
struct	promote_trait< SpTuples< int64_t, unsigned >, SpTuples< int64_t, bool > >
struct	RandReduce
	With 50/50 chances, return a one of the operants. More...
class	RefGen21
struct	RowCompare
struct	RowLexiCompare
struct	safemultinv
struct	sel2nd
struct	Select2ndMinSR
struct	Select2ndRandSR
struct	Select2ndSRing
struct	SelectMaxSRing
struct	SelectMaxSRing< bool, T2 >
struct	SelectPlusSR
class	SemanticGraph
struct	SetIfNotEqual
	Returns a special value (passed to the constructor of the functor) when both operants disagree. More...
class	SparseVectorLocalIterator
class	SpCCols
class	SpDCCols
class	SpHelper
struct	SpImpl
struct	SpImpl< SR, IT, bool, IVT, OVT >
class	SpMat
class	SpParHelper
class	SpParMat
class	SpTuples
class	StackEntry
struct	totality
struct	TupleEqual
struct	type_info_compare
	comparison function object for two std::type_info pointers is implemented using the before() member function of the std::type_info class More...
class	VectorLocalIterator
struct	VertexType
struct	VertexTypeML
struct	VertexTypeMM
struct	WeightMaxMLSR
struct	WeightMaxMMSR

Typedefs
typedef struct combblas::packed_edge	packed_edge

Enumerations
enum	Dim { Column, Row }

Functions
template<typename IT , typename NT >
SpDCCols< IT, NT > *	GenRMat (unsigned scale, unsigned EDGEFACTOR, double initiator[4], MPI_Comm &layerworld, bool scramble)
template<typename IT , typename NT >
void	Generator (unsigned scale, unsigned EDGEFACTOR, double initiator[4], CCGrid &CMG, SpDCCols< IT, NT > &splitmat, bool trans, bool scramble)
template<typename IT , typename NT >
SpDCCols< IT, NT > *	multiply (SpDCCols< IT, NT > &splitA, SpDCCols< IT, NT > &splitB, CCGrid &CMG, bool isBT, bool threaded)
template<typename PARMAT >
void	Symmetricize (PARMAT &A)
template<typename IT , typename NT >
void	Reader (string filename, CCGrid &CMG, SpDCCols< IT, NT > &splitmat, bool trans, bool permute, FullyDistVec< IT, IT > &p)
template<typename SR , typename IT , typename NT >
SpTuples< IT, NT > *	ParallelReduce_Alltoall_threaded (MPI_Comm &fibWorld, SpTuples< IT, NT > *&localmerged)
template<typename NT , typename IT >
SpDCCols< IT, NT > *	ReduceAll_threaded (std::vector< SpTuples< IT, NT > * > &unreducedC, CCGrid &CMG)
template<typename ONT , typename IT , typename INT , typename DER >
FullyDistSpVec< IT, ONT >	MIS2 (SpParMat< IT, INT, DER > A)
template<typename IT , typename NT >
void	RestrictionOp (CCGrid &CMG, SpDCCols< IT, NT > *localmat, SpDCCols< IT, NT > *&R, SpDCCols< IT, NT > *&RT)
template<typename NT , typename IT >
SpDCCols< IT, NT > *	ReadMat (std::string filename, CCGrid &CMG, bool permute, FullyDistVec< IT, IT > &p)
template<typename IT , typename NT >
SpDCCols< IT, NT > *	GenMat (CCGrid &CMG, unsigned scale, unsigned EDGEFACTOR, double initiator[4], bool permute)
template<typename IT , typename NT >
void	SplitMat (CCGrid &CMG, SpDCCols< IT, NT > *localmat, SpDCCols< IT, NT > &splitmat, bool rowsplit=false)
template<typename IT , typename NT >
void	SUMMALayer (SpDCCols< IT, NT > &SplitA, SpDCCols< IT, NT > &SplitB, std::vector< SpTuples< IT, NT > * > &C, CCGrid &CMG, bool isBT, bool threaded)
template<typename IT , typename NT , typename DER >
FullyDistVec< IT, short >	StarCheck (const SpParMat< IT, NT, DER > &A, FullyDistVec< IT, IT > &father)
template<typename IT , typename NT , typename DER >
void	ConditionalHook (const SpParMat< IT, NT, DER > &A, FullyDistVec< IT, IT > &father)
template<typename IT , typename NT , typename DER >
void	UnconditionalHook (const SpParMat< IT, NT, DER > &A, FullyDistVec< IT, IT > &father)
template<typename IT >
void	Shortcut (FullyDistVec< IT, IT > &father)
template<typename IT , typename NT , typename DER >
bool	neigborsInSameCC (const SpParMat< IT, NT, DER > &A, FullyDistVec< IT, IT > &cclabel)
template<typename IT , typename NT , typename DER >
void	Correctness (const SpParMat< IT, NT, DER > &A, FullyDistVec< IT, IT > &cclabel, IT nCC, FullyDistVec< IT, IT > father)
template<typename IT >
IT	LabelCC (FullyDistVec< IT, IT > &father, FullyDistVec< IT, IT > &cclabel)
template<typename IT , typename NT , typename DER >
FullyDistVec< IT, IT >	CC (SpParMat< IT, NT, DER > &A, IT &nCC)
template<typename IT >
void	PrintCC (FullyDistVec< IT, IT > CC, IT nCC)
template<typename IT >
void	First4Clust (FullyDistVec< IT, IT > &cc)
template<typename IT >
void	HistCC (FullyDistVec< IT, IT > CC, IT nCC)
template<class IT >
void	WriteMCLClusters (std::string ofName, FullyDistVec< IT, IT > clustIdForVtx, FullyDistVec< IT, std::array< char, MAXVERTNAME > > vtxLabels)
template<class IT >
void	WriteMCLClusters (std::string ofName, FullyDistVec< IT, IT > clustIdForVtx, int base)
template<class IT , class NT >
std::vector< std::tuple< IT, IT, NT > >	ExchangeData (std::vector< std::vector< std::tuple< IT, IT, NT >>> &tempTuples, MPI_Comm World)
template<class IT , class NT >
std::vector< std::tuple< IT, IT, IT, NT > >	ExchangeData1 (std::vector< std::vector< std::tuple< IT, IT, IT, NT >>> &tempTuples, MPI_Comm World)
template<class IT , class NT , class DER >
int	OwnerProcs (SpParMat< IT, NT, DER > &A, IT grow, IT gcol, IT nrows, IT ncols)
template<class IT >
std::vector< std::tuple< IT, IT > >	MateBcast (std::vector< std::tuple< IT, IT >> sendTuples, MPI_Comm World)
template<class IT , class NT >
void	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)
template<class IT , class NT , class DER >
NT	Trace (SpParMat< IT, NT, DER > &A, IT &rettrnnz=0)
template<class NT >
NT	MatchingWeight (std::vector< NT > &RepMateWC2R, MPI_Comm RowWorld, NT &minw)
template<class IT >
void	UpdateMatching (FullyDistVec< IT, IT > &mateRow2Col, FullyDistVec< IT, IT > &mateCol2Row, std::vector< IT > &RepMateR2C, std::vector< IT > &RepMateC2R)
int	ThreadBuffLenForBinning (int itemsize, int nbins)
template<class IT , class NT >
std::vector< std::tuple< IT, IT, NT > >	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)
template<class IT , class NT >
std::vector< std::tuple< IT, IT, IT, NT > >	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)
template<class IT , class NT >
std::vector< std::vector< std::tuple< IT, IT, IT, NT > > >	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)
template<class IT , class NT , class DER >
void	TwoThirdApprox (SpParMat< IT, NT, DER > &A, FullyDistVec< IT, IT > &mateRow2Col, FullyDistVec< IT, IT > &mateCol2Row)
template<class IT , class NT , class DER >
void	TransformWeight (SpParMat< IT, NT, DER > &A, bool applylog)
template<class IT , class NT >
void	AWPM (SpParMat< IT, NT, SpDCCols< IT, NT > > &A1, FullyDistVec< IT, IT > &mateRow2Col, FullyDistVec< IT, IT > &mateCol2Row, bool optimizeProd=true)
template<typename Par_DCSC_Bool , typename IT >
void	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)
template<typename Par_MAT_Double , typename IT >
void	WeightedGreedy (Par_MAT_Double &A, FullyDistVec< IT, IT > &mateRow2Col, FullyDistVec< IT, IT > &mateCol2Row, FullyDistVec< IT, IT > &degCol)
template<class Par_DCSC_Bool , class IT , class NT >
bool	isMaximalmatching (Par_DCSC_Bool &A, FullyDistVec< IT, NT > &mateRow2Col, FullyDistVec< IT, NT > &mateCol2Row)
template<class IT , class DER >
SpParMat< IT, bool, DER >	PermMat (const FullyDistVec< IT, IT > &ri, const IT ncol)
template<typename IT >
void	AugmentLevel (FullyDistVec< IT, IT > &mateRow2Col, FullyDistVec< IT, IT > &mateCol2Row, FullyDistVec< IT, IT > &parentsRow, FullyDistVec< IT, IT > &leaves)
template<typename IT >
void	AugmentPath (FullyDistVec< IT, IT > &mateRow2Col, FullyDistVec< IT, IT > &mateCol2Row, FullyDistVec< IT, IT > &parentsRow, FullyDistVec< IT, IT > &leaves)
template<typename IT , typename NT , typename DER >
void	maximumMatching (SpParMat< IT, NT, DER > &A, FullyDistVec< IT, IT > &mateRow2Col, FullyDistVec< IT, IT > &mateCol2Row, bool prune=true, bool randMM=false, bool maximizeWeight=false)
template<typename PARMAT >
void	removeIsolated (PARMAT &A)
template<class IT , class NT >
bool	isMatching (FullyDistVec< IT, NT > &mateCol2Row, FullyDistVec< IT, NT > &mateRow2Col)
template<class IT >
bool	CheckMatching (FullyDistVec< IT, IT > &mateRow2Col, FullyDistVec< IT, IT > &mateCol2Row)
template<class IT , class NT , class DER >
NT	MatchingWeight (SpParMat< IT, NT, DER > &A, FullyDistVec< IT, IT > mateRow2Col, FullyDistVec< IT, IT > &mateCol2Row)
template<typename IT , typename VT >
void	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)
template<typename VT , typename IT , typename UDER >
void	LocalSpMV (const SpParMat< IT, bool, UDER > &A, int rowneighs, OptBuf< int32_t, VT > &optbuf, int32_t *&indacc, VT *&numacc, int *sendcnt, int accnz)
template<typename IU , typename VT >
void	MergeContributions (FullyDistSpVec< IU, VT > &y, int *&recvcnt, int *&rdispls, int32_t *&recvindbuf, VT *&recvnumbuf, int rowneighs)
template<typename VT , typename IT , typename UDER >
FullyDistSpVec< IT, VT >	SpMV (const SpParMat< IT, bool, UDER > &A, const FullyDistSpVec< IT, VT > &x, OptBuf< int32_t, VT > &optbuf)
template<typename VT , typename IT , typename UDER >
SpDCCols< int, bool >::SpColIter *	CalcSubStarts (SpParMat< IT, bool, UDER > &A, FullyDistSpVec< IT, VT > &x, BitMapCarousel< IT, VT > &done)
template<typename VT , typename IT >
void	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)
template<typename VT , typename IT , typename UDER >
void	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)
template<class T >
bool	compare (const T &a, const T &b, std::false_type)
template<class T >
bool	compare (const T &a, const T &b, std::true_type)
template<typename A >
void	DeleteAll (A arr1)
template<typename A , typename B >
void	DeleteAll (A arr1, B arr2)
template<typename A , typename B , typename C >
void	DeleteAll (A arr1, B arr2, C arr3)
template<typename A , typename B , typename C , typename D >
void	DeleteAll (A arr1, B arr2, C arr3, D arr4)
template<typename A , typename B , typename C , typename D , typename E >
void	DeleteAll (A arr1, B arr2, C arr3, D arr4, E arr5)
template<typename A , typename B , typename C , typename D , typename E , typename F >
void	DeleteAll (A arr1, B arr2, C arr3, D arr4, E arr5, F arr6)
template<typename IT >
void	PermEdges (DistEdgeList< IT > &DEL)
template<typename IU >
void	RenameVertices (DistEdgeList< IU > &DEL)
template<typename IU >
void	PermEdges (DistEdgeList< IU > &DEL)
HeaderInfo	ParseHeader (const std::string &inputname, FILE *&f, int &seeklength)
template<typename SR , typename IU , typename NU , typename RHS , typename LHS >
void	dcsc_gespmv (const SpDCCols< IU, NU > &A, const RHS *x, LHS *y)
	SpMV with dense vector. More...
template<typename SR , typename IU , typename NU , typename RHS , typename LHS >
void	dcsc_gespmv_threaded (const SpDCCols< IU, NU > &A, const RHS *x, LHS *y)
	SpMV with dense vector (multithreaded version) More...
template<typename SR , typename IU , typename NUM , typename DER , typename IVT , typename OVT >
int	generic_gespmv_threaded (const SpMat< IU, NUM, DER > &A, const int32_t *indx, const IVT *numx, int32_t nnzx, int32_t *&sendindbuf, OVT *&sendnumbuf, int *&sdispls, int p_c, PreAllocatedSPA< OVT > &SPA)
template<typename SR , typename IU , typename NUM , typename DER , typename IVT , typename OVT >
void	generic_gespmv_threaded_setbuffers (const SpMat< IU, NUM, DER > &A, const int32_t *indx, const IVT *numx, int32_t nnzx, int32_t *sendindbuf, OVT *sendnumbuf, int *cnts, int *dspls, int p_c)
template<typename SR , typename MIND , typename VIND , typename DER , typename NUM , typename IVT , typename OVT >
void	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)
template<typename SR , typename IU , typename DER , typename NUM , typename IVT , typename OVT >
void	generic_gespmv (const SpMat< IU, NUM, DER > &A, const int32_t *indx, const IVT *numx, int32_t nnzx, int32_t *indy, OVT *numy, int *cnts, int *dspls, int p_c, bool indexisvalue)
template<typename IU >
void	BooleanRowSplit (SpDCCols< IU, bool > &A, int numsplits)
template<class SR , class NUO , class IU , class NU1 , class NU2 >
SpTuples< IU, NUO > *	Tuples_AnXBt (const SpDCCols< IU, NU1 > &A, const SpDCCols< IU, NU2 > &B, bool clearA=false, bool clearB=false)
template<class SR , class NUO , class IU , class NU1 , class NU2 >
SpTuples< IU, NUO > *	Tuples_AnXBn (const SpDCCols< IU, NU1 > &A, const SpDCCols< IU, NU2 > &B, bool clearA=false, bool clearB=false)
template<class SR , class NUO , class IU , class NU1 , class NU2 >
SpTuples< IU, NUO > *	Tuples_AtXBt (const SpDCCols< IU, NU1 > &A, const SpDCCols< IU, NU2 > &B, bool clearA=false, bool clearB=false)
template<class SR , class NUO , class IU , class NU1 , class NU2 >
SpTuples< IU, NUO > *	Tuples_AtXBn (const SpDCCols< IU, NU1 > &A, const SpDCCols< IU, NU2 > &B, bool clearA=false, bool clearB=false)
template<class SR , class IU , class NU >
SpTuples< IU, NU >	MergeAll (const std::vector< SpTuples< IU, NU > *> &ArrSpTups, IU mstar=0, IU nstar=0, bool delarrs=false)
template<typename IU , typename NU1 , typename NU2 >
Dcsc< IU, typename promote_trait< NU1, NU2 >::T_promote >	EWiseMult (const Dcsc< IU, NU1 > &A, const Dcsc< IU, NU2 > *B, bool exclude)
template<typename N_promote , typename IU , typename NU1 , typename NU2 , typename _BinaryOperation >
Dcsc< IU, N_promote >	EWiseApply (const Dcsc< IU, NU1 > &A, const Dcsc< IU, NU2 > *B, _BinaryOperation __binary_op, bool notB, const NU2 &defaultBVal)
template<typename IU , typename NU1 , typename NU2 >
SpDCCols< IU, typename promote_trait< NU1, NU2 >::T_promote >	EWiseMult (const SpDCCols< IU, NU1 > &A, const SpDCCols< IU, NU2 > &B, bool exclude)
template<typename N_promote , typename IU , typename NU1 , typename NU2 , typename _BinaryOperation >
SpDCCols< IU, N_promote >	EWiseApply (const SpDCCols< IU, NU1 > &A, const SpDCCols< IU, NU2 > &B, _BinaryOperation __binary_op, bool notB, const NU2 &defaultBVal)
template<typename RETT , typename IU , typename NU1 , typename NU2 , typename _BinaryOperation , typename _BinaryPredicate >
Dcsc< IU, RETT >	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)
template<typename RETT , typename IU , typename NU1 , typename NU2 , typename _BinaryOperation , typename _BinaryPredicate >
SpDCCols< IU, RETT >	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)
template<typename BT >
MMmul< BT >	operator* (const BT &smm1, const BT &smm2)
template<typename T >
MPI_Datatype	MPIType (void)
template<>
MPI_Datatype	MPIType< signed char > (void)
template<>
MPI_Datatype	MPIType< signed short int > (void)
template<>
MPI_Datatype	MPIType< unsigned char > (void)
template<>
MPI_Datatype	MPIType< unsigned short int > (void)
template<>
MPI_Datatype	MPIType< int32_t > (void)
template<>
MPI_Datatype	MPIType< uint32_t > (void)
template<>
MPI_Datatype	MPIType< int64_t > (void)
template<>
MPI_Datatype	MPIType< uint64_t > (void)
template<>
MPI_Datatype	MPIType< float > (void)
template<>
MPI_Datatype	MPIType< double > (void)
template<>
MPI_Datatype	MPIType< long double > (void)
template<>
MPI_Datatype	MPIType< bool > (void)
template<typename T >
T *	prefixsum (T *in, int size, int nthreads)
template<typename SR , typename NTO , typename IT , typename NT1 , typename NT2 >
SpTuples< IT, NTO > *	LocalSpGEMM (const SpDCCols< IT, NT1 > &A, const SpDCCols< IT, NT2 > &B, bool clearA, bool clearB)
template<typename IT , typename NT1 , typename NT2 >
IT *	estimateNNZ (const SpDCCols< IT, NT1 > &A, const SpDCCols< IT, NT2 > &B)
template<typename RT , typename IT , typename NT >
std::vector< RT >	findColSplitters (SpTuples< IT, NT > *&spTuples, int nsplits)
template<class IT , class NT >
IT	SerialMergeNNZ (const std::vector< SpTuples< IT, NT > *> &ArrSpTups)
template<class SR , class IT , class NT >
void	SerialMerge (const std::vector< SpTuples< IT, NT > *> &ArrSpTups, std::tuple< IT, IT, NT > *ntuples)
template<class SR , class IT , class NT >
SpTuples< IT, NT > *	MultiwayMerge (std::vector< SpTuples< IT, NT > *> &ArrSpTups, IT mdim=0, IT ndim=0, bool delarrs=false)
template<typename IT , typename NT >
FullyDistVec< IT, NT >	Concatenate (std::vector< FullyDistVec< IT, NT > > &vecs)
template<typename MATRIXA , typename MATRIXB >
bool	CheckSpGEMMCompliance (const MATRIXA &A, const MATRIXB &B)
template<typename IT , typename NT , typename DER >
void	MCLPruneRecoverySelect (SpParMat< IT, NT, DER > &A, NT hardThreshold, IT selectNum, IT recoverNum, NT recoverPct, int kselectVersion)
template<typename SR , typename NUO , typename UDERO , typename IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB >
SpParMat< IU, NUO, UDERO >	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)
template<typename SR , typename NUO , typename UDERO , typename IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB >
SpParMat< IU, NUO, UDERO >	Mult_AnXBn_DoubleBuff (SpParMat< IU, NU1, UDERA > &A, SpParMat< IU, NU2, UDERB > &B, bool clearA=false, bool clearB=false)
template<typename SR , typename NUO , typename UDERO , typename IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB >
SpParMat< IU, NUO, UDERO >	Mult_AnXBn_Synch (SpParMat< IU, NU1, UDERA > &A, SpParMat< IU, NU2, UDERB > &B, bool clearA=false, bool clearB=false)
template<typename IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB >
int64_t	EstPerProcessNnzSUMMA (SpParMat< IU, NU1, UDERA > &A, SpParMat< IU, NU2, UDERB > &B)
template<typename MATRIX , typename VECTOR >
void	CheckSpMVCompliance (const MATRIX &A, const VECTOR &x)
template<typename SR , typename IU , typename NUM , typename UDER >
FullyDistSpVec< IU, typename promote_trait< NUM, IU >::T_promote >	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)
template<typename SR , typename IU , typename NUM , typename UDER >
FullyDistSpVec< IU, typename promote_trait< NUM, IU >::T_promote >	SpMV (const SpParMat< IU, NUM, UDER > &A, const FullyDistSpVec< IU, IU > &x, bool indexisvalue)
template<typename IU , typename NV >
void	TransposeVector (MPI_Comm &World, const FullyDistSpVec< IU, NV > &x, int32_t &trxlocnz, IU &lenuntil, int32_t *&trxinds, NV *&trxnums, bool indexisvalue)
template<typename IU , typename NV >
void	AllGatherVector (MPI_Comm &ColWorld, int trxlocnz, IU lenuntil, int32_t *&trxinds, NV *&trxnums, int32_t *&indacc, NV *&numacc, int &accnz, bool indexisvalue)
template<typename SR , typename IVT , typename OVT , typename IU , typename NUM , typename UDER >
void	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)
template<typename SR , typename IU , typename OVT >
void	MergeContributions (int *listSizes, std::vector< int32_t *> &indsvec, std::vector< OVT *> &numsvec, std::vector< IU > &mergedind, std::vector< OVT > &mergednum)
template<typename SR , typename IU , typename OVT >
void	MergeContributions_threaded (int *&listSizes, std::vector< int32_t *> &indsvec, std::vector< OVT *> &numsvec, std::vector< IU > &mergedind, std::vector< OVT > &mergednum, IU maxindex)
template<typename SR , typename IVT , typename OVT , typename IU , typename NUM , typename UDER >
void	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)
template<typename SR , typename IVT , typename OVT , typename IU , typename NUM , typename UDER >
void	SpMV (const SpParMat< IU, NUM, UDER > &A, const FullyDistSpVec< IU, IVT > &x, FullyDistSpVec< IU, OVT > &y, bool indexisvalue, PreAllocatedSPA< OVT > &SPA)
template<typename SR , typename IVT , typename OVT , typename IU , typename NUM , typename UDER >
void	SpMV (const SpParMat< IU, NUM, UDER > &A, const FullyDistSpVec< IU, IVT > &x, FullyDistSpVec< IU, OVT > &y, bool indexisvalue)
template<typename SR , typename IVT , typename OVT , typename IU , typename NUM , typename UDER >
void	SpMV (const SpParMat< IU, NUM, UDER > &A, const FullyDistSpVec< IU, IVT > &x, FullyDistSpVec< IU, OVT > &y, bool indexisvalue, OptBuf< int32_t, OVT > &optbuf)
template<typename SR , typename IU , typename NUM , typename NUV , typename UDER >
FullyDistVec< IU, typename promote_trait< NUM, NUV >::T_promote >	SpMV (const SpParMat< IU, NUM, UDER > &A, const FullyDistVec< IU, NUV > &x)
template<typename SR , typename IU , typename NUM , typename NUV , typename UDER >
FullyDistSpVec< IU, typename promote_trait< NUM, NUV >::T_promote >	SpMV (const SpParMat< IU, NUM, UDER > &A, const FullyDistSpVec< IU, NUV > &x)
template<typename IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB >
SpParMat< IU, typename promote_trait< NU1, NU2 >::T_promote, typename promote_trait< UDERA, UDERB >::T_promote >	EWiseMult (const SpParMat< IU, NU1, UDERA > &A, const SpParMat< IU, NU2, UDERB > &B, bool exclude)
template<typename RETT , typename RETDER , typename IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB , typename _BinaryOperation >
SpParMat< IU, RETT, RETDER >	EWiseApply (const SpParMat< IU, NU1, UDERA > &A, const SpParMat< IU, NU2, UDERB > &B, _BinaryOperation __binary_op, bool notB, const NU2 &defaultBVal)
template<typename RETT , typename RETDER , typename IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB , typename _BinaryOperation , typename _BinaryPredicate >
SpParMat< IU, RETT, RETDER >	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)
template<typename RETT , typename RETDER , typename IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB , typename _BinaryOperation , typename _BinaryPredicate >
SpParMat< IU, RETT, RETDER >	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)
template<typename IU , typename NU1 , typename NU2 >
FullyDistSpVec< IU, typename promote_trait< NU1, NU2 >::T_promote >	EWiseMult (const FullyDistSpVec< IU, NU1 > &V, const FullyDistVec< IU, NU2 > &W, bool exclude, NU2 zero)
template<typename RET , typename IU , typename NU1 , typename NU2 , typename _BinaryOperation , typename _BinaryPredicate >
FullyDistSpVec< IU, RET >	EWiseApply_threaded (const FullyDistSpVec< IU, NU1 > &V, const FullyDistVec< IU, NU2 > &W, _BinaryOperation _binary_op, _BinaryPredicate _doOp, bool allowVNulls, NU1 Vzero, const bool useExtendedBinOp)
template<typename RET , typename IU , typename NU1 , typename NU2 , typename _BinaryOperation , typename _BinaryPredicate >
FullyDistSpVec< IU, RET >	EWiseApply (const FullyDistSpVec< IU, NU1 > &V, const FullyDistVec< IU, NU2 > &W, _BinaryOperation _binary_op, _BinaryPredicate _doOp, bool allowVNulls, NU1 Vzero, const bool useExtendedBinOp)
template<typename RET , typename IU , typename NU1 , typename NU2 , typename _BinaryOperation , typename _BinaryPredicate >
FullyDistSpVec< IU, RET >	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)
template<typename RET , typename IU , typename NU1 , typename NU2 , typename _BinaryOperation , typename _BinaryPredicate >
FullyDistSpVec< IU, RET >	EWiseApply (const FullyDistSpVec< IU, NU1 > &V, const FullyDistVec< IU, NU2 > &W, _BinaryOperation _binary_op, _BinaryPredicate _doOp, bool allowVNulls, NU1 Vzero)
template<typename RET , typename IU , typename NU1 , typename NU2 , typename _BinaryOperation , typename _BinaryPredicate >
FullyDistSpVec< IU, RET >	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)
template<typename SR , typename IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB >
SpParMat< IU, typename promote_trait< NU1, NU2 >::T_promote, typename promote_trait< UDERA, UDERB >::T_promote >	Mult_AnXBn_ActiveTarget (const SpParMat< IU, NU1, UDERA > &A, const SpParMat< IU, NU2, UDERB > &B)
template<typename SR , typename IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB >
SpParMat< IU, typename promote_trait< NU1, NU2 >::T_promote, typename promote_trait< UDERA, UDERB >::T_promote >	Mult_AnXBn_PassiveTarget (const SpParMat< IU, NU1, UDERA > &A, const SpParMat< IU, NU2, UDERB > &B)
template<typename SR , typename IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB >
SpParMat< IU, typename promote_trait< NU1, NU2 >::T_promote, typename promote_trait< UDERA, UDERB >::T_promote >	Mult_AnXBn_Fence (const SpParMat< IU, NU1, UDERA > &A, const SpParMat< IU, NU2, UDERB > &B)
	DECLARE_PROMOTE (int64_t, bool, int64_t)
	DECLARE_PROMOTE (int64_t, int, int64_t)
	DECLARE_PROMOTE (bool, int64_t, int64_t)
	DECLARE_PROMOTE (int, int64_t, int64_t)
	DECLARE_PROMOTE (int64_t, int64_t, int64_t)
	DECLARE_PROMOTE (int, bool, int)
	DECLARE_PROMOTE (short, bool, short)
	DECLARE_PROMOTE (unsigned, bool, unsigned)
	DECLARE_PROMOTE (float, bool, float)
	DECLARE_PROMOTE (double, bool, double)
	DECLARE_PROMOTE (unsigned long long, bool, unsigned long long)
	DECLARE_PROMOTE (bool, int, int)
	DECLARE_PROMOTE (bool, short, short)
	DECLARE_PROMOTE (bool, unsigned, unsigned)
	DECLARE_PROMOTE (bool, float, float)
	DECLARE_PROMOTE (bool, double, double)
	DECLARE_PROMOTE (bool, unsigned long long, unsigned long long)
	DECLARE_PROMOTE (bool, bool, bool)
	DECLARE_PROMOTE (float, int, float)
	DECLARE_PROMOTE (double, int, double)
	DECLARE_PROMOTE (int, float, float)
	DECLARE_PROMOTE (int, double, double)
	DECLARE_PROMOTE (double, int64_t, double)
	DECLARE_PROMOTE (int64_t, double, double)
	DECLARE_PROMOTE (double, uint64_t, double)
	DECLARE_PROMOTE (uint64_t, double, double)
	DECLARE_PROMOTE (float, float, float)
	DECLARE_PROMOTE (double, double, double)
	DECLARE_PROMOTE (int, int, int)
	DECLARE_PROMOTE (unsigned, unsigned, unsigned)
	DECLARE_PROMOTE (unsigned long long, unsigned long long, unsigned long long)
template<typename SR , typename IT , typename NT , typename IVT , typename OVT >
void	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)
template<typename SR , typename IT , typename NT , typename IVT , typename OVT >
void	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)
template<class SR , class IT , class NUM , class IVT , class OVT >
void	SpMXSpV (const Dcsc< IT, NUM > &Adcsc, 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)
	Overload #1: DCSC. More...
template<class SR , class IT , class NUM , class IVT , class OVT >
void	SpMXSpV (const Dcsc< IT, NUM > &Adcsc, int32_t mA, const int32_t *indx, const IVT *numx, int32_t veclen, int32_t *indy, OVT *numy, int *cnts, int *dspls, int p_c)
	Overload #2: DCSC. More...
template<class SR , class IT , class NUM , class IVT , class OVT >
void	SpMXSpV_ForThreading (const Dcsc< IT, NUM > &Adcsc, 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)
	Overload #3: DCSC. More...
template<class SR , class IT , class NUM , class IVT , class OVT >
void	SpMXSpV_ForThreading (const Dcsc< IT, NUM > &Adcsc, 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, std::vector< OVT > &localy, BitMap &isthere, std::vector< uint32_t > &nzinds)
	Overload #4: DCSC w/ preallocated SPA. More...
template<typename SR , typename IT , typename NUM , typename IVT , typename OVT >
void	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)
template<class SR , class IT , class NUM , class IVT , class OVT >
void	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)
template<class SR , class IT , class NUM , class IVT , class OVT >
void	SpMXSpV (const Csc< IT, NUM > &Acsc, int32_t mA, const int32_t *indx, const IVT *numx, int32_t veclen, int32_t *indy, OVT *numy, int *cnts, int *dspls, int p_c)
	Overload #1: CSC. More...
template<class SR , class IT , class NUM , class IVT , class OVT >
void	SpMXSpV (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)
	Overload #2: CSC. More...
template<class SR , class IT , class NUM , class IVT , class OVT >
void	SpMXSpV_ForThreading (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)
	Overload #3: CSC. More...
template<class SR , class IT , class NUM , class IVT , class OVT >
void	SpMXSpV_ForThreading (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, std::vector< OVT > &localy, BitMap &isthere, std::vector< uint32_t > &nzinds)
	Overload #4: CSC w/ preallocated SPA. More...
template<typename SR , typename NUO , typename IU , typename NU1 , typename NU2 , typename DER1 , typename DER2 >
SpTuples< IU, NUO > *	MultiplyReturnTuples (const SpMat< IU, NU1, DER1 > &A, const SpMat< IU, NU2, DER2 > &B, bool isAT, bool isBT, bool clearA=false, bool clearB=false)
template<typename UIT , typename UNT , typename UDER >
std::ofstream &	operator<< (std::ofstream &outfile, const SpMat< UIT, UNT, UDER > &s)
template<typename UIT , typename UNT , typename UDER >
std::ifstream &	operator>> (std::ifstream &infile, SpMat< UIT, UNT, UDER > &s)
template<class IU , class NU , class UDER >
std::ofstream &	operator<< (std::ofstream &outfile, const SpParMat< IU, NU, UDER > &s)
template<typename SR , typename NUO , typename UDERO , typename IU , typename NU1 , typename NU2 , typename UDER1 , typename UDER2 >
void	PSpGEMM (SpParMat< IU, NU1, UDER1 > &A, SpParMat< IU, NU2, UDER2 > &B, SpParMat< IU, NUO, UDERO > &out, bool clearA=false, bool clearB=false)
template<typename SR , typename IU , typename NU1 , typename NU2 , typename UDER1 , typename UDER2 >
SpParMat< IU, typename promote_trait< NU1, NU2 >::T_promote, typename promote_trait< UDER2, UDER2 >::T_promote >	PSpGEMM (SpParMat< IU, NU1, UDER1 > &A, SpParMat< IU, NU2, UDER2 > &B, bool clearA=false, bool clearB=false)
shared_ptr< CommGrid >	ProductGrid (CommGrid *gridA, CommGrid *gridB, int &innerdim, int &Aoffset, int &Boffset)
uint64_t	_rotl64 (uint64_t value, int8_t amount)
uint32_t	SuperFastHash (const char *data, int len)
uint64_t	getblock (const uint64_t *p, int i)
void	bmix64 (uint64_t &h1, uint64_t &h2, uint64_t &k1, uint64_t &k2, uint64_t &c1, uint64_t &c2)
uint64_t	fmix64 (uint64_t k)
void	MurmurHash3_x64_128 (const void *key, const int len, const uint32_t seed, void *out)
void	MurmurHash3_x64_32 (const void *key, int len, uint32_t seed, void *out)
void	MurmurHash3_x64_64 (const void *key, int len, uint32_t seed, void *out)
ofstream &	operator<< (ofstream &outfile, const MemoryPool &mpool)
	Dump the contents of the pinned memory. More...

Variables
double	t1Comp
double	t1Comm
double	t2Comp
double	t2Comm
double	t3Comp
double	t3Comm
double	t4Comp
double	t4Comm
double	t5Comp
double	t5Comm
double	tUpdateMateComp
MPIOpCache	mpioc
MPIDataTypeCache	mpidtc

Detailed Description

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

Typedef Documentation

packed_edge

typedef struct combblas::packed_edge combblas::packed_edge

From Graph 500 reference implementation v2.1.1

Enumeration Type Documentation

Dim

enum combblas::Dim

Enumerator
Column
Row

Definition at line 112 of file SpDefs.h.

Function Documentation

_rotl64()

uint64_t combblas::_rotl64 ( uint64_t  value, int8_t  amount  )

inline

Definition at line 7 of file hash.cpp.

AllGatherVector()

template<typename IU , typename NV >

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

Parameters

[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.

AugmentLevel()

template<typename IT >

void combblas::AugmentLevel	(	FullyDistVec< IT, IT > &	mateRow2Col,
		FullyDistVec< IT, IT > &	mateCol2Row,
		FullyDistVec< IT, IT > &	parentsRow,
		FullyDistVec< IT, IT > &	leaves
	)

Definition at line 130 of file BPMaximumMatching.h.

AugmentPath()

template<typename IT >

void combblas::AugmentPath	(	FullyDistVec< IT, IT > &	mateRow2Col,
		FullyDistVec< IT, IT > &	mateCol2Row,
		FullyDistVec< IT, IT > &	parentsRow,
		FullyDistVec< IT, IT > &	leaves
	)

Definition at line 169 of file BPMaximumMatching.h.

AWPM()

template<class IT , class NT >

void combblas::AWPM	(	SpParMat< IT, NT, SpDCCols< IT, NT > > &	A1,
		FullyDistVec< IT, IT > &	mateRow2Col,
		FullyDistVec< IT, IT > &	mateCol2Row,
		bool	optimizeProd = true
	)

Definition at line 1171 of file ApproxWeightPerfectMatching.h.

bmix64()

void combblas::bmix64 ( uint64_t &  h1, uint64_t &  h2, uint64_t &  k1, uint64_t &  k2, uint64_t &  c1, uint64_t &  c2  )

inline

Definition at line 71 of file hash.cpp.

BooleanRowSplit()

template<typename IU >

void combblas::BooleanRowSplit	(	SpDCCols< IU, bool > &	A,
		int	numsplits
	)

Definition at line 439 of file Friends.h.

BottomUpStep()

template<typename VT , typename IT , typename UDER >

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.

CalcSubStarts()

template<typename VT , typename IT , typename UDER >

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.

CC()

template<typename IT , typename NT , typename DER >

FullyDistVec<IT, IT> combblas::CC	(	SpParMat< IT, NT, DER > &	A,
		IT &	nCC
	)

Definition at line 276 of file CC.h.

CheckMatching()

template<class IT >

bool combblas::CheckMatching	(	FullyDistVec< IT, IT > &	mateRow2Col,
		FullyDistVec< IT, IT > &	mateCol2Row
	)

Definition at line 113 of file Utility.h.

CheckSpGEMMCompliance()

template<typename MATRIXA , typename MATRIXB >

bool combblas::CheckSpGEMMCompliance	(	const MATRIXA &	A,
		const MATRIXB &	B
	)

Definition at line 159 of file ParFriends.h.

CheckSpMVCompliance()

template<typename MATRIX , typename VECTOR >

void combblas::CheckSpMVCompliance	(	const MATRIX &	A,
		const VECTOR &	x
	)

Definition at line 1020 of file ParFriends.h.

compare() [1/2]

template<class T >

bool combblas::compare ( const T &  a, const T &  b, std::false_type    )

inline

Definition at line 41 of file Compare.h.

compare() [2/2]

template<class T >

bool combblas::compare ( const T &  a, const T &  b, std::true_type    )

inline

Definition at line 47 of file Compare.h.

Concatenate()

template<typename IT , typename NT >

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.

ConditionalHook()

template<typename IT , typename NT , typename DER >

void combblas::ConditionalHook	(	const SpParMat< IT, NT, DER > &	A,
		FullyDistVec< IT, IT > &	father
	)

Definition at line 131 of file CC.h.

Correctness()

template<typename IT , typename NT , typename DER >

void combblas::Correctness	(	const SpParMat< IT, NT, DER > &	A,
		FullyDistVec< IT, IT > &	cclabel,
		IT	nCC,
		FullyDistVec< IT, IT >	father
	)

Definition at line 235 of file CC.h.

dcsc_gespmv()

template<typename SR , typename IU , typename NU , typename RHS , typename LHS >

void combblas::dcsc_gespmv	(	const SpDCCols< IU, NU > &	A,
		const RHS *	x,
		LHS *	y
	)

SpMV with dense vector.

Definition at line 64 of file Friends.h.

dcsc_gespmv_threaded()

template<typename SR , typename IU , typename NU , typename RHS , typename LHS >

void combblas::dcsc_gespmv_threaded	(	const SpDCCols< IU, NU > &	A,
		const RHS *	x,
		LHS *	y
	)

SpMV with dense vector (multithreaded version)

Definition at line 82 of file Friends.h.

dcsc_gespmv_threaded_setbuffers()

template<typename IT , typename VT >

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.

DECLARE_PROMOTE() [1/31]

combblas::DECLARE_PROMOTE	(	int64_t	,
		bool	,
		int64_t
	)

DECLARE_PROMOTE() [2/31]

combblas::DECLARE_PROMOTE	(	int64_t	,
		int	,
		int64_t
	)

DECLARE_PROMOTE() [3/31]

combblas::DECLARE_PROMOTE	(	bool	,
		int64_t	,
		int64_t
	)

DECLARE_PROMOTE() [4/31]

combblas::DECLARE_PROMOTE	(	int	,
		int64_t	,
		int64_t
	)

DECLARE_PROMOTE() [5/31]

combblas::DECLARE_PROMOTE	(	int64_t	,
		int64_t	,
		int64_t
	)

DECLARE_PROMOTE() [6/31]

combblas::DECLARE_PROMOTE	(	int	,
		bool	,
		int
	)

DECLARE_PROMOTE() [7/31]

combblas::DECLARE_PROMOTE	(	short	,
		bool	,
		short
	)

DECLARE_PROMOTE() [8/31]

combblas::DECLARE_PROMOTE	(	unsigned	,
		bool	,
		unsigned
	)

DECLARE_PROMOTE() [9/31]

combblas::DECLARE_PROMOTE	(	float	,
		bool	,
		float
	)

DECLARE_PROMOTE() [10/31]

combblas::DECLARE_PROMOTE	(	double	,
		bool	,
		double
	)

DECLARE_PROMOTE() [11/31]

combblas::DECLARE_PROMOTE	(	unsigned long	long,
		bool	,
		unsigned long	long
	)

DECLARE_PROMOTE() [12/31]

combblas::DECLARE_PROMOTE	(	bool	,
		int	,
		int
	)

DECLARE_PROMOTE() [13/31]

combblas::DECLARE_PROMOTE	(	bool	,
		short	,
		short
	)

DECLARE_PROMOTE() [14/31]

combblas::DECLARE_PROMOTE	(	bool	,
		unsigned	,
		unsigned
	)

DECLARE_PROMOTE() [15/31]

combblas::DECLARE_PROMOTE	(	bool	,
		float	,
		float
	)

DECLARE_PROMOTE() [16/31]

combblas::DECLARE_PROMOTE	(	bool	,
		double	,
		double
	)

DECLARE_PROMOTE() [17/31]

combblas::DECLARE_PROMOTE	(	bool	,
		unsigned long	long,
		unsigned long	long
	)

DECLARE_PROMOTE() [18/31]

combblas::DECLARE_PROMOTE	(	bool	,
		bool	,
		bool
	)

DECLARE_PROMOTE() [19/31]

combblas::DECLARE_PROMOTE	(	float	,
		int	,
		float
	)

DECLARE_PROMOTE() [20/31]

combblas::DECLARE_PROMOTE	(	double	,
		int	,
		double
	)

DECLARE_PROMOTE() [21/31]

combblas::DECLARE_PROMOTE	(	int	,
		float	,
		float
	)

DECLARE_PROMOTE() [22/31]

combblas::DECLARE_PROMOTE	(	int	,
		double	,
		double
	)

DECLARE_PROMOTE() [23/31]

combblas::DECLARE_PROMOTE	(	double	,
		int64_t	,
		double
	)

DECLARE_PROMOTE() [24/31]

combblas::DECLARE_PROMOTE	(	int64_t	,
		double	,
		double
	)

DECLARE_PROMOTE() [25/31]

combblas::DECLARE_PROMOTE	(	double	,
		uint64_t	,
		double
	)

DECLARE_PROMOTE() [26/31]

combblas::DECLARE_PROMOTE	(	uint64_t	,
		double	,
		double
	)

DECLARE_PROMOTE() [27/31]

combblas::DECLARE_PROMOTE	(	float	,
		float	,
		float
	)

DECLARE_PROMOTE() [28/31]

combblas::DECLARE_PROMOTE	(	double	,
		double	,
		double
	)

DECLARE_PROMOTE() [29/31]

combblas::DECLARE_PROMOTE	(	int	,
		int	,
		int
	)

DECLARE_PROMOTE() [30/31]

combblas::DECLARE_PROMOTE	(	unsigned	,
		unsigned	,
		unsigned
	)

DECLARE_PROMOTE() [31/31]

combblas::DECLARE_PROMOTE	(	unsigned long	long,
		unsigned long	long,
		unsigned long	long
	)

DeleteAll() [1/6]

template<typename A >

void combblas::DeleteAll

(

A

arr1

)

Definition at line 48 of file Deleter.h.

DeleteAll() [2/6]

template<typename A , typename B >

void combblas::DeleteAll	(	A	arr1,
		B	arr2
	)

Definition at line 54 of file Deleter.h.

DeleteAll() [3/6]

template<typename A , typename B , typename C >

void combblas::DeleteAll	(	A	arr1,
		B	arr2,
		C	arr3
	)

Definition at line 61 of file Deleter.h.

DeleteAll() [4/6]

template<typename A , typename B , typename C , typename D >

void combblas::DeleteAll	(	A	arr1,
		B	arr2,
		C	arr3,
		D	arr4
	)

Definition at line 68 of file Deleter.h.

DeleteAll() [5/6]

template<typename A , typename B , typename C , typename D , typename E >

void combblas::DeleteAll	(	A	arr1,
		B	arr2,
		C	arr3,
		D	arr4,
		E	arr5
	)

Definition at line 76 of file Deleter.h.

DeleteAll() [6/6]

template<typename A , typename B , typename C , typename D , typename E , typename F >

void combblas::DeleteAll	(	A	arr1,
		B	arr2,
		C	arr3,
		D	arr4,
		E	arr5,
		F	arr6
	)

Definition at line 83 of file Deleter.h.

estimateNNZ()

template<typename IT , typename NT1 , typename NT2 >

IT* combblas::estimateNNZ	(	const SpDCCols< IT, NT1 > &	A,
		const SpDCCols< IT, NT2 > &	B
	)

Definition at line 211 of file mtSpGEMM.h.

EstPerProcessNnzSUMMA()

template<typename IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB >

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

Precondition

{ Input matrices, A and B, should not alias }

Definition at line 916 of file ParFriends.h.

EWiseApply() [1/11]

template<typename N_promote , typename IU , typename NU1 , typename NU2 , typename _BinaryOperation >

Dcsc<IU, N_promote> combblas::EWiseApply	(	const Dcsc< IU, NU1 > &	A,
		const Dcsc< IU, NU2 > *	B,
		_BinaryOperation	__binary_op,
		bool	notB,
		const NU2 &	defaultBVal
	)

Definition at line 814 of file Friends.h.

EWiseApply() [2/11]

template<typename N_promote , typename IU , typename NU1 , typename NU2 , typename _BinaryOperation >

SpDCCols<IU, N_promote> combblas::EWiseApply	(	const SpDCCols< IU, NU1 > &	A,
		const SpDCCols< IU, NU2 > &	B,
		_BinaryOperation	__binary_op,
		bool	notB,
		const NU2 &	defaultBVal
	)

Definition at line 960 of file Friends.h.

EWiseApply() [3/11]

template<typename RETT , typename IU , typename NU1 , typename NU2 , typename _BinaryOperation , typename _BinaryPredicate >

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

Definition at line 993 of file Friends.h.

EWiseApply() [4/11]

template<typename RETT , typename IU , typename NU1 , typename NU2 , typename _BinaryOperation , typename _BinaryPredicate >

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
	)

Definition at line 1224 of file Friends.h.

EWiseApply() [5/11]

template<typename RETT , typename RETDER , typename IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB , typename _BinaryOperation >

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 1842 of file ParFriends.h.

EWiseApply() [6/11]

template<typename RETT , typename RETDER , typename IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB , typename _BinaryOperation , typename _BinaryPredicate >

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 1859 of file ParFriends.h.

EWiseApply() [7/11]

template<typename RETT , typename RETDER , typename IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB , typename _BinaryOperation , typename _BinaryPredicate >

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.

EWiseApply() [8/11]

template<typename RET , typename IU , typename NU1 , typename NU2 , typename _BinaryOperation , typename _BinaryPredicate >

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 2127 of file ParFriends.h.

EWiseApply() [9/11]

template<typename RET , typename IU , typename NU1 , typename NU2 , typename _BinaryOperation , typename _BinaryPredicate >

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:

Todo:

: Should allowIntersect be "false" for all SetDifference uses?

Definition at line 2228 of file ParFriends.h.

EWiseApply() [10/11]

template<typename RET , typename IU , typename NU1 , typename NU2 , typename _BinaryOperation , typename _BinaryPredicate >

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 2326 of file ParFriends.h.

EWiseApply() [11/11]

template<typename RET , typename IU , typename NU1 , typename NU2 , typename _BinaryOperation , typename _BinaryPredicate >

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 2340 of file ParFriends.h.

EWiseApply_threaded()

template<typename RET , typename IU , typename NU1 , typename NU2 , typename _BinaryOperation , typename _BinaryPredicate >

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 1981 of file ParFriends.h.

EWiseMult() [1/4]

template<typename IU , typename NU1 , typename NU2 >

Dcsc<IU, typename promote_trait<NU1,NU2>::T_promote> combblas::EWiseMult	(	const Dcsc< IU, NU1 > &	A,
		const Dcsc< IU, NU2 > *	B,
		bool	exclude
	)

Parameters

[in]

exclude

if false, then operation is A = A .* B else operation is A = A .* not(B)

Definition at line 694 of file Friends.h.

EWiseMult() [2/4]

template<typename IU , typename NU1 , typename NU2 >

SpDCCols<IU, typename promote_trait<NU1,NU2>::T_promote > combblas::EWiseMult	(	const SpDCCols< IU, NU1 > &	A,
		const SpDCCols< IU, NU2 > &	B,
		bool	exclude
	)

Definition at line 935 of file Friends.h.

EWiseMult() [3/4]

template<typename IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB >

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 1822 of file ParFriends.h.

EWiseMult() [4/4]

template<typename IU , typename NU1 , typename NU2 >

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 1892 of file ParFriends.h.

ExchangeData()

template<class IT , class NT >

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 46 of file ApproxWeightPerfectMatching.h.

ExchangeData1()

template<class IT , class NT >

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 94 of file ApproxWeightPerfectMatching.h.

findColSplitters()

template<typename RT , typename IT , typename NT >

std::vector<RT> combblas::findColSplitters	(	SpTuples< IT, NT > *&	spTuples,
		int	nsplits
	)

Definition at line 17 of file MultiwayMerge.h.

First4Clust()

template<typename IT >

void combblas::First4Clust

(

FullyDistVec< IT, IT > &

cc

)

Definition at line 334 of file CC.h.

fmix64()

uint64_t combblas::fmix64 ( uint64_t  k )

inline

Definition at line 97 of file hash.cpp.

Generator()

template<typename IT , typename NT >

void combblas::Generator	(	unsigned	scale,
		unsigned	EDGEFACTOR,
		double	initiator[4],
		CCGrid &	CMG,
		SpDCCols< IT, NT > &	splitmat,
		bool	trans,
		bool	scramble
	)

Parameters

[out]

splitmat

{generated RMAT matrix, split into CMG.GridLayers pieces}

Definition at line 68 of file GenRmatDist.h.

generic_gespmv() [1/2]

template<typename SR , typename MIND , typename VIND , typename DER , typename NUM , typename IVT , typename OVT >

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
	)

SpMV with sparse vector MIND: Matrix index type VIND: Vector index type (optimized: int32_t, general: int64_t)

Definition at line 402 of file Friends.h.

generic_gespmv() [2/2]

template<typename SR , typename IU , typename DER , typename NUM , typename IVT , typename OVT >

void combblas::generic_gespmv	(	const SpMat< IU, NUM, DER > &	A,
		const int32_t *	indx,
		const IVT *	numx,
		int32_t	nnzx,
		int32_t *	indy,
		OVT *	numy,
		int *	cnts,
		int *	dspls,
		int	p_c,
		bool	indexisvalue
	)

SpMV with sparse vector

Parameters

[in]

indexisvalue

is only used for BFS-like computations, if true then we can call the optimized version that skips SPA

Definition at line 421 of file Friends.h.

generic_gespmv_threaded()

template<typename SR , typename IU , typename NUM , typename DER , typename IVT , typename OVT >

int combblas::generic_gespmv_threaded	(	const SpMat< IU, NUM, DER > &	A,
		const int32_t *	indx,
		const IVT *	numx,
		int32_t	nnzx,
		int32_t *&	sendindbuf,
		OVT *&	sendnumbuf,
		int *&	sdispls,
		int	p_c,
		PreAllocatedSPA< OVT > &	SPA
	)

Multithreaded SpMV with sparse vector the assembly of outgoing buffers sendindbuf/sendnumbuf are done here

Definition at line 139 of file Friends.h.

generic_gespmv_threaded_setbuffers()

template<typename SR , typename IU , typename NUM , typename DER , typename IVT , typename OVT >

void combblas::generic_gespmv_threaded_setbuffers	(	const SpMat< IU, NUM, DER > &	A,
		const int32_t *	indx,
		const IVT *	numx,
		int32_t	nnzx,
		int32_t *	sendindbuf,
		OVT *	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 IVT: input vector numerical type OVT: output vector numerical type

Definition at line 280 of file Friends.h.

GenMat()

template<typename IT , typename NT >

SpDCCols<IT,NT>* combblas::GenMat	(	CCGrid &	CMG,
		unsigned	scale,
		unsigned	EDGEFACTOR,
		double	initiator[4],
		bool	permute
	)

Definition at line 83 of file SplitMatDist.h.

GenRMat()

template<typename IT , typename NT >

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.

getblock()

uint64_t combblas::getblock ( const uint64_t *  p, int  i  )

inline

Definition at line 63 of file hash.cpp.

HistCC()

template<typename IT >

void combblas::HistCC	(	FullyDistVec< IT, IT >	CC,
		IT	nCC
	)

Definition at line 352 of file CC.h.

isMatching()

template<class IT , class NT >

bool combblas::isMatching	(	FullyDistVec< IT, NT > &	mateCol2Row,
		FullyDistVec< IT, NT > &	mateRow2Col
	)

Definition at line 80 of file Utility.h.

isMaximalmatching()

template<class Par_DCSC_Bool , class IT , class NT >

bool combblas::isMaximalmatching	(	Par_DCSC_Bool &	A,
		FullyDistVec< IT, NT > &	mateRow2Col,
		FullyDistVec< IT, NT > &	mateCol2Row
	)

Definition at line 403 of file BPMaximalMatching.h.

LabelCC()

template<typename IT >

IT combblas::LabelCC	(	FullyDistVec< IT, IT > &	father,
		FullyDistVec< IT, IT > &	cclabel
	)

Definition at line 262 of file CC.h.

LocalSpGEMM()

template<typename SR , typename NTO , typename IT , typename NT1 , typename NT2 >

SpTuples< IT, NTO > * combblas::LocalSpGEMM	(	const SpDCCols< IT, NT1 > &	A,
		const SpDCCols< IT, NT2 > &	B,
		bool	clearA,
		bool	clearB
	)

Definition at line 78 of file mtSpGEMM.h.

LocalSpMV() [1/2]

template<typename VT , typename IT , typename UDER >

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)

Parameters

[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.

LocalSpMV() [2/2]

template<typename SR , typename IVT , typename OVT , typename IU , typename NUM , typename UDER >

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

Parameters

[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.

MatchingWeight() [1/2]

template<class IT , class NT , class DER >

NT combblas::MatchingWeight	(	SpParMat< IT, NT, DER > &	A,
		FullyDistVec< IT, IT >	mateRow2Col,
		FullyDistVec< IT, IT > &	mateCol2Row
	)

Definition at line 160 of file Utility.h.

MatchingWeight() [2/2]

template<class NT >

NT combblas::MatchingWeight	(	std::vector< NT > &	RepMateWC2R,
		MPI_Comm	RowWorld,
		NT &	minw
	)

Definition at line 333 of file ApproxWeightPerfectMatching.h.

MateBcast()

template<class IT >

std::vector<std::tuple<IT,IT> > combblas::MateBcast	(	std::vector< std::tuple< IT, IT >>	sendTuples,
		MPI_Comm	World
	)

Definition at line 187 of file ApproxWeightPerfectMatching.h.

MaximalMatching()

template<typename Par_DCSC_Bool , typename IT >

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 25 of file BPMaximalMatching.h.

maximumMatching()

template<typename IT , typename NT , typename DER >

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 231 of file BPMaximumMatching.h.

MCLPruneRecoverySelect()

template<typename IT , typename NT , typename DER >

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.

MemEfficientSpGEMM()

template<typename SR , typename NUO , typename UDERO , typename IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB >

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.

MergeAll()

template<class SR , class IU , class NU >

SpTuples<IU,NU> combblas::MergeAll	(	const std::vector< SpTuples< IU, NU > *> &	ArrSpTups,
		IU	mstar = 0,
		IU	nstar = 0,
		bool	delarrs = false
	)

Definition at line 605 of file Friends.h.

MergeContributions() [1/2]

template<typename IU , typename VT >

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.

MergeContributions() [2/2]

template<typename SR , typename IU , typename OVT >

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.

MergeContributions_threaded()

template<typename SR , typename IU , typename OVT >

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.

MIS2()

template<typename ONT , typename IT , typename INT , typename DER >

FullyDistSpVec<IT, ONT> combblas::MIS2

(

SpParMat< IT, INT, DER >

A

)

Definition at line 118 of file RestrictionOp.h.

MPIType()

template<typename T >

MPI_Datatype combblas::MPIType

(

void

)

Definition at line 106 of file MPIType.h.

MPIType< bool >()

template<>

MPI_Datatype combblas::MPIType< bool >

(

void

)

Definition at line 84 of file MPIType.cpp.

MPIType< double >()

template<>

MPI_Datatype combblas::MPIType< double >

(

void

)

Definition at line 76 of file MPIType.cpp.

MPIType< float >()

template<>

MPI_Datatype combblas::MPIType< float >

(

void

)

Definition at line 72 of file MPIType.cpp.

MPIType< int32_t >()

template<>

MPI_Datatype combblas::MPIType< int32_t >

(

void

)

Definition at line 56 of file MPIType.cpp.

MPIType< int64_t >()

template<>

MPI_Datatype combblas::MPIType< int64_t >

(

void

)

Definition at line 64 of file MPIType.cpp.

MPIType< long double >()

template<>

MPI_Datatype combblas::MPIType< long double >

(

void

)

Definition at line 80 of file MPIType.cpp.

MPIType< signed char >()

template<>

MPI_Datatype combblas::MPIType< signed char >

(

void

)

Definition at line 40 of file MPIType.cpp.

MPIType< signed short int >()

template<>

MPI_Datatype combblas::MPIType< signed short int >

(

void

)

Definition at line 48 of file MPIType.cpp.

MPIType< uint32_t >()

template<>

MPI_Datatype combblas::MPIType< uint32_t >

(

void

)

Definition at line 60 of file MPIType.cpp.

MPIType< uint64_t >()

template<>

MPI_Datatype combblas::MPIType< uint64_t >

(

void

)

Definition at line 68 of file MPIType.cpp.

MPIType< unsigned char >()

template<>

MPI_Datatype combblas::MPIType< unsigned char >

(

void

)

Definition at line 44 of file MPIType.cpp.

MPIType< unsigned short int >()

template<>

MPI_Datatype combblas::MPIType< unsigned short int >

(

void

)

Definition at line 52 of file MPIType.cpp.

Mult_AnXBn_ActiveTarget()

template<typename SR , typename IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB >

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 59 of file ParFriendsExt.h.

Mult_AnXBn_DoubleBuff()

template<typename SR , typename NUO , typename UDERO , typename IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB >

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

Precondition

{ Input matrices, A and B, should not alias } Most memory efficient version available. Total stages: 2*sqrt(p) Memory requirement during first sqrt(p) stages: <= (3/2)*(nnz(A)+nnz(B))+(1/2)*nnz(C) Memory requirement during second sqrt(p) stages: <= nnz(A)+nnz(B)+nnz(C) Final memory requirement: nnz(C) if clearA and clearB are true

Definition at line 618 of file ParFriends.h.

Mult_AnXBn_Fence()

template<typename SR , typename IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB >

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 449 of file ParFriendsExt.h.

Mult_AnXBn_PassiveTarget()

template<typename SR , typename IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB >

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 292 of file ParFriendsExt.h.

Mult_AnXBn_Synch()

template<typename SR , typename NUO , typename UDERO , typename IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB >

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

Precondition

{ Input matrices, A and B, should not alias }

Definition at line 793 of file ParFriends.h.

multiply()

template<typename IT , typename NT >

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.

MultiplyReturnTuples()

template<typename SR , typename NUO , typename IU , typename NU1 , typename NU2 , typename DER1 , typename DER2 >

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
	)

Returns a pointer to SpTuples, in order to avoid temporaries It is the caller's responsibility to delete the returned pointer afterwards

Definition at line 135 of file SpMat.cpp.

MultiwayMerge()

template<class SR , class IT , class NT >

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.

MurmurHash3_x64_128()

void combblas::MurmurHash3_x64_128	(	const void *	key,
		const int	len,
		const uint32_t	seed,
		void *	out
	)

Definition at line 108 of file hash.cpp.

MurmurHash3_x64_32()

void combblas::MurmurHash3_x64_32	(	const void *	key,
		int	len,
		uint32_t	seed,
		void *	out
	)

Definition at line 183 of file hash.cpp.

MurmurHash3_x64_64()

void combblas::MurmurHash3_x64_64	(	const void *	key,
		int	len,
		uint32_t	seed,
		void *	out
	)

Definition at line 194 of file hash.cpp.

neigborsInSameCC()

template<typename IT , typename NT , typename DER >

bool combblas::neigborsInSameCC	(	const SpParMat< IT, NT, DER > &	A,
		FullyDistVec< IT, IT > &	cclabel
	)

Definition at line 225 of file CC.h.

operator*()

template<typename BT >

MMmul< BT > combblas::operator* ( const BT &  smm1, const BT &  smm2  )

inline

Just defer the multiplication

Definition at line 51 of file MMmul.h.

operator<<() [1/3]

ofstream& combblas::operator<<	(	ofstream &	outfile,
		const MemoryPool &	mpool
	)

Dump the contents of the pinned memory.

Definition at line 140 of file MemoryPool.cpp.

operator<<() [2/3]

template<typename UIT , typename UNT , typename UDER >

std::ofstream& combblas::operator<<	(	std::ofstream &	outfile,
		const SpMat< UIT, UNT, UDER > &	s
	)

Definition at line 201 of file SpMat.cpp.

operator<<() [3/3]

template<class IU , class NU , class UDER >

std::ofstream& combblas::operator<<	(	std::ofstream &	outfile,
		const SpParMat< IU, NU, UDER > &	s
	)

Definition at line 4255 of file SpParMat.cpp.

operator>>()

template<typename UIT , typename UNT , typename UDER >

std::ifstream& combblas::operator>>	(	std::ifstream &	infile,
		SpMat< UIT, UNT, UDER > &	s
	)

Definition at line 207 of file SpMat.cpp.

OwnerProcs()

template<class IT , class NT , class DER >

int combblas::OwnerProcs	(	SpParMat< IT, NT, DER > &	A,
		IT	grow,
		IT	gcol,
		IT	nrows,
		IT	ncols
	)

Definition at line 143 of file ApproxWeightPerfectMatching.h.

ParallelReduce_Alltoall_threaded()

template<typename SR , typename IT , typename NT >

SpTuples<IT,NT>* combblas::ParallelReduce_Alltoall_threaded	(	MPI_Comm &	fibWorld,
		SpTuples< IT, NT > *&	localmerged
	)

Definition at line 37 of file Reductions.h.

ParseHeader()

HeaderInfo combblas::ParseHeader ( const std::string &  inputname, FILE *&  f, int &  seeklength  )

inline

Definition at line 52 of file FileHeader.h.

PermEdges() [1/2]

template<typename IU >

void combblas::PermEdges

(

DistEdgeList< IU > &

DEL

)

PermEdges() [2/2]

template<typename IT >

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.

PermMat()

template<class IT , class DER >

SpParMat<IT, bool, DER> combblas::PermMat	(	const FullyDistVec< IT, IT > &	ri,
		const IT	ncol
	)

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 27 of file BPMaximumMatching.h.

Phase1()

template<class IT , class NT >

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 415 of file ApproxWeightPerfectMatching.h.

Phase2()

template<class IT , class NT >

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 560 of file ApproxWeightPerfectMatching.h.

Phase2_old()

template<class IT , class NT >

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 759 of file ApproxWeightPerfectMatching.h.

prefixsum()

template<typename T >

T* combblas::prefixsum	(	T *	in,
		int	size,
		int	nthreads
	)

Definition at line 24 of file mtSpGEMM.h.

PrintCC()

template<typename IT >

void combblas::PrintCC	(	FullyDistVec< IT, IT >	CC,
		IT	nCC
	)

Definition at line 323 of file CC.h.

ProductGrid()

shared_ptr<CommGrid> combblas::ProductGrid	(	CommGrid *	gridA,
		CommGrid *	gridB,
		int &	innerdim,
		int &	Aoffset,
		int &	Boffset
	)

Definition at line 164 of file CommGrid.cpp.

PSpGEMM() [1/2]

template<typename SR , typename NUO , typename UDERO , typename IU , typename NU1 , typename NU2 , typename UDER1 , typename UDER2 >

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.

PSpGEMM() [2/2]

template<typename SR , typename IU , typename NU1 , typename NU2 , typename UDER1 , typename UDER2 >

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.

Reader()

template<typename IT , typename NT >

void combblas::Reader	(	string	filename,
		CCGrid &	CMG,
		SpDCCols< IT, NT > &	splitmat,
		bool	trans,
		bool	permute,
		FullyDistVec< IT, IT > &	p
	)

Parameters

[out]

splitmat

{read matrix market file into layer 0, and split into CMG.GridLayers pieces}

Definition at line 41 of file ReadMatDist.h.

ReadMat()

template<typename NT , typename IT >

SpDCCols<IT,NT>* combblas::ReadMat	(	std::string	filename,
		CCGrid &	CMG,
		bool	permute,
		FullyDistVec< IT, IT > &	p
	)

Definition at line 30 of file SplitMatDist.h.

ReduceAll_threaded()

template<typename NT , typename IT >

SpDCCols<IT,NT>* combblas::ReduceAll_threaded	(	std::vector< SpTuples< IT, NT > * > &	unreducedC,
		CCGrid &	CMG
	)

Definition at line 134 of file Reductions.h.

removeIsolated()

template<typename PARMAT >

void combblas::removeIsolated

(

PARMAT &

A

)

Definition at line 12 of file Utility.h.

RenameVertices()

template<typename IU >

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.

ReplicateMateWeights()

template<class IT , class NT >

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 228 of file ApproxWeightPerfectMatching.h.

RestrictionOp()

template<typename IT , typename NT >

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.

SerialMerge()

template<class SR , class IT , class NT >

void combblas::SerialMerge	(	const std::vector< SpTuples< IT, NT > *> &	ArrSpTups,
		std::tuple< IT, IT, NT > *	ntuples
	)

Definition at line 94 of file MultiwayMerge.h.

SerialMergeNNZ()

template<class IT , class NT >

IT combblas::SerialMergeNNZ

(

const std::vector< SpTuples< IT, NT > *> &

ArrSpTups

)

Definition at line 40 of file MultiwayMerge.h.

Shortcut()

template<typename IT >

void combblas::Shortcut

(

FullyDistVec< IT, IT > &

father

)

Definition at line 218 of file CC.h.

SplitMat()

template<typename IT , typename NT >

void combblas::SplitMat	(	CCGrid &	CMG,
		SpDCCols< IT, NT > *	localmat,
		SpDCCols< IT, NT > &	splitmat,
		bool	rowsplit = false
	)

Parameters

[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.

SpMV() [1/9]

template<typename VT , typename IT , typename UDER >

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.

SpMV() [2/9]

template<typename SR , typename IU , typename NUM , typename UDER >

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 1582 of file ParFriends.h.

SpMV() [3/9]

template<typename SR , typename IU , typename NUM , typename UDER >

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 1044 of file ParFriends.h.

SpMV() [4/9]

template<typename SR , typename IVT , typename OVT , typename IU , typename NUM , typename UDER >

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.

SpMV() [5/9]

template<typename SR , typename IVT , typename OVT , typename IU , typename NUM , typename UDER >

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.

SpMV() [6/9]

template<typename SR , typename IVT , typename OVT , typename IU , typename NUM , typename UDER >

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.

SpMV() [7/9]

template<typename SR , typename IVT , typename OVT , typename IU , typename NUM , typename UDER >

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.

SpMV() [8/9]

template<typename SR , typename IU , typename NUM , typename NUV , typename UDER >

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 1595 of file ParFriends.h.

SpMV() [9/9]

template<typename SR , typename IU , typename NUM , typename NUV , typename UDER >

FullyDistSpVec<IU,typename promote_trait<NUM,NUV>::T_promote> combblas::SpMV	(	const SpParMat< IU, NUM, UDER > &	A,
		const FullyDistSpVec< IU, NUV > &	x
	)

: Old version that is no longer considered optimal Kept for legacy purposes To be removed when other functionals are fully tested.

Definition at line 1675 of file ParFriends.h.

SpMXSpV() [1/4]

template<class SR , class IT , class NUM , class IVT , class OVT >

void combblas::SpMXSpV	(	const Dcsc< IT, NUM > &	Adcsc,
		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
	)

Overload #1: DCSC.

Definition at line 51 of file SpImpl.h.

SpMXSpV() [2/4]

template<class SR , class IT , class NUM , class IVT , class OVT >

void combblas::SpMXSpV	(	const Dcsc< IT, NUM > &	Adcsc,
		int32_t	mA,
		const int32_t *	indx,
		const IVT *	numx,
		int32_t	veclen,
		int32_t *	indy,
		OVT *	numy,
		int *	cnts,
		int *	dspls,
		int	p_c
	)

Overload #2: DCSC.

Definition at line 61 of file SpImpl.h.

SpMXSpV() [3/4]

template<class SR , class IT , class NUM , class IVT , class OVT >

void combblas::SpMXSpV	(	const Csc< IT, NUM > &	Acsc,
		int32_t	mA,
		const int32_t *	indx,
		const IVT *	numx,
		int32_t	veclen,
		int32_t *	indy,
		OVT *	numy,
		int *	cnts,
		int *	dspls,
		int	p_c
	)

Overload #1: CSC.

Definition at line 107 of file SpImpl.h.

SpMXSpV() [4/4]

template<class SR , class IT , class NUM , class IVT , class OVT >

void combblas::SpMXSpV	(	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
	)

Overload #2: CSC.

Definition at line 116 of file SpImpl.h.

SpMXSpV_Bucket() [1/2]

template<class SR , class IT , class NUM , class IVT , class OVT >

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
	)

SpMXSpV_Bucket() [2/2]

template<typename SR , typename IT , typename NT , typename IVT , typename OVT >

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.

SpMXSpV_ForThreading() [1/4]

template<class SR , class IT , class NUM , class IVT , class OVT >

void combblas::SpMXSpV_ForThreading	(	const Dcsc< IT, NUM > &	Adcsc,
		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
	)

Overload #3: DCSC.

Definition at line 70 of file SpImpl.h.

SpMXSpV_ForThreading() [2/4]

template<class SR , class IT , class NUM , class IVT , class OVT >

void combblas::SpMXSpV_ForThreading	(	const Dcsc< IT, NUM > &	Adcsc,
		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,
		std::vector< OVT > &	localy,
		BitMap &	isthere,
		std::vector< uint32_t > &	nzinds
	)

Overload #4: DCSC w/ preallocated SPA.

Definition at line 78 of file SpImpl.h.

SpMXSpV_ForThreading() [3/4]

template<class SR , class IT , class NUM , class IVT , class OVT >

void combblas::SpMXSpV_ForThreading	(	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
	)

Overload #3: CSC.

Definition at line 128 of file SpImpl.h.

SpMXSpV_ForThreading() [4/4]

template<class SR , class IT , class NUM , class IVT , class OVT >

void combblas::SpMXSpV_ForThreading	(	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,
		std::vector< OVT > &	localy,
		BitMap &	isthere,
		std::vector< uint32_t > &	nzinds
	)

Overload #4: CSC w/ preallocated SPA.

Definition at line 136 of file SpImpl.h.

SpMXSpV_HeapSort() [1/2]

template<typename SR , typename IT , typename NUM , typename IVT , typename OVT >

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
	)

SpMXSpV_HeapSort() [2/2]

template<typename SR , typename IT , typename NT , typename IVT , typename OVT >

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.

StarCheck()

template<typename IT , typename NT , typename DER >

FullyDistVec<IT,short> combblas::StarCheck	(	const SpParMat< IT, NT, DER > &	A,
		FullyDistVec< IT, IT > &	father
	)

Definition at line 83 of file CC.h.

SUMMALayer()

template<typename IT , typename NT >

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.

SuperFastHash()

uint32_t combblas::SuperFastHash	(	const char *	data,
		int	len
	)

Definition at line 11 of file hash.cpp.

Symmetricize()

template<typename PARMAT >

void combblas::Symmetricize

(

PARMAT &

A

)

Definition at line 29 of file ReadMatDist.h.

ThreadBuffLenForBinning()

int combblas::ThreadBuffLenForBinning	(	int	itemsize,
		int	nbins
	)

Definition at line 394 of file ApproxWeightPerfectMatching.h.

Trace()

template<class IT , class NT , class DER >

NT combblas::Trace	(	SpParMat< IT, NT, DER > &	A,
		IT &	rettrnnz = 0
	)

Definition at line 275 of file ApproxWeightPerfectMatching.h.

TransformWeight()

template<class IT , class NT , class DER >

void combblas::TransformWeight	(	SpParMat< IT, NT, DER > &	A,
		bool	applylog
	)

Definition at line 1149 of file ApproxWeightPerfectMatching.h.

TransposeVector()

template<typename IU , typename NV >

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

Parameters

[in,out]	trxlocnz,lenuntil,trxinds,trxnums	{ set or allocated }
[in]	indexisvalue

Definition at line 1057 of file ParFriends.h.

Tuples_AnXBn()

template<class SR , class NUO , class IU , class NU1 , class NU2 >

SpTuples<IU, NUO>* combblas::Tuples_AnXBn	(	const SpDCCols< IU, NU1 > &	A,
		const SpDCCols< IU, NU2 > &	B,
		bool	clearA = false,
		bool	clearB = false
	)

SpTuples(A*B) (Using ColByCol Algorithm) Returns the tuples for efficient merging later Support mixed precision multiplication The multiplication is on the specified semiring (passed as parameter)

Definition at line 554 of file Friends.h.

Tuples_AnXBt()

template<class SR , class NUO , class IU , class NU1 , class NU2 >

SpTuples<IU, NUO>* combblas::Tuples_AnXBt	(	const SpDCCols< IU, NU1 > &	A,
		const SpDCCols< IU, NU2 > &	B,
		bool	clearA = false,
		bool	clearB = false
	)

SpTuples(A*B') (Using OuterProduct Algorithm) Returns the tuples for efficient merging later Support mixed precision multiplication The multiplication is on the specified semiring (passed as parameter)

Definition at line 511 of file Friends.h.

Tuples_AtXBn()

template<class SR , class NUO , class IU , class NU1 , class NU2 >

SpTuples<IU, NUO>* combblas::Tuples_AtXBn	(	const SpDCCols< IU, NU1 > &	A,
		const SpDCCols< IU, NU2 > &	B,
		bool	clearA = false,
		bool	clearB = false
	)

Definition at line 591 of file Friends.h.

Tuples_AtXBt()

template<class SR , class NUO , class IU , class NU1 , class NU2 >

SpTuples<IU, NUO>* combblas::Tuples_AtXBt	(	const SpDCCols< IU, NU1 > &	A,
		const SpDCCols< IU, NU2 > &	B,
		bool	clearA = false,
		bool	clearB = false
	)

Definition at line 578 of file Friends.h.

TwoThirdApprox()

template<class IT , class NT , class DER >

void combblas::TwoThirdApprox	(	SpParMat< IT, NT, DER > &	A,
		FullyDistVec< IT, IT > &	mateRow2Col,
		FullyDistVec< IT, IT > &	mateCol2Row
	)

be very careful here

Definition at line 794 of file ApproxWeightPerfectMatching.h.

UnconditionalHook()

template<typename IT , typename NT , typename DER >

void combblas::UnconditionalHook	(	const SpParMat< IT, NT, DER > &	A,
		FullyDistVec< IT, IT > &	father
	)

Definition at line 175 of file CC.h.

UpdateMatching()

template<class IT >

void combblas::UpdateMatching	(	FullyDistVec< IT, IT > &	mateRow2Col,
		FullyDistVec< IT, IT > &	mateCol2Row,
		std::vector< IT > &	RepMateR2C,
		std::vector< IT > &	RepMateC2R
	)

Definition at line 358 of file ApproxWeightPerfectMatching.h.

UpdateParents()

template<typename VT , typename IT >

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.

WeightedGreedy()

template<typename Par_MAT_Double , typename IT >

void combblas::WeightedGreedy	(	Par_MAT_Double &	A,
		FullyDistVec< IT, IT > &	mateRow2Col,
		FullyDistVec< IT, IT > &	mateCol2Row,
		FullyDistVec< IT, IT > &	degCol
	)

Definition at line 240 of file BPMaximalMatching.h.

WriteMCLClusters() [1/2]

template<class IT >

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

Parameters

[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.

WriteMCLClusters() [2/2]

template<class IT >

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

Parameters

[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.

Variable Documentation

mpidtc

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

Definition at line 38 of file MPIType.cpp.

mpioc

MPIOpCache combblas::mpioc

Definition at line 7 of file MPIOp.cpp.

t1Comm

double combblas::t1Comm

Definition at line 42 of file ApproxWeightPerfectMatching.h.

t1Comp

double combblas::t1Comp

Definition at line 42 of file ApproxWeightPerfectMatching.h.

t2Comm

double combblas::t2Comm

Definition at line 42 of file ApproxWeightPerfectMatching.h.

t2Comp

double combblas::t2Comp

Definition at line 42 of file ApproxWeightPerfectMatching.h.

t3Comm

double combblas::t3Comm

Definition at line 42 of file ApproxWeightPerfectMatching.h.

t3Comp

double combblas::t3Comp

Definition at line 42 of file ApproxWeightPerfectMatching.h.

t4Comm

double combblas::t4Comm

Definition at line 42 of file ApproxWeightPerfectMatching.h.

t4Comp

double combblas::t4Comp

Definition at line 42 of file ApproxWeightPerfectMatching.h.

t5Comm

double combblas::t5Comm

Definition at line 42 of file ApproxWeightPerfectMatching.h.

t5Comp

double combblas::t5Comp

Definition at line 42 of file ApproxWeightPerfectMatching.h.

tUpdateMateComp

double combblas::tUpdateMateComp

Definition at line 42 of file ApproxWeightPerfectMatching.h.