libMesh::LibMeshInit Class Reference

The LibMeshInit class, when constructed, initializes the dependent libraries (e.g. More...

#include <libmesh.h>

Public Member Functions
	LibMeshInit (int argc, const char *const *argv, MPI_Comm COMM_WORLD_IN=MPI_COMM_WORLD, int n_threads=-1)
	Initialize the library for use, with the command line options provided. More...
	LibMeshInit (int argc, const char *const *argv, int COMM_WORLD_IN=0, int n_threads=-1)
virtual	~LibMeshInit ()
	Destructor. More...
const Parallel::Communicator &	comm () const
	Returns a Communicator created from the TIMPIInit object we hold, which will be a compatibility shim if MPI is not enabled. More...
Parallel::Communicator &	comm ()

Private Attributes
TIMPI::TIMPIInit *	_timpi_init
Parallel::Communicator *	_comm
vtkMPIController *	_vtk_mpi_controller

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.

All libMesh functionality should be used only when a LibMeshInit object exists. Dependent library functionality, likewise, except in codes which manually initialize those libraries before LibMeshInit creation and finalize them after LibMeshInit destruction.

Since "it is best not to perform much more than a return rc after calling MPI_Finalize", applications which want to do anything after LibMeshInit destruction should manage MPI initialization and finalization manually.

Definition at line 90 of file libmesh.h.

Constructor & Destructor Documentation

LibMeshInit() [1/2]

libMesh::LibMeshInit::LibMeshInit	(	int	argc,
		const char *const *	argv,
		MPI_Comm	COMM_WORLD_IN = MPI_COMM_WORLD,
		int	n_threads = -1
	)

Initialize the library for use, with the command line options provided.

This will e.g. call MPI_Init if MPI is available and enabled and has not already been initialized; similar initialization may take place for Petsc, Slepc, multithreading support, libMesh Singleton objects, the libMesh::out/err IO streams, and any libMesh handlers for floating-point exceptions, signals, and/or C++ aborts.

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.

LibMeshInit() [2/2]

libMesh::LibMeshInit::LibMeshInit	(	int	argc,
		const char *const *	argv,
		int	COMM_WORLD_IN = 0,
		int	n_threads = -1
	)

~LibMeshInit()

libMesh::LibMeshInit::~LibMeshInit ( )

virtual

Destructor.

Cleans up libMesh Singleton objects, and thread manager if threading is in use. Prints reference count and performance logging information if enabled. Restores pre-LibMeshInit terminate handler and floating-point-exception handling. Finalizes any of Slepc, Petsc, and MPI which were initialized by LibMeshInit.

Definition at line 794 of file libmesh.C.

References _comm, libMesh::libMeshPrivateData::_is_initialized, _timpi_init, _vtk_mpi_controller, TIMPI::Communicator::barrier(), libMesh::Singleton::cleanup(), libMesh::PerfLog::clear(), libMesh::closed(), comm(), libMesh::command_line_names(), libMesh::enableFPE(), libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), libMesh::GLOBAL_COMM_WORLD, libMesh::ReferenceCounter::n_objects(), libMesh::Quality::name(), libMesh::old_terminate_handler, libMesh::on_command_line(), libMesh::out, libMesh::perflog, libMesh::ReferenceCounter::print_info(), libMesh::PerfLog::print_log(), libMesh::BasicOStreamProxy< charT, traits >::rdbuf(), libMesh::BasicOStreamProxy< charT, traits >::reset(), and libMesh::uninstall_thread_buffered_sync().

{
  // Every processor had better be ready to exit at the same time.
  // This would be a libmesh_parallel_only() function, except that
  // libmesh_parallel_only() uses libmesh_assert() which throws an
  // exception() which causes compilers to scream about exceptions
  // inside destructors.

  // Even if we're not doing parallel_only debugging, we don't want
  // one processor to try to exit until all others are done working.
  this->comm().barrier();

  // 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();

  // 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;

  // Before resetting the stream buffers, let's remove our thread wrappers
  if (!libMesh::on_command_line ("--disable-thread-safe-output"))
    uninstall_thread_buffered_sync();

  if (libMesh::on_command_line ("--redirect-stdout") ||
      libMesh::on_command_line ("--redirect-output"))
    {
      // 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

#ifdef LIBMESH_HAVE_NETGEN
  nglib::Ng_Exit();
#endif

  if (libMesh::on_command_line("--enable-fpe"))
    libMesh::enableFPE(false);

#if defined(LIBMESH_HAVE_PETSC)
  // Let PETSc know about all the command line objects that we
  // consumed without asking them, so we don't get unused option
  // warnings about those.
  std::vector<std::string> cli_names = command_line_names();
  for (const auto & name : cli_names)
    if (!name.empty() && name[0] == '-')
      {
        // Newer PETSc can give me a double-free I'm having trouble
        // replicating; let's protect against trying to clear
        // already-used values
        PetscBool used = PETSC_FALSE;
        auto ierr = PetscOptionsUsed(NULL, name.c_str(), &used);
        CHKERRABORT(libMesh::GLOBAL_COMM_WORLD, ierr);
        if (used == PETSC_FALSE)
          {
            ierr = PetscOptionsClearValue(NULL, name.c_str());
            CHKERRABORT(libMesh::GLOBAL_COMM_WORLD, ierr);
          }
      }

  // 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
      )
    {
      PetscErrorCode ierr = LIBMESH_PETSC_SUCCESS;
# if defined(LIBMESH_HAVE_SLEPC)
      if (libmesh_initialized_slepc)
        ierr = SlepcFinalize();
# else
      if (libmesh_initialized_petsc)
        ierr = PetscFinalize();
# endif
      CHKERRABORT(libMesh::GLOBAL_COMM_WORLD, ierr);
    }
#endif

#if defined(LIBMESH_HAVE_MPI) && defined(LIBMESH_HAVE_VTK)
  _vtk_mpi_controller->Finalize(/*finalized_externally=*/1);
  _vtk_mpi_controller->Delete();
#endif

  delete this->_comm;

#if defined(LIBMESH_HAVE_MPI)
  // Allow the user to bypass MPI finalization
  if (!libMesh::on_command_line ("--disable-mpi"))
    {
      delete this->_timpi_init;
    }
#else
  delete this->_timpi_init;
#endif
}

Member Function Documentation

comm() [1/2]

const Parallel::Communicator& libMesh::LibMeshInit::comm ( ) const

inline

Returns a Communicator created from the TIMPIInit object we hold, which will be a compatibility shim if MPI is not enabled.

Definition at line 128 of file libmesh.h.

References _comm.

Referenced by ~LibMeshInit().

{ return *_comm; }

comm() [2/2]

Parallel::Communicator& libMesh::LibMeshInit::comm ( )

inline

Definition at line 130 of file libmesh.h.

References _comm.

{ return *_comm; }

Member Data Documentation

_comm

Parallel::Communicator* libMesh::LibMeshInit::_comm

private

Definition at line 142 of file libmesh.h.

Referenced by comm(), and ~LibMeshInit().

_timpi_init

TIMPI::TIMPIInit* libMesh::LibMeshInit::_timpi_init

private

Definition at line 135 of file libmesh.h.

Referenced by ~LibMeshInit().

_vtk_mpi_controller

vtkMPIController* libMesh::LibMeshInit::_vtk_mpi_controller

private

Definition at line 148 of file libmesh.h.

Referenced by ~LibMeshInit().

---

The documentation for this class was generated from the following files:

• include/base/libmesh.h
• src/base/libmesh.C