//=============================================================================
int Amesos_Klu::SymbolicFactorization()
{
MyPID_ = Comm().MyPID();
NumProcs_ = Comm().NumProc();
IsSymbolicFactorizationOK_ = false;
IsNumericFactorizationOK_ = false;
CreateTimer(Comm(), 2);
ResetTimer(1);
// "overhead" time for the following method is considered here
AMESOS_CHK_ERR( CreateLocalMatrixAndExporters() ) ;
assert( NumGlobalElements_ == RowMatrixA_->NumGlobalCols() );
//
// Perform checks in SymbolicFactorization(), but none in
// NumericFactorization() or Solve()
//
if ( TrustMe_ ) {
if ( CrsMatrixA_ == 0 ) AMESOS_CHK_ERR( -15 );
if( UseDataInPlace_ != 1 ) AMESOS_CHK_ERR( -15 ) ;
if( Reindex_ ) AMESOS_CHK_ERR( -15 ) ;
if( ! Problem_->GetLHS() ) AMESOS_CHK_ERR( -15 ) ;
if( ! Problem_->GetRHS() ) AMESOS_CHK_ERR( -15 ) ;
if( ! Problem_->GetLHS()->NumVectors() ) AMESOS_CHK_ERR( -15 ) ;
if( ! Problem_->GetRHS()->NumVectors() ) AMESOS_CHK_ERR( -15 ) ;
SerialB_ = Teuchos::rcp(Problem_->GetRHS(),false) ;
SerialX_ = Teuchos::rcp(Problem_->GetLHS(),false) ;
NumVectors_ = SerialX_->NumVectors();
if (MyPID_ == 0) {
AMESOS_CHK_ERR(SerialX_->ExtractView(&SerialXBvalues_,&SerialXlda_ ));
AMESOS_CHK_ERR(SerialB_->ExtractView(&SerialBvalues_,&SerialXlda_ ));
}
}
// "overhead" time for the following two methods is considered here
AMESOS_CHK_ERR( ExportToSerial() );
AMESOS_CHK_ERR( ConvertToKluCRS(true) );
OverheadTime_ = AddTime("Total Amesos overhead time", OverheadTime_, 1);
// All this time if KLU time
AMESOS_CHK_ERR( PerformSymbolicFactorization() );
NumSymbolicFact_++;
IsSymbolicFactorizationOK_ = true;
return 0;
}
//=============================================================================
int Amesos_Dscpack::SymbolicFactorization()
{
IsSymbolicFactorizationOK_ = false;
IsNumericFactorizationOK_ = false;
CreateTimer(Comm(), 2);
AMESOS_CHK_ERR(PerformSymbolicFactorization());
IsSymbolicFactorizationOK_ = true;
NumSymbolicFact_++;
return(0);
}
//=============================================================================
int Amesos_Umfpack::NumericFactorization()
{
IsNumericFactorizationOK_ = false;
if (IsSymbolicFactorizationOK_ == false)
{
// Call here what is needed, to avoid double shipping of the matrix
CreateTimer(Comm(), 2);
MyPID_ = Comm().MyPID();
NumProcs_ = Comm().NumProc();
AMESOS_CHK_ERR(ConvertToSerial(true));
AMESOS_CHK_ERR(ConvertToUmfpackCRS());
AMESOS_CHK_ERR(PerformSymbolicFactorization());
IsSymbolicFactorizationOK_ = true;
NumSymbolicFact_++;
AMESOS_CHK_ERR(PerformNumericFactorization());
}
else
{
// need to reshuffle and reconvert because entry values may have changed
AMESOS_CHK_ERR(ConvertToSerial(false));
AMESOS_CHK_ERR(ConvertToUmfpackCRS());
AMESOS_CHK_ERR(PerformNumericFactorization());
}
NumNumericFact_++;
IsNumericFactorizationOK_ = true;
return 0;
}
//=============================================================================
int Amesos_Umfpack::SymbolicFactorization()
{
// MS // NOTE: If you change this method, also change
// MS // NumericFactorization(), because it performs part of the actions
// MS // of this method. This is to avoid to ship the matrix twice
// MS // (once for the symbolic factorization, and once for the numeric
// MS // factorization) when it is not necessary.
IsSymbolicFactorizationOK_ = false;
IsNumericFactorizationOK_ = false;
CreateTimer(Comm(), 2);
// MS // Initialize two timers:
// MS // timer 1: this will track all time spent in Amesos most
// MS // important functions, *including* UMFPACK functions
// MS // timer 2: this will track all time spent in this function
// MS // that is not due to UMFPACK calls, and therefore it
// MS // tracks down how much Amesos costs. The timer starts
// MS // and ends in *each* method, unless the method does not
// MS // perform any real operation. If a method calls another
// MS // method, the timer will be stopped before the called
// MS // method, then restared.
// MS // All the time of this timer goes into "overhead"
MyPID_ = Comm().MyPID();
NumProcs_ = Comm().NumProc();
AMESOS_CHK_ERR(ConvertToSerial(true));
AMESOS_CHK_ERR(ConvertToUmfpackCRS());
AMESOS_CHK_ERR(PerformSymbolicFactorization());
IsSymbolicFactorizationOK_ = true;
NumSymbolicFact_++;
return 0;
}
//=============================================================================
int Amesos_Paraklete::SymbolicFactorization()
{
MyPID_ = Comm().MyPID();
NumProcs_ = Comm().NumProc();
IsSymbolicFactorizationOK_ = false;
IsNumericFactorizationOK_ = false;
#ifdef HAVE_AMESOS_EPETRAEXT
transposer_ = static_cast<Teuchos::ENull>( 0 );
#endif
CreateTimer(Comm(), 2);
ResetTimer(1);
// "overhead" time for the following method is considered here
AMESOS_CHK_ERR( CreateLocalMatrixAndExporters() ) ;
assert( NumGlobalElements_ == RowMatrixA_->NumGlobalCols() );
SetMaxProcesses(MaxProcesses_, *RowMatrixA_);
//
// Perform checks in SymbolicFactorization(), but none in
// NumericFactorization() or Solve()
//
assert( ! TrustMe_ ) ;
if ( TrustMe_ ) {
if ( CrsMatrixA_ == 0 ) AMESOS_CHK_ERR(10 );
if( UseDataInPlace_ != 1 ) AMESOS_CHK_ERR( 10 ) ;
if( Reindex_ ) AMESOS_CHK_ERR( 10 ) ;
if( ! Problem_->GetLHS() ) AMESOS_CHK_ERR( 10 ) ;
if( ! Problem_->GetRHS() ) AMESOS_CHK_ERR( 10 ) ;
if( ! Problem_->GetLHS()->NumVectors() ) AMESOS_CHK_ERR( 10 ) ;
if( ! Problem_->GetRHS()->NumVectors() ) AMESOS_CHK_ERR( 10 ) ;
SerialB_ = Problem_->GetRHS() ;
SerialX_ = Problem_->GetLHS() ;
NumVectors_ = SerialX_->NumVectors();
if (MyPID_ == 0) {
AMESOS_CHK_ERR(SerialX_->ExtractView(&SerialXBvalues_,&SerialXlda_ ));
AMESOS_CHK_ERR(SerialB_->ExtractView(&SerialBvalues_,&SerialXlda_ ));
}
}
PrivateParakleteData_->common_ = rcp(new paraklete_common());
const Epetra_MpiComm* MpiComm = dynamic_cast<const Epetra_MpiComm*>(&Comm());
assert (MpiComm != 0);
MPI_Comm PK_Comm;
//
// Create an MPI group with MaxProcesses_ processes
//
if ( MaxProcesses_ != Comm().NumProc()) {
if(ParakleteComm_) {
MPI_Comm_free(&ParakleteComm_);
ParakleteComm_ = 0 ;
}
std::vector<int> ProcsInGroup(MaxProcesses_);
IamInGroup_ = false;
for (int i = 0 ; i < MaxProcesses_ ; ++i) {
ProcsInGroup[i] = i;
if ( Comm().MyPID() == i ) IamInGroup_ = true;
}
MPI_Group OrigGroup, ParakleteGroup;
MPI_Comm_group(MpiComm->GetMpiComm(), &OrigGroup);
MPI_Group_incl(OrigGroup, MaxProcesses_, &ProcsInGroup[0], &ParakleteGroup);
MPI_Comm_create(MpiComm->GetMpiComm(), ParakleteGroup, &ParakleteComm_);
PK_Comm = ParakleteComm_ ;
} else {
IamInGroup_ = true;
PK_Comm = MpiComm->GetMpiComm() ;
}
paraklete_common& pk_common = *PrivateParakleteData_->common_ ;
cholmod_common *cm = &(pk_common.cm) ;
amesos_cholmod_l_start (cm) ;
PK_DEBUG_INIT ("pk", cm) ;
pk_common.nproc = MaxProcesses_ ;
pk_common.myid = Comm().MyPID() ;
//pk_common.mpicomm = PK_Comm ;
cm->print = 1 ;
cm->precise = TRUE ;
cm->error_handler = my_handler ;
pk_common.tol_diag = 0.001 ;
pk_common.tol_offdiag = 0.1 ;
pk_common.growth = 2. ;
// "overhead" time for the following two methods is considered here
AMESOS_CHK_ERR( ExportToSerial() );
AMESOS_CHK_ERR( ConvertToParakleteCRS(true) );
OverheadTime_ = AddTime("Total Amesos overhead time", OverheadTime_, 1);
// All this time if PARAKLETE time
AMESOS_CHK_ERR( PerformSymbolicFactorization() );
NumSymbolicFact_++;
IsSymbolicFactorizationOK_ = true;
return 0;
}
