libMesh::LibMeshInit Class Reference
#include <libmesh.h>
Public Member Functions | |
| LibMeshInit (int argc, const char *const *argv, MPI_Comm COMM_WORLD_IN=MPI_COMM_WORLD) | |
| LibMeshInit (int argc, const char *const *argv) | |
| virtual | ~LibMeshInit () |
| const Parallel::Communicator & | comm () const |
| Parallel::Communicator & | comm () |
Private Attributes | |
| Parallel::Communicator | _comm |
Detailed Description
The LibMeshInit class, when constructed, initializes the dependent libraries (e.g. MPI or PETSC) and does the command line parsing needed by libMesh. The LibMeshInit destructor closes those libraries properly.
For most users, a single LibMeshInit object should be created at the start of your main() function. This object replaces the previous libMesh::init()/libMesh::close() methods, which are now deprecated.
Constructor & Destructor Documentation
| libMesh::LibMeshInit::LibMeshInit | ( | int | argc, |
| const char *const * | argv, | ||
| MPI_Comm | COMM_WORLD_IN = MPI_COMM_WORLD |
||
| ) |
Initialize the library for use, with the command line options provided. This will e.g. call PetscInitialize if PETSC is available. You must create a LibMeshInit object before using any of the library functionality. This method may take an optional parameter to use a user-specified MPI communicator.
| libMesh::LibMeshInit::LibMeshInit | ( | int | argc, |
| const char *const * | argv | ||
| ) |
Definition at line 336 of file libmesh.C.
References libMesh::libMeshPrivateData::_is_initialized, libMesh::libMeshPrivateData::_n_processors, libMesh::libMeshPrivateData::_n_threads, EXTERN_C_FOR_PETSC_END::_ofstream, libMesh::libMeshPrivateData::_processor_id, libMesh::closed(), libMesh::COMM_WORLD, EXTERN_C_FOR_PETSC_END::command_line, libMesh::command_line_value(), libMesh::Parallel::Communicator_World, libMesh::PerfLog::disable_logging(), libMesh::ReferenceCounter::disable_print_counter_info(), DMCreate_libMesh(), libMesh::enableFPE(), libMesh::enableSEGV(), libMesh::err, EXTERN_C_FOR_PETSC_END::err_buf(), libMesh::GLOBAL_COMM_WORLD, libMesh::global_processor_id(), libMesh::ierr, libMesh::initialized(), libMesh::libmesh_assert(), libMesh::libmesh_errhandler, EXTERN_C_FOR_PETSC_END::libmesh_initialized_mpi, EXTERN_C_FOR_PETSC_END::libmesh_initialized_petsc, EXTERN_C_FOR_PETSC_END::libmesh_initialized_slepc, libMesh_MPI_Handler(), libMesh::libmesh_terminate_handler(), libMesh::n_threads(), libMesh::old_terminate_handler, libMesh::on_command_line(), libMesh::out, EXTERN_C_FOR_PETSC_END::out_buf(), libMesh::perflog, PetscBool, libMesh::BasicOStreamProxy< charT, traits >::rdbuf(), libMesh::remote_elem, libMesh::Singleton::setup(), and EXTERN_C_FOR_PETSC_END::task_scheduler.
{
// should _not_ be initialized already.
libmesh_assert (!libMesh::initialized());
// Build a command-line parser.
command_line.reset (new GetPot (argc, argv));
// Disable performance logging upon request
{
if (libMesh::on_command_line ("--disable-perflog"))
libMesh::perflog.disable_logging();
}
// Build a task scheduler
{
// Get the requested number of threads, defaults to 1 to avoid MPI and
// multithreading competition. If you would like to use MPI and multithreading
// at the same time then (n_mpi_processes_per_node)x(n_threads) should be the
// number of processing cores per node.
std::vector<std::string> n_threads(2);
n_threads[0] = "--n_threads";
n_threads[1] = "--n-threads";
libMesh::libMeshPrivateData::_n_threads =
libMesh::command_line_value (n_threads, 1);
// Set the number of OpenMP threads to the same as the number of threads libMesh is going to use
#ifdef LIBMESH_HAVE_OPENMP
omp_set_num_threads(libMesh::libMeshPrivateData::_n_threads);
#endif
task_scheduler.reset (new Threads::task_scheduler_init(libMesh::n_threads()));
}
// Construct singletons who may be at risk of the
// "static initialization order fiasco"
Singleton::setup();
// Make sure the construction worked
libmesh_assert(remote_elem);
#if defined(LIBMESH_HAVE_MPI)
// Allow the user to bypass MPI initialization
if (!libMesh::on_command_line ("--disable-mpi"))
{
// Check whether the calling program has already initialized
// MPI, and avoid duplicate Init/Finalize
int flag;
MPI_Initialized (&flag);
if (!flag)
{
#if MPI_VERSION > 1
int mpi_thread_provided;
const int mpi_thread_requested = libMesh::n_threads() > 1 ?
MPI_THREAD_FUNNELED :
MPI_THREAD_SINGLE;
MPI_Init_thread (&argc, const_cast<char***>(&argv),
mpi_thread_requested, &mpi_thread_provided);
if ((libMesh::n_threads() > 1) &&
(mpi_thread_provided < MPI_THREAD_FUNNELED))
{
libmesh_warning("Warning: MPI failed to guarantee MPI_THREAD_FUNNELED\n"
<< "for a threaded run.\n"
<< "Be sure your library is funneled-thread-safe..."
<< std::endl);
// Ideally, if an MPI stack tells us it's unsafe for us
// to use threads, we shouldn't use threads.
// In practice, we've encountered one MPI stack (an
// mvapich2 configuration) that returned
// MPI_THREAD_SINGLE as a proper warning, two stacks
// that handle MPI_THREAD_FUNNELED properly, and two
// current stacks plus a couple old stacks that return
// MPI_THREAD_SINGLE but support libMesh threaded runs
// anyway.
// libMesh::libMeshPrivateData::_n_threads = 1;
// task_scheduler.reset (new Threads::task_scheduler_init(libMesh::n_threads()));
}
#else
if (libMesh::libMeshPrivateData::_n_threads > 1)
{
libmesh_warning("Warning: using MPI1 for threaded code.\n" <<
"Be sure your library is funneled-thread-safe..." <<
std::endl);
}
MPI_Init (&argc, const_cast<char***>(&argv));
#endif
libmesh_initialized_mpi = true;
}
// Duplicate the input communicator for internal use
// And get a Parallel::Communicator copy too, to use
// as a default for that API
this->_comm = COMM_WORLD_IN;
libMesh::GLOBAL_COMM_WORLD = COMM_WORLD_IN;
#ifndef LIBMESH_DISABLE_COMMWORLD
libMesh::COMM_WORLD = COMM_WORLD_IN;
Parallel::Communicator_World = COMM_WORLD_IN;
#endif
//MPI_Comm_set_name not supported in at least SGI MPT's MPI implementation
//MPI_Comm_set_name (libMesh::COMM_WORLD, "libMesh::COMM_WORLD");
libMeshPrivateData::_processor_id =
cast_int<processor_id_type>(this->comm().rank());
libMeshPrivateData::_n_processors =
cast_int<processor_id_type>(this->comm().size());
// Set up an MPI error handler if requested. This helps us get
// into a debugger with a proper stack when an MPI error occurs.
if (libMesh::on_command_line ("--handle-mpi-errors"))
{
#if MPI_VERSION > 1
MPI_Comm_create_errhandler(libMesh_MPI_Handler, &libmesh_errhandler);
MPI_Comm_set_errhandler(libMesh::GLOBAL_COMM_WORLD, libmesh_errhandler);
MPI_Comm_set_errhandler(MPI_COMM_WORLD, libmesh_errhandler);
#else
MPI_Errhandler_create(libMesh_MPI_Handler, &libmesh_errhandler);
MPI_Errhandler_set(libMesh::GLOBAL_COMM_WORLD, libmesh_errhandler);
MPI_Errhandler_set(MPI_COMM_WORLD, libmesh_errhandler);
#endif // #if MPI_VERSION > 1
}
}
// Could we have gotten bad values from the above calls?
libmesh_assert_greater (libMeshPrivateData::_n_processors, 0);
// The cast_int already tested _processor_id>=0
// libmesh_assert_greater_equal (libMeshPrivateData::_processor_id, 0);
// Let's be sure we properly initialize on every processor at once:
libmesh_parallel_only(this->comm());
#endif
#if defined(LIBMESH_HAVE_PETSC)
// Allow the user to bypass PETSc initialization
if (!libMesh::on_command_line ("--disable-petsc")
#if defined(LIBMESH_HAVE_MPI)
// If the user bypassed MPI, we'd better be safe and assume that
// PETSc was built to require it; otherwise PETSc initialization
// dies.
&& !libMesh::on_command_line ("--disable-mpi")
#endif
)
{
int ierr=0;
PETSC_COMM_WORLD = libMesh::GLOBAL_COMM_WORLD;
// Check whether the calling program has already initialized
// PETSc, and avoid duplicate Initialize/Finalize
PetscBool petsc_already_initialized;
ierr = PetscInitialized(&petsc_already_initialized);
CHKERRABORT(libMesh::GLOBAL_COMM_WORLD,ierr);
if (petsc_already_initialized != PETSC_TRUE)
libmesh_initialized_petsc = true;
# if defined(LIBMESH_HAVE_SLEPC)
// If SLEPc allows us to check whether the calling program
// has already initialized it, we do that, and avoid
// duplicate Initialize/Finalize.
// We assume that SLEPc will handle PETSc appropriately,
// which it does in the versions we've checked.
# if !SLEPC_VERSION_LESS_THAN(2,3,3)
if (!SlepcInitializeCalled)
# endif
{
ierr = SlepcInitialize (&argc, const_cast<char***>(&argv), NULL, NULL);
CHKERRABORT(libMesh::GLOBAL_COMM_WORLD,ierr);
libmesh_initialized_slepc = true;
}
# else
if (libmesh_initialized_petsc)
{
ierr = PetscInitialize (&argc, const_cast<char***>(&argv), NULL, NULL);
CHKERRABORT(libMesh::GLOBAL_COMM_WORLD,ierr);
}
# endif
#if !PETSC_RELEASE_LESS_THAN(3,3,0)
// Register the reference implementation of DMlibMesh
#if PETSC_RELEASE_LESS_THAN(3,4,0)
ierr = DMRegister(DMLIBMESH, PETSC_NULL, "DMCreate_libMesh", DMCreate_libMesh); CHKERRABORT(libMesh::GLOBAL_COMM_WORLD,ierr);
#else
ierr = DMRegister(DMLIBMESH, DMCreate_libMesh); CHKERRABORT(libMesh::GLOBAL_COMM_WORLD,ierr);
#endif
#endif
}
#endif
// Re-parse the command-line arguments. Note that PETSc and MPI
// initialization above may have removed command line arguments
// that are not relevant to this application in the above calls.
// We don't want a false-positive by detecting those arguments.
command_line->parse_command_line (argc, argv);
// The following line is an optimization when simultaneous
// C and C++ style access to output streams is not required.
// The amount of benefit which occurs is probably implementation
// defined, and may be nothing. On the other hand, I have seen
// some IO tests where IO peformance improves by a factor of two.
if (!libMesh::on_command_line ("--sync-with-stdio"))
std::ios::sync_with_stdio(false);
// Honor the --separate-libmeshout command-line option.
// When this is specified, the library uses an independent ostream
// for libMesh::out/libMesh::err messages, and
// std::cout and std::cerr are untouched by any other options
if (libMesh::on_command_line ("--separate-libmeshout"))
{
// Redirect. We'll share streambufs with cout/cerr for now, but
// presumably anyone using this option will want to replace the
// bufs later.
std::ostream* newout = new std::ostream(std::cout.rdbuf());
libMesh::out = *newout;
std::ostream* newerr = new std::ostream(std::cerr.rdbuf());
libMesh::err = *newerr;
}
// Honor the --redirect-stdout command-line option.
// When this is specified each processor sends
// libMesh::out/libMesh::err messages to
// stdout.processor.####
if (libMesh::on_command_line ("--redirect-stdout"))
{
std::ostringstream filename;
filename << "stdout.processor." << libMesh::global_processor_id();
_ofstream.reset (new std::ofstream (filename.str().c_str()));
// Redirect, saving the original streambufs!
out_buf = libMesh::out.rdbuf (_ofstream->rdbuf());
err_buf = libMesh::err.rdbuf (_ofstream->rdbuf());
}
// redirect libMesh::out to nothing on all
// other processors unless explicitly told
// not to via the --keep-cout command-line argument.
if (libMesh::global_processor_id() != 0)
if (!libMesh::on_command_line ("--keep-cout"))
libMesh::out.rdbuf (NULL);
// Check command line to override printing
// of reference count information.
if(libMesh::on_command_line("--disable-refcount-printing") )
ReferenceCounter::disable_print_counter_info();
#ifdef LIBMESH_ENABLE_EXCEPTIONS
// Set our terminate handler to write stack traces in the event of a
// crash
old_terminate_handler = std::set_terminate(libmesh_terminate_handler);
#endif
if (libMesh::on_command_line("--enable-fpe"))
libMesh::enableFPE(true);
if (libMesh::on_command_line("--enable-segv"))
libMesh::enableSEGV(true);
// The library is now ready for use
libMeshPrivateData::_is_initialized = true;
// Make sure these work. Library methods
// depend on these being implemented properly,
// so this is a good time to test them!
libmesh_assert (libMesh::initialized());
libmesh_assert (!libMesh::closed());
}
| libMesh::LibMeshInit::~LibMeshInit | ( | ) | [virtual] |
Definition at line 622 of file libmesh.C.
References _comm, libMesh::libMeshPrivateData::_is_initialized, libMesh::Singleton::cleanup(), libMesh::PerfLog::clear(), libMesh::Parallel::Communicator::clear(), libMesh::closed(), comm(), libMesh::Parallel::Communicator_World, libMesh::enableFPE(), libMesh::err, EXTERN_C_FOR_PETSC_END::err_buf(), libMesh::BasicOStreamProxy< charT, traits >::get(), EXTERN_C_FOR_PETSC_END::libmesh_initialized_mpi, EXTERN_C_FOR_PETSC_END::libmesh_initialized_petsc, EXTERN_C_FOR_PETSC_END::libmesh_initialized_slepc, libMesh::ReferenceCounter::n_objects(), libMesh::old_terminate_handler, libMesh::on_command_line(), libMesh::out, EXTERN_C_FOR_PETSC_END::out_buf(), libMesh::perflog, libMesh::ReferenceCounter::print_info(), libMesh::PerfLog::print_log(), libMesh::BasicOStreamProxy< charT, traits >::rdbuf(), libMesh::BasicOStreamProxy< charT, traits >::reset(), and EXTERN_C_FOR_PETSC_END::task_scheduler.
{
// We can't delete, finalize, etc. more than once without
// reinitializing in between
libmesh_exceptionless_assert(!libMesh::closed());
// Delete reference counted singleton(s)
Singleton::cleanup();
// Clear the thread task manager we started
task_scheduler.reset();
// Let's be sure we properly close on every processor at once:
libmesh_parallel_only(this->comm());
// Force the \p ReferenceCounter to print
// its reference count information. This allows
// us to find memory leaks. By default the
// \p ReferenceCounter only prints its information
// when the last created object has been destroyed.
// That does no good if we are leaking memory!
ReferenceCounter::print_info ();
// Print an informative message if we detect a memory leak
if (ReferenceCounter::n_objects() != 0)
{
libMesh::err << "Memory leak detected!"
<< std::endl;
#if !defined(LIBMESH_ENABLE_REFERENCE_COUNTING) || defined(NDEBUG)
libMesh::err << "Compile in DEBUG mode with --enable-reference-counting"
<< std::endl
<< "for more information"
<< std::endl;
#endif
}
// print the perflog to individual processor's file.
libMesh::perflog.print_log();
// Now clear the logging object, we don't want it to print
// a second time during the PerfLog destructor.
libMesh::perflog.clear();
// Reconnect the output streams
// (don't do this, or we will get messages from objects
// that go out of scope after the following return)
//std::cout.rdbuf(std::cerr.rdbuf());
// Set the initialized() flag to false
libMeshPrivateData::_is_initialized = false;
if (libMesh::on_command_line ("--redirect-stdout"))
{
// If stdout/stderr were redirected to files, reset them now.
libMesh::out.rdbuf (out_buf);
libMesh::err.rdbuf (err_buf);
}
// If we built our own output streams, we want to clean them up.
if (libMesh::on_command_line ("--separate-libmeshout"))
{
delete libMesh::out.get();
delete libMesh::err.get();
libMesh::out.reset(std::cout);
libMesh::err.reset(std::cerr);
}
#ifdef LIBMESH_ENABLE_EXCEPTIONS
// Reset the old terminate handler; maybe the user code wants to
// keep doing C++ stuff after closing libMesh stuff.
std::set_terminate(old_terminate_handler);
#endif
if (libMesh::on_command_line("--enable-fpe"))
libMesh::enableFPE(false);
#if defined(LIBMESH_HAVE_PETSC)
// Allow the user to bypass PETSc finalization
if (!libMesh::on_command_line ("--disable-petsc")
#if defined(LIBMESH_HAVE_MPI)
&& !libMesh::on_command_line ("--disable-mpi")
#endif
)
{
# if defined(LIBMESH_HAVE_SLEPC)
if (libmesh_initialized_slepc)
SlepcFinalize();
# else
if (libmesh_initialized_petsc)
PetscFinalize();
# endif
}
#endif
#if defined(LIBMESH_HAVE_MPI)
// Allow the user to bypass MPI finalization
if (!libMesh::on_command_line ("--disable-mpi"))
{
this->_comm.clear();
#ifndef LIBMESH_DISABLE_COMMWORLD
Parallel::Communicator_World.clear();
#endif
if (libmesh_initialized_mpi)
MPI_Finalize();
}
#endif
}
Member Function Documentation
| const Parallel::Communicator& libMesh::LibMeshInit::comm | ( | ) | const [inline] |
Definition at line 76 of file libmesh.h.
References _comm.
Referenced by ~LibMeshInit().
{ return _comm; }
| Parallel::Communicator& libMesh::LibMeshInit::comm | ( | ) | [inline] |
Member Data Documentation
Definition at line 81 of file libmesh.h.
Referenced by comm(), and ~LibMeshInit().
The documentation for this class was generated from the following files:
generated by
