combblas Namespace Reference

Classes
struct	absdiff
struct	Arr
struct	AWPM_param
class	BinaryMin
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	BlockSpGEMM
struct	BoolCopy1stSRing
struct	BoolCopy2ndSRing
class	CCGrid
struct	ColCompare
struct	ColLexiCompare
struct	ColLexiCompareWithID
class	CommGrid
class	CommGrid3D
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	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< NT, NT >
struct	promote_trait< NZT, samparr_t >
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
class	SamplesSaveHandler
struct	sel2nd
struct	Select2ndMinSR
struct	Select2ndRandSR
struct	Select2ndSRing
struct	SelectMaxSRing
struct	SelectMaxSRing< bool, T2 >
struct	SelectMinxSR
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	SpParMat3D
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
typedef std::array< float, NROUNDS >	samparr_t

Enumerations
enum	Dim {   Column , Row , Column , Row ,   Column , Row }
enum	Dim {   Column , Row , Column , Row ,   Column , Row }
enum	Dim {   Column , Row , Column , Row ,   Column , Row }

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<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, bool weightedCard=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<class T , class I >
void	omp_par_scan (T *A, T *B, I cnt)
template<typename T >
int	Mpi_Alltoallv_kway (T *sbuff_, int *s_cnt_, int *sdisp_, T *rbuff_, int *r_cnt_, int *rdisp_, MPI_Comm c, int kway=2)
template<typename T >
int	Mpi_Alltoallv (T *sbuff, int *s_cnt, int *sdisp, T *rbuff, int *r_cnt, int *rdisp, MPI_Comm comm)
template<class IT , class NT >
int	replicate (const FullyDistVec< IT, NT > dense, FullyDistSpVec< IT, IT > ri, vector< vector< NT > > &bcastBuffer)
template<class IT , class NT >
FullyDistSpVec< IT, NT >	Extract (const FullyDistVec< IT, NT > dense, FullyDistSpVec< IT, IT > ri)
template<class IT , class NT >
int	ReduceAssign (FullyDistSpVec< IT, IT > &ind, FullyDistSpVec< IT, NT > &val, vector< vector< NT > > &reduceBuffer, NT MAX_FOR_REDUCE)
template<class IT , class NT >
int	ReduceAssign (FullyDistSpVec< IT, IT > &ind, NT val, vector< vector< NT > > &reduceBuffer, NT MAX_FOR_REDUCE)
template<class IT , class NT >
FullyDistSpVec< IT, NT >	Assign (FullyDistSpVec< IT, IT > &ind, FullyDistSpVec< IT, NT > &val)
template<class IT , class NT >
FullyDistSpVec< IT, NT >	Assign (FullyDistSpVec< IT, IT > &ind, NT val)
template<typename IT , typename NT , typename DER >
void	StarCheckAfterHooking (const SpParMat< IT, NT, DER > &A, FullyDistVec< IT, IT > &parent, FullyDistVec< IT, short > &star, FullyDistSpVec< IT, IT > condhooks, bool isStar2StarHookPossible)
template<typename IT >
void	StarCheck (FullyDistVec< IT, IT > &parents, FullyDistVec< IT, short > &stars)
template<typename IT , typename NT , typename DER >
FullyDistSpVec< IT, IT >	ConditionalHook (const SpParMat< IT, NT, DER > &A, FullyDistVec< IT, IT > &parent, FullyDistVec< IT, short > stars, int iteration)
template<typename IT , typename NT , typename DER >
FullyDistSpVec< IT, IT >	UnconditionalHook2 (const SpParMat< IT, NT, DER > &A, FullyDistVec< IT, IT > &parents, FullyDistVec< IT, short > stars)
template<typename IT >
void	Shortcut (FullyDistVec< IT, IT > &parent)
template<typename IT >
void	Shortcut (FullyDistVec< IT, IT > &parents, FullyDistVec< IT, short > stars)
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 > parent)
template<typename IT >
IT	LabelCC (FullyDistVec< IT, IT > &parent, 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 , class NT >
int	ReduceAssign (FullyDistVec< IT, IT > &ind, FullyDistVec< IT, NT > &val, std::vector< std::vector< NT > > &reduceBuffer, NT MAX_FOR_REDUCE)
template<class IT , class NT >
FullyDistSpVec< IT, NT >	Assign (FullyDistVec< IT, IT > &ind, FullyDistVec< IT, NT > &val)
template<class IT , class NT >
int	replicate (const FullyDistVec< IT, NT > &dense, const FullyDistVec< IT, IT > &ri, std::vector< std::vector< NT > > &bcastBuffer)
template<class IT , class NT >
FullyDistVec< IT, NT >	Extract (const FullyDistVec< IT, NT > &dense, const FullyDistVec< IT, IT > &ri)
template<typename IT , typename NT , typename DER >
FullyDistVec< IT, IT >	SV (SpParMat< IT, NT, DER > &A, 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<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.
template<typename SR , typename IU , typename NU , typename RHS , typename LHS >
void	dcsc_gespmv_threaded_nosplit (const SpDCCols< IU, NU > &A, const RHS *x, LHS *y)
	SpMV with dense vector (multithreaded version)
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)
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 >	SetDifference (const Dcsc< IU, NU1 > &A, const Dcsc< IU, NU2 > *B)
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 NT >
bool	sort_less (const std::pair< IT, NT > &left, const std::pair< IT, NT > &right)
template<typename SR , typename NTO , typename IT , typename NT1 , typename NT2 >
SpTuples< IT, NTO > *	LocalHybridSpGEMM (const SpDCCols< IT, NT1 > &A, const SpDCCols< IT, NT2 > &B, bool clearA, bool clearB, IT *aux=nullptr)
template<typename SR , typename NTO , typename IT , typename NT1 , typename NT2 >
SpTuples< IT, NTO > *	LocalSpGEMMHash (const SpDCCols< IT, NT1 > &A, const SpDCCols< IT, NT2 > &B, bool clearA, bool clearB, bool sort=true)
template<typename SR , typename IT , typename NT1 , typename NT2 >
IT	EstimateLocalFLOP (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, IT *aux=nullptr, bool freeaux=true)
template<typename IT , typename NT1 , typename NT2 >
IT *	estimateNNZ_Hash (const SpDCCols< IT, NT1 > &A, const SpDCCols< IT, NT2 > &B, IT *flopC, IT *aux=nullptr)
template<typename IT , typename NT1 , typename NT2 >
int64_t	estimateNNZ_sampling (const SpDCCols< IT, NT1 > &A, const SpDCCols< IT, NT2 > &B, int nrounds=5)
template<typename IT , typename NT1 , typename NT2 >
IT *	estimateFLOP (const SpDCCols< IT, NT1 > &A, const SpDCCols< IT, NT2 > &B, IT *aux=nullptr)
template<typename SR , typename NTO , typename IT , typename NT1 , typename NT2 >
SpTuples< IT, NTO > *	LocalHybridSpGEMM (const SpCCols< IT, NT1 > &A, const SpCCols< IT, NT2 > &B, bool clearA, bool clearB)
template<typename IT , typename NT1 , typename NT2 >
IT *	estimateFLOP (const SpCCols< IT, NT1 > &A, const SpCCols< IT, NT2 > &B)
template<typename IT , typename NT1 , typename NT2 >
IT *	estimateNNZ_Hash (const SpCCols< IT, NT1 > &A, const SpCCols< IT, NT2 > &B, const IT *flopC)
template<typename T >
T *	prefixSum (T *in, int size, int nthreads)
template<typename RT , typename IT , typename NT >
std::vector< RT >	findColSplitters (SpTuples< IT, NT > *&spTuples, int nsplits)
template<typename RT , typename IT , typename NT >
std::vector< RT >	findColSplittersFinger (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 IT , class NT >
IT *	SerialMergeNNZHash (const std::vector< SpTuples< IT, NT > * > &ArrSpTups, IT &totnnz, IT &maxnnzPerCol, IT startCol, IT endCol)
template<class SR , class IT , class NT >
void	SerialMergeHash (const std::vector< SpTuples< IT, NT > * > &ArrSpTups, std::tuple< IT, IT, NT > *ntuples, IT *colnnz, IT maxcolnnz, IT startCol, IT endCol, bool sorted)
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<class SR , class IT , class NT >
SpTuples< IT, NT > *	MultiwayMergeHash (std::vector< SpTuples< IT, NT > * > &ArrSpTups, IT mdim=0, IT ndim=0, bool delarrs=false, bool sorted=true)
template<class SR , class IT , class NT >
SpTuples< IT, NT > *	MultiwayMergeHashSliding (std::vector< SpTuples< IT, NT > * > &ArrSpTups, IT mdim=0, IT ndim=0, bool delarrs=false, bool sorted=true, IT maxHashTableSize=16384)
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 IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB >
IU	EstimateFLOP (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 >	MemEfficientSpGEMM (SpParMat< IU, NU1, UDERA > &A, SpParMat< IU, NU2, UDERB > &B, int phases, NUO hardThreshold, IU selectNum, IU recoverNum, NUO recoverPct, int kselectVersion, int computationKernel, int64_t perProcessMemory)
template<typename SR , typename NUO , typename UDERO , typename IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB >
int	CalculateNumberOfPhases (SpParMat< IU, NU1, UDERA > &A, SpParMat< IU, NU2, UDERB > &B, 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 SR , typename NUO , typename UDERO , typename IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB >
SpParMat< IU, NUO, UDERO >	Mult_AnXBn_Overlap (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, bool hashEstimate)
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, NU1, UDERA >	SetDifference (const SpParMat< IU, NU1, UDERA > &A, const SpParMat< IU, NU2, UDERB > &B)
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 IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB >
int64_t	EstPerProcessNnzSpMV (SpParMat< IU, NU1, UDERA > &A, SpParMat< IU, NU2, UDERB > &B)
template<typename SR , typename NUO , typename UDERO , typename IU , typename NU1 , typename NU2 , typename UDER1 , typename UDER2 >
SpParMat3D< IU, NUO, UDERO >	Mult_AnXBn_SUMMA3D (SpParMat3D< IU, NU1, UDER1 > &A, SpParMat3D< IU, NU2, UDER2 > &B)
template<typename SR , typename NUO , typename UDERO , typename IU , typename NU1 , typename NU2 , typename UDERA , typename UDERB >
SpParMat3D< IU, NUO, UDERO >	MemEfficientSpGEMM3D (SpParMat3D< IU, NU1, UDERA > &A, SpParMat3D< IU, NU2, UDERB > &B, int phases, NUO hardThreshold, IU selectNum, IU recoverNum, NUO recoverPct, int kselectVersion, int computationKernel, int64_t perProcessMemory)
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 T >
const T	inf_plus (const T &a, const T &b)
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.
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.
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.
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.
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.
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.
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.
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.
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)
template<class IT , class NT >
std::tuple< IT, IT, NT > *	ExchangeData (std::vector< std::vector< std::tuple< IT, IT, NT > > > &tempTuples, MPI_Comm World, IT &datasize)
template<class IT , class NT , class DER >
void	SpecialExchangeData (std::vector< DER > &sendChunks, MPI_Comm World, IT &datasize, NT dummy, vector< DER > &recvChunks)
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<>
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)
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.
template<>
MPI_Datatype	MPIType< signed char > (void)
template<>
MPI_Datatype	MPIType< unsigned char > (void)
template<>
MPI_Datatype	MPIType< signed short int > (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)

Variables
MPIOpCache	mpioc
MPIDataTypeCache	mpidtc

Detailed Description

Connected components based on Awerbuch-Shiloach algorithm

Connected components based on Shiloach-Vishkin 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

samparr_t

typedef std::array< float, NROUNDS > combblas::samparr_t

Definition at line 2714 of file ParFriends.h.

Enumeration Type Documentation

Dim [1/3]

enum combblas::Dim

Enumerator
Column
Row
Column
Row
Column
Row

Definition at line 113 of file SpDefs.h.

Dim [2/3]

enum combblas::Dim

Enumerator
Column
Row
Column
Row
Column
Row

Definition at line 113 of file SpDefs.h.

Dim [3/3]

enum combblas::Dim

Enumerator
Column
Row
Column
Row
Column
Row

Definition at line 113 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 1430 of file ParFriends.h.

Assign() [1/3]

template<class IT , class NT >

FullyDistSpVec< IT, NT > combblas::Assign	(	FullyDistSpVec< IT, IT > &	ind,
		FullyDistSpVec< IT, NT > &	val
	)

Definition at line 747 of file CC.h.

Assign() [2/3]

template<class IT , class NT >

FullyDistSpVec< IT, NT > combblas::Assign	(	FullyDistSpVec< IT, IT > &	ind,
		NT	val
	)

Definition at line 905 of file CC.h.

Assign() [3/3]

template<class IT , class NT >

FullyDistSpVec< IT, NT > combblas::Assign	(	FullyDistVec< IT, IT > &	ind,
		FullyDistVec< IT, NT > &	val
	)

Definition at line 133 of file FastSV.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 129 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 168 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,
		bool	weightedCard = true
	)

Definition at line 1144 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 482 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.

CalculateNumberOfPhases()

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

int combblas::CalculateNumberOfPhases	(	SpParMat< IU, NU1, UDERA > &	A,
		SpParMat< IU, NU2, UDERB > &	B,
		NUO	hardThreshold,
		IU	selectNum,
		IU	recoverNum,
		NUO	recoverPct,
		int	kselectVersion,
		int64_t	perProcessMemory
	)

Definition at line 733 of file ParFriends.h.

CC()

template<typename IT , typename NT , typename DER >

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

Definition at line 1405 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 161 of file ParFriends.h.

CheckSpMVCompliance()

template<typename MATRIX , typename VECTOR >

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

Definition at line 1351 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 61 of file ParFriends.h.

ConditionalHook()

template<typename IT , typename NT , typename DER >

FullyDistSpVec< IT, IT > combblas::ConditionalHook	(	const SpParMat< IT, NT, DER > &	A,
		FullyDistVec< IT, IT > &	parent,
		FullyDistVec< IT, short >	stars,
		int	iteration
	)

Definition at line 1195 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 >	parent
	)

Definition at line 1357 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
	)

Multithreaded SpMV with dense vector

Definition at line 140 of file Friends.h.

dcsc_gespmv_threaded_nosplit()

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

void combblas::dcsc_gespmv_threaded_nosplit	(	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	(	bool	,
		bool	,
		bool
	)

DECLARE_PROMOTE() [2/31]

combblas::DECLARE_PROMOTE	(	bool	,
		double	,
		double
	)

DECLARE_PROMOTE() [3/31]

combblas::DECLARE_PROMOTE	(	bool	,
		float	,
		float
	)

DECLARE_PROMOTE() [4/31]

combblas::DECLARE_PROMOTE	(	bool	,
		int	,
		int
	)

DECLARE_PROMOTE() [5/31]

combblas::DECLARE_PROMOTE	(	bool	,
		int64_t	,
		int64_t
	)

DECLARE_PROMOTE() [6/31]

combblas::DECLARE_PROMOTE	(	bool	,
		short	,
		short
	)

DECLARE_PROMOTE() [7/31]

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

DECLARE_PROMOTE() [8/31]

combblas::DECLARE_PROMOTE	(	bool	,
		unsigned	,
		unsigned
	)

DECLARE_PROMOTE() [9/31]

combblas::DECLARE_PROMOTE	(	double	,
		bool	,
		double
	)

DECLARE_PROMOTE() [10/31]

combblas::DECLARE_PROMOTE	(	double	,
		double	,
		double
	)

DECLARE_PROMOTE() [11/31]

combblas::DECLARE_PROMOTE	(	double	,
		int	,
		double
	)

DECLARE_PROMOTE() [12/31]

combblas::DECLARE_PROMOTE	(	double	,
		int64_t	,
		double
	)

DECLARE_PROMOTE() [13/31]

combblas::DECLARE_PROMOTE	(	double	,
		uint64_t	,
		double
	)

DECLARE_PROMOTE() [14/31]

combblas::DECLARE_PROMOTE	(	float	,
		bool	,
		float
	)

DECLARE_PROMOTE() [15/31]

combblas::DECLARE_PROMOTE	(	float	,
		float	,
		float
	)

DECLARE_PROMOTE() [16/31]

combblas::DECLARE_PROMOTE	(	float	,
		int	,
		float
	)

DECLARE_PROMOTE() [17/31]

combblas::DECLARE_PROMOTE	(	int	,
		bool	,
		int
	)

DECLARE_PROMOTE() [18/31]

combblas::DECLARE_PROMOTE	(	int	,
		double	,
		double
	)

DECLARE_PROMOTE() [19/31]

combblas::DECLARE_PROMOTE	(	int	,
		float	,
		float
	)

DECLARE_PROMOTE() [20/31]

combblas::DECLARE_PROMOTE	(	int	,
		int	,
		int
	)

DECLARE_PROMOTE() [21/31]

combblas::DECLARE_PROMOTE	(	int	,
		int64_t	,
		int64_t
	)

DECLARE_PROMOTE() [22/31]

combblas::DECLARE_PROMOTE	(	int64_t	,
		bool	,
		int64_t
	)

DECLARE_PROMOTE() [23/31]

combblas::DECLARE_PROMOTE	(	int64_t	,
		double	,
		double
	)

DECLARE_PROMOTE() [24/31]

combblas::DECLARE_PROMOTE	(	int64_t	,
		int	,
		int64_t
	)

DECLARE_PROMOTE() [25/31]

combblas::DECLARE_PROMOTE	(	int64_t	,
		int64_t	,
		int64_t
	)

DECLARE_PROMOTE() [26/31]

combblas::DECLARE_PROMOTE	(	short	,
		bool	,
		short
	)

DECLARE_PROMOTE() [27/31]

combblas::DECLARE_PROMOTE	(	uint64_t	,
		double	,
		double
	)

DECLARE_PROMOTE() [28/31]

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

DECLARE_PROMOTE() [29/31]

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

DECLARE_PROMOTE() [30/31]

combblas::DECLARE_PROMOTE	(	unsigned	,
		bool	,
		unsigned
	)

DECLARE_PROMOTE() [31/31]

combblas::DECLARE_PROMOTE	(	unsigned	,
		unsigned	,
		unsigned
	)

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.

estimateFLOP() [1/2]

template<typename IT , typename NT1 , typename NT2 >

IT * combblas::estimateFLOP	(	const SpCCols< IT, NT1 > &	A,
		const SpCCols< IT, NT2 > &	B
	)

Definition at line 1322 of file mtSpGEMM.h.

estimateFLOP() [2/2]

template<typename IT , typename NT1 , typename NT2 >

IT * combblas::estimateFLOP	(	const SpDCCols< IT, NT1 > &	A,
		const SpDCCols< IT, NT2 > &	B,
		IT *	aux = nullptr
	)

Definition at line 1058 of file mtSpGEMM.h.

EstimateFLOP()

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

IU combblas::EstimateFLOP	(	SpParMat< IU, NU1, UDERA > &	A,
		SpParMat< IU, NU2, UDERB > &	B,
		bool	clearA = false,
		bool	clearB = false
	)

Definition at line 356 of file ParFriends.h.

EstimateLocalFLOP()

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

IT combblas::EstimateLocalFLOP	(	const SpDCCols< IT, NT1 > &	A,
		const SpDCCols< IT, NT2 > &	B,
		bool	clearA,
		bool	clearB
	)

Definition at line 663 of file mtSpGEMM.h.

estimateNNZ()

template<typename IT , typename NT1 , typename NT2 >

IT * combblas::estimateNNZ	(	const SpDCCols< IT, NT1 > &	A,
		const SpDCCols< IT, NT2 > &	B,
		IT *	aux = nullptr,
		bool	freeaux = true
	)

Definition at line 693 of file mtSpGEMM.h.

estimateNNZ_Hash() [1/2]

template<typename IT , typename NT1 , typename NT2 >

IT * combblas::estimateNNZ_Hash	(	const SpCCols< IT, NT1 > &	A,
		const SpCCols< IT, NT2 > &	B,
		const IT *	flopC
	)

Definition at line 1367 of file mtSpGEMM.h.

estimateNNZ_Hash() [2/2]

template<typename IT , typename NT1 , typename NT2 >

IT * combblas::estimateNNZ_Hash	(	const SpDCCols< IT, NT1 > &	A,
		const SpDCCols< IT, NT2 > &	B,
		IT *	flopC,
		IT *	aux = nullptr
	)

Definition at line 807 of file mtSpGEMM.h.

estimateNNZ_sampling()

template<typename IT , typename NT1 , typename NT2 >

int64_t combblas::estimateNNZ_sampling	(	const SpDCCols< IT, NT1 > &	A,
		const SpDCCols< IT, NT2 > &	B,
		int	nrounds = 5
	)

Definition at line 938 of file mtSpGEMM.h.

EstPerProcessNnzSpMV()

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

int64_t combblas::EstPerProcessNnzSpMV	(	SpParMat< IU, NU1, UDERA > &	A,
		SpParMat< IU, NU2, UDERB > &	B
	)

Definition at line 2810 of file ParFriends.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,
		bool	hashEstimate
	)

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 1243 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 890 of file Friends.h.

EWiseApply() [2/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 1069 of file Friends.h.

EWiseApply() [3/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?

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?

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

EWiseApply() [4/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 2692 of file ParFriends.h.

EWiseApply() [5/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 2678 of file ParFriends.h.

EWiseApply() [6/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 2479 of file ParFriends.h.

EWiseApply() [7/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 1300 of file Friends.h.

EWiseApply() [8/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 1036 of file Friends.h.

EWiseApply() [9/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 2211 of file ParFriends.h.

EWiseApply() [10/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 2230 of file ParFriends.h.

EWiseApply() [11/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 2194 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 2333 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)

Aydin (June 2021): exclude=true case of this function now calls SetDifference above, to remove code duplication

Definition at line 834 of file Friends.h.

EWiseMult() [2/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 2244 of file ParFriends.h.

EWiseMult() [3/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 1011 of file Friends.h.

EWiseMult() [4/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 2174 of file ParFriends.h.

ExchangeData() [1/2]

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

ExchangeData() [2/2]

template<class IT , class NT >

std::tuple< IT, IT, NT > * combblas::ExchangeData	(	std::vector< std::vector< std::tuple< IT, IT, NT > > > &	tempTuples,
		MPI_Comm	World,
		IT &	datasize
	)

Definition at line 51 of file SpParMat3D.cpp.

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

Extract() [1/2]

template<class IT , class NT >

FullyDistVec< IT, NT > combblas::Extract	(	const FullyDistVec< IT, NT > &	dense,
		const FullyDistVec< IT, IT > &	ri
	)

Definition at line 253 of file FastSV.h.

Extract() [2/2]

template<class IT , class NT >

FullyDistSpVec< IT, NT > combblas::Extract	(	const FullyDistVec< IT, NT >	dense,
		FullyDistSpVec< IT, IT >	ri
	)

Definition at line 420 of file CC.h.

findColSplitters()

template<typename RT , typename IT , typename NT >

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

Definition at line 85 of file MultiwayMerge.h.

findColSplittersFinger()

template<typename RT , typename IT , typename NT >

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

Definition at line 108 of file MultiwayMerge.h.

First4Clust()

template<typename IT >

void combblas::First4Clust

(

FullyDistVec< IT, IT > &

cc

)

Definition at line 1559 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 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 464 of file Friends.h.

generic_gespmv() [2/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 445 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 182 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 323 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 1577 of file CC.h.

inf_plus()

template<typename T >

const T combblas::inf_plus	(	const T &	a,
		const T &	b
	)

Definition at line 41 of file Semirings.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 > &	parent,
		FullyDistVec< IT, IT > &	cclabel
	)

Definition at line 1384 of file CC.h.

LocalHybridSpGEMM() [1/2]

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

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

Definition at line 1148 of file mtSpGEMM.h.

LocalHybridSpGEMM() [2/2]

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

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

Definition at line 214 of file mtSpGEMM.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 75 of file mtSpGEMM.h.

LocalSpGEMMHash()

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

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

Definition at line 464 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 1489 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 144 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 331 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 185 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 23 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 186 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,
		int	computationKernel,
		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 Parameters:

• computationKernel: 1 means hash-based, 2 means heap-based

Definition at line 450 of file ParFriends.h.

MemEfficientSpGEMM3D()

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

SpParMat3D< IU, NUO, UDERO > combblas::MemEfficientSpGEMM3D	(	SpParMat3D< IU, NU1, UDERA > &	A,
		SpParMat3D< IU, NU2, UDERB > &	B,
		int	phases,
		NUO	hardThreshold,
		IU	selectNum,
		IU	recoverNum,
		NUO	recoverPct,
		int	kselectVersion,
		int	computationKernel,
		int64_t	perProcessMemory
	)

Definition at line 3215 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 660 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 1557 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 1629 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.

Mpi_Alltoallv()

template<typename T >

int combblas::Mpi_Alltoallv	(	T *	sbuff,
		int *	s_cnt,
		int *	sdisp,
		T *	rbuff,
		int *	r_cnt,
		int *	rdisp,
		MPI_Comm	comm
	)

Definition at line 311 of file CC.h.

Mpi_Alltoallv_kway()

template<typename T >

int combblas::Mpi_Alltoallv_kway	(	T *	sbuff_,
		int *	s_cnt_,
		int *	sdisp_,
		T *	rbuff_,
		int *	r_cnt_,
		int *	rdisp_,
		MPI_Comm	c,
		int	kway = 2
	)

Definition at line 133 of file CC.h.

MPIType()

template<typename T >

MPI_Datatype combblas::MPIType

(

void

)

Definition at line 106 of file MPIType.h.

MPIType< bool >() [1/4]

template<>

MPI_Datatype combblas::MPIType< bool >

(

void

)

Definition at line 84 of file MPIType.cpp.

MPIType< bool >() [2/4]

template<>

MPI_Datatype combblas::MPIType< bool >

(

void

)

Definition at line 84 of file MPIType.cpp.

MPIType< bool >() [3/4]

template<>

MPI_Datatype combblas::MPIType< bool >

(

void

)

Definition at line 84 of file MPIType.cpp.

MPIType< bool >() [4/4]

template<>

MPI_Datatype combblas::MPIType< bool >

(

void

)

Definition at line 84 of file MPIType.cpp.

MPIType< double >() [1/4]

template<>

MPI_Datatype combblas::MPIType< double >

(

void

)

Definition at line 76 of file MPIType.cpp.

MPIType< double >() [2/4]

template<>

MPI_Datatype combblas::MPIType< double >

(

void

)

Definition at line 76 of file MPIType.cpp.

MPIType< double >() [3/4]

template<>

MPI_Datatype combblas::MPIType< double >

(

void

)

Definition at line 76 of file MPIType.cpp.

MPIType< double >() [4/4]

template<>

MPI_Datatype combblas::MPIType< double >

(

void

)

Definition at line 76 of file MPIType.cpp.

MPIType< float >() [1/4]

template<>

MPI_Datatype combblas::MPIType< float >

(

void

)

Definition at line 72 of file MPIType.cpp.

MPIType< float >() [2/4]

template<>

MPI_Datatype combblas::MPIType< float >

(

void

)

Definition at line 72 of file MPIType.cpp.

MPIType< float >() [3/4]

template<>

MPI_Datatype combblas::MPIType< float >

(

void

)

Definition at line 72 of file MPIType.cpp.

MPIType< float >() [4/4]

template<>

MPI_Datatype combblas::MPIType< float >

(

void

)

Definition at line 72 of file MPIType.cpp.

MPIType< int32_t >() [1/4]

template<>

MPI_Datatype combblas::MPIType< int32_t >

(

void

)

Definition at line 56 of file MPIType.cpp.

MPIType< int32_t >() [2/4]

template<>

MPI_Datatype combblas::MPIType< int32_t >

(

void

)

Definition at line 56 of file MPIType.cpp.

MPIType< int32_t >() [3/4]

template<>

MPI_Datatype combblas::MPIType< int32_t >

(

void

)

Definition at line 56 of file MPIType.cpp.

MPIType< int32_t >() [4/4]

template<>

MPI_Datatype combblas::MPIType< int32_t >

(

void

)

Definition at line 56 of file MPIType.cpp.

MPIType< int64_t >() [1/4]

template<>

MPI_Datatype combblas::MPIType< int64_t >

(

void

)

Definition at line 64 of file MPIType.cpp.

MPIType< int64_t >() [2/4]

template<>

MPI_Datatype combblas::MPIType< int64_t >

(

void

)

Definition at line 64 of file MPIType.cpp.

MPIType< int64_t >() [3/4]

template<>

MPI_Datatype combblas::MPIType< int64_t >

(

void

)

Definition at line 64 of file MPIType.cpp.

MPIType< int64_t >() [4/4]

template<>

MPI_Datatype combblas::MPIType< int64_t >

(

void

)

Definition at line 64 of file MPIType.cpp.

MPIType< long double >() [1/4]

template<>

MPI_Datatype combblas::MPIType< long double >

(

void

)

Definition at line 80 of file MPIType.cpp.

MPIType< long double >() [2/4]

template<>

MPI_Datatype combblas::MPIType< long double >

(

void

)

Definition at line 80 of file MPIType.cpp.

MPIType< long double >() [3/4]

template<>

MPI_Datatype combblas::MPIType< long double >

(

void

)

Definition at line 80 of file MPIType.cpp.

MPIType< long double >() [4/4]

template<>

MPI_Datatype combblas::MPIType< long double >

(

void

)

Definition at line 80 of file MPIType.cpp.

MPIType< signed char >() [1/4]

template<>

MPI_Datatype combblas::MPIType< signed char >

(

void

)

Definition at line 40 of file MPIType.cpp.

MPIType< signed char >() [2/4]

template<>

MPI_Datatype combblas::MPIType< signed char >

(

void

)

Definition at line 40 of file MPIType.cpp.

MPIType< signed char >() [3/4]

template<>

MPI_Datatype combblas::MPIType< signed char >

(

void

)

Definition at line 40 of file MPIType.cpp.

MPIType< signed char >() [4/4]

template<>

MPI_Datatype combblas::MPIType< signed char >

(

void

)

Definition at line 40 of file MPIType.cpp.

MPIType< signed short int >() [1/4]

template<>

MPI_Datatype combblas::MPIType< signed short int >

(

void

)

Definition at line 48 of file MPIType.cpp.

MPIType< signed short int >() [2/4]

template<>

MPI_Datatype combblas::MPIType< signed short int >

(

void

)

Definition at line 48 of file MPIType.cpp.

MPIType< signed short int >() [3/4]

template<>

MPI_Datatype combblas::MPIType< signed short int >

(

void

)

Definition at line 48 of file MPIType.cpp.

MPIType< signed short int >() [4/4]

template<>

MPI_Datatype combblas::MPIType< signed short int >

(

void

)

Definition at line 48 of file MPIType.cpp.

MPIType< uint32_t >() [1/4]

template<>

MPI_Datatype combblas::MPIType< uint32_t >

(

void

)

Definition at line 60 of file MPIType.cpp.

MPIType< uint32_t >() [2/4]

template<>

MPI_Datatype combblas::MPIType< uint32_t >

(

void

)

Definition at line 60 of file MPIType.cpp.

MPIType< uint32_t >() [3/4]

template<>

MPI_Datatype combblas::MPIType< uint32_t >

(

void

)

Definition at line 60 of file MPIType.cpp.

MPIType< uint32_t >() [4/4]

template<>

MPI_Datatype combblas::MPIType< uint32_t >

(

void

)

Definition at line 60 of file MPIType.cpp.

MPIType< uint64_t >() [1/4]

template<>

MPI_Datatype combblas::MPIType< uint64_t >

(

void

)

Definition at line 68 of file MPIType.cpp.

MPIType< uint64_t >() [2/4]

template<>

MPI_Datatype combblas::MPIType< uint64_t >

(

void

)

Definition at line 68 of file MPIType.cpp.

MPIType< uint64_t >() [3/4]

template<>

MPI_Datatype combblas::MPIType< uint64_t >

(

void

)

Definition at line 68 of file MPIType.cpp.

MPIType< uint64_t >() [4/4]

template<>

MPI_Datatype combblas::MPIType< uint64_t >

(

void

)

Definition at line 68 of file MPIType.cpp.

MPIType< unsigned char >() [1/4]

template<>

MPI_Datatype combblas::MPIType< unsigned char >

(

void

)

Definition at line 44 of file MPIType.cpp.

MPIType< unsigned char >() [2/4]

template<>

MPI_Datatype combblas::MPIType< unsigned char >

(

void

)

Definition at line 44 of file MPIType.cpp.

MPIType< unsigned char >() [3/4]

template<>

MPI_Datatype combblas::MPIType< unsigned char >

(

void

)

Definition at line 44 of file MPIType.cpp.

MPIType< unsigned char >() [4/4]

template<>

MPI_Datatype combblas::MPIType< unsigned char >

(

void

)

Definition at line 44 of file MPIType.cpp.

MPIType< unsigned short int >() [1/4]

template<>

MPI_Datatype combblas::MPIType< unsigned short int >

(

void

)

Definition at line 52 of file MPIType.cpp.

MPIType< unsigned short int >() [2/4]

template<>

MPI_Datatype combblas::MPIType< unsigned short int >

(

void

)

Definition at line 52 of file MPIType.cpp.

MPIType< unsigned short int >() [3/4]

template<>

MPI_Datatype combblas::MPIType< unsigned short int >

(

void

)

Definition at line 52 of file MPIType.cpp.

MPIType< unsigned short int >() [4/4]

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 58 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 799 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 448 of file ParFriendsExt.h.

Mult_AnXBn_Overlap()

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

SpParMat< IU, NUO, UDERO > combblas::Mult_AnXBn_Overlap	(	SpParMat< IU, NU1, UDERA > &	A,
		SpParMat< IU, NU2, UDERB > &	B,
		bool	clearA = false,
		bool	clearB = false
	)

Definition at line 1111 of file ParFriends.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 291 of file ParFriendsExt.h.

Mult_AnXBn_SUMMA3D()

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

SpParMat3D< IU, NUO, UDERO > combblas::Mult_AnXBn_SUMMA3D	(	SpParMat3D< IU, NU1, UDER1 > &	A,
		SpParMat3D< IU, NU2, UDER2 > &	B
	)

Definition at line 2919 of file ParFriends.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 1005 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 134 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 412 of file MultiwayMerge.h.

MultiwayMergeHash()

template<class SR , class IT , class NT >

SpTuples< IT, NT > * combblas::MultiwayMergeHash	(	std::vector< SpTuples< IT, NT > * > &	ArrSpTups,
		IT	mdim = 0,
		IT	ndim = 0,
		bool	delarrs = false,
		bool	sorted = true
	)

Definition at line 537 of file MultiwayMerge.h.

MultiwayMergeHashSliding()

template<class SR , class IT , class NT >

SpTuples< IT, NT > * combblas::MultiwayMergeHashSliding	(	std::vector< SpTuples< IT, NT > * > &	ArrSpTups,
		IT	mdim = 0,
		IT	ndim = 0,
		bool	delarrs = false,
		bool	sorted = true,
		IT	maxHashTableSize = 16384
	)

Definition at line 693 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 1347 of file CC.h.

omp_par_scan()

template<class T , class I >

void combblas::omp_par_scan	(	T *	A,
		T *	B,
		I	cnt
	)

Definition at line 89 of file CC.h.

operator*()

template<typename BT >

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

inline

Just defer the multiplication

Just defer the multiplication

Just defer the multiplication

Just defer the multiplication

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 5053 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 141 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 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.

PermEdges() [2/2]

template<typename IU >

void combblas::PermEdges

(

DistEdgeList< IU > &

DEL

)

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 26 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 413 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 558 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 757 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.

prefixSum()

template<typename T >

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

Definition at line 25 of file MultiwayMerge.h.

PrintCC()

template<typename IT >

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

Definition at line 1548 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 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 462 of file SpParMat.h.

PSpGEMM() [2/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 455 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.

ReduceAssign() [1/3]

template<class IT , class NT >

int combblas::ReduceAssign	(	FullyDistSpVec< IT, IT > &	ind,
		FullyDistSpVec< IT, NT > &	val,
		vector< vector< NT > > &	reduceBuffer,
		NT	MAX_FOR_REDUCE
	)

Definition at line 580 of file CC.h.

ReduceAssign() [2/3]

template<class IT , class NT >

int combblas::ReduceAssign	(	FullyDistSpVec< IT, IT > &	ind,
		NT	val,
		vector< vector< NT > > &	reduceBuffer,
		NT	MAX_FOR_REDUCE
	)

Definition at line 662 of file CC.h.

ReduceAssign() [3/3]

template<class IT , class NT >

int combblas::ReduceAssign	(	FullyDistVec< IT, IT > &	ind,
		FullyDistVec< IT, NT > &	val,
		std::vector< std::vector< NT > > &	reduceBuffer,
		NT	MAX_FOR_REDUCE
	)

Definition at line 68 of file FastSV.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.

replicate() [1/2]

template<class IT , class NT >

int combblas::replicate	(	const FullyDistVec< IT, NT > &	dense,
		const FullyDistVec< IT, IT > &	ri,
		std::vector< std::vector< NT > > &	bcastBuffer
	)

Definition at line 203 of file FastSV.h.

replicate() [2/2]

template<class IT , class NT >

int combblas::replicate	(	const FullyDistVec< IT, NT >	dense,
		FullyDistSpVec< IT, IT >	ri,
		vector< vector< NT > > &	bcastBuffer
	)

Definition at line 347 of file CC.h.

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 226 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 185 of file MultiwayMerge.h.

SerialMergeHash()

template<class SR , class IT , class NT >

void combblas::SerialMergeHash	(	const std::vector< SpTuples< IT, NT > * > &	ArrSpTups,
		std::tuple< IT, IT, NT > *	ntuples,
		IT *	colnnz,
		IT	maxcolnnz,
		IT	startCol,
		IT	endCol,
		bool	sorted
	)

Definition at line 321 of file MultiwayMerge.h.

SerialMergeNNZ()

template<class IT , class NT >

IT combblas::SerialMergeNNZ

(

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

ArrSpTups

)

Definition at line 131 of file MultiwayMerge.h.

SerialMergeNNZHash()

template<class IT , class NT >

IT * combblas::SerialMergeNNZHash	(	const std::vector< SpTuples< IT, NT > * > &	ArrSpTups,
		IT &	totnnz,
		IT &	maxnnzPerCol,
		IT	startCol,
		IT	endCol
	)

Definition at line 238 of file MultiwayMerge.h.

SetDifference() [1/2]

template<typename IU , typename NU1 , typename NU2 >

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

operation is A = A .* not(B)

Definition at line 748 of file Friends.h.

SetDifference() [2/2]

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

SpParMat< IU, NU1, UDERA > combblas::SetDifference	(	const SpParMat< IU, NU1, UDERA > &	A,
		const SpParMat< IU, NU2, UDERB > &	B
	)

Definition at line 2157 of file ParFriends.h.

Shortcut() [1/2]

template<typename IT >

void combblas::Shortcut

(

FullyDistVec< IT, IT > &

parent

)

Definition at line 1322 of file CC.h.

Shortcut() [2/2]

template<typename IT >

void combblas::Shortcut	(	FullyDistVec< IT, IT > &	parents,
		FullyDistVec< IT, short >	stars
	)

Definition at line 1332 of file CC.h.

sort_less()

template<typename IT , typename NT >

bool combblas::sort_less	(	const std::pair< IT, NT > &	left,
		const std::pair< IT, NT > &	right
	)

Definition at line 207 of file mtSpGEMM.h.

SpecialExchangeData()

template<class IT , class NT , class DER >

void combblas::SpecialExchangeData	(	std::vector< DER > &	sendChunks,
		MPI_Comm	World,
		IT &	datasize,
		NT	dummy,
		vector< DER > &	recvChunks
	)

Definition at line 97 of file SpParMat3D.cpp.

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
	)

Definition at line 1374 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,
		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 1912 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
	)

Definition at line 1892 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,
		OptBuf< int32_t, OVT > &	optbuf
	)

Definition at line 1900 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,
		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 1725 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,
		PreAllocatedSPA< OVT > &	SPA
	)

Definition at line 1885 of file ParFriends.h.

SpMV() [8/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
	)

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

Definition at line 2005 of file ParFriends.h.

SpMV() [9/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 1925 of file ParFriends.h.

SpMXSpV() [1/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() [2/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() [3/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() [4/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_Bucket() [1/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_Bucket() [2/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_ForThreading() [1/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() [2/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_ForThreading() [3/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() [4/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_HeapSort() [1/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.

SpMXSpV_HeapSort() [2/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
	)

StarCheck()

template<typename IT >

void combblas::StarCheck	(	FullyDistVec< IT, IT > &	parents,
		FullyDistVec< IT, short > &	stars
	)

Definition at line 1126 of file CC.h.

StarCheckAfterHooking()

template<typename IT , typename NT , typename DER >

void combblas::StarCheckAfterHooking	(	const SpParMat< IT, NT, DER > &	A,
		FullyDistVec< IT, IT > &	parent,
		FullyDistVec< IT, short > &	star,
		FullyDistSpVec< IT, IT >	condhooks,
		bool	isStar2StarHookPossible
	)

Definition at line 1035 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.

SV()

template<typename IT , typename NT , typename DER >

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

Definition at line 336 of file FastSV.h.

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  )

inline

Definition at line 392 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 273 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 1122 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 1388 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 608 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 565 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 645 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 632 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

be very careful here

be very careful here

Definition at line 792 of file ApproxWeightPerfectMatching.h.

UnconditionalHook2()

template<typename IT , typename NT , typename DER >

FullyDistSpVec< IT, IT > combblas::UnconditionalHook2	(	const SpParMat< IT, NT, DER > &	A,
		FullyDistVec< IT, IT > &	parents,
		FullyDistVec< IT, short >	stars
	)

Definition at line 1243 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 356 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 102 of file MPIType.h.

mpioc

MPIOpCache combblas::mpioc

Definition at line 59 of file MPIOp.h.