void PetscDMRegister() { if (PetscDMRegistered) return; PetscErrorCode ierr; #if PETSC_RELEASE_LESS_THAN(3,4,0) ierr = DMRegister(DMLIBMESH, PETSC_NULL, "DMCreate_libMesh", DMCreate_libMesh); CHKERRABORT(libMesh::COMM_WORLD,ierr); #else ierr = DMRegister(DMLIBMESH, DMCreate_libMesh); CHKERRABORT(libMesh::COMM_WORLD,ierr); #endif PetscDMRegistered = PETSC_TRUE; }
void PetscDMRegister() { if (PetscDMRegistered) return; PetscErrorCode ierr; ierr = DMRegister(DMLIBMESH, PETSC_NULL, "DMCreate_libMesh", DMCreate_libMesh); CHKERRABORT(libMesh::COMM_WORLD, ierr); PetscDMRegistered = PETSC_TRUE; }
/*@C DMRegisterAll - Registers all of the DM components in the DM package. Not Collective Input parameter: . path - The dynamic library path Level: advanced .keywords: DM, register, all .seealso: DMRegister(), DMRegisterDestroy() @*/ PetscErrorCode DMRegisterAll() { PetscErrorCode ierr; PetscFunctionBegin; DMRegisterAllCalled = PETSC_TRUE; ierr = DMRegister(DMDA, DMCreate_DA);CHKERRQ(ierr); ierr = DMRegister(DMCOMPOSITE, DMCreate_Composite);CHKERRQ(ierr); ierr = DMRegister(DMSLICED, DMCreate_Sliced);CHKERRQ(ierr); ierr = DMRegister(DMSHELL, DMCreate_Shell);CHKERRQ(ierr); ierr = DMRegister(DMREDUNDANT, DMCreate_Redundant);CHKERRQ(ierr); ierr = DMRegister(DMPLEX, DMCreate_Plex);CHKERRQ(ierr); ierr = DMRegister(DMPATCH, DMCreate_Patch);CHKERRQ(ierr); #if defined(PETSC_HAVE_MOAB) ierr = DMRegister(DMMOAB, DMCreate_Moab);CHKERRQ(ierr); #endif ierr = DMRegister(DMNETWORK, DMCreate_Network);CHKERRQ(ierr); PetscFunctionReturn(0); }
LibMeshInit::LibMeshInit (int argc, const char * const * argv, MPI_Comm COMM_WORLD_IN) #endif { // 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); // If there's no threading model active, force _n_threads==1 #if !LIBMESH_USING_THREADS if (libMesh::libMeshPrivateData::_n_threads != 1) { libMesh::libMeshPrivateData::_n_threads = 1; libmesh_warning("Warning: You requested --n-threads>1 but no threading model is active!\n" << "Forcing --n-threads==1 instead!"); } #endif // 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; libmesh_call_mpi(MPI_Initialized (&flag)); if (!flag) { int mpi_thread_provided; const int mpi_thread_requested = libMesh::n_threads() > 1 ? MPI_THREAD_FUNNELED : MPI_THREAD_SINGLE; libmesh_call_mpi (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())); } 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; //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")) { libmesh_call_mpi (MPI_Comm_create_errhandler(libMesh_MPI_Handler, &libmesh_errhandler)); libmesh_call_mpi (MPI_Comm_set_errhandler(libMesh::GLOBAL_COMM_WORLD, libmesh_errhandler)); libmesh_call_mpi (MPI_Comm_set_errhandler(MPI_COMM_WORLD, libmesh_errhandler)); } } // 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 (!SlepcInitializeCalled) { ierr = SlepcInitialize (&argc, const_cast<char ***>(&argv), nullptr, nullptr); CHKERRABORT(libMesh::GLOBAL_COMM_WORLD,ierr); libmesh_initialized_slepc = true; } # else if (libmesh_initialized_petsc) { ierr = PetscInitialize (&argc, const_cast<char ***>(&argv), nullptr, nullptr); 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 #if defined(LIBMESH_HAVE_MPI) && defined(LIBMESH_HAVE_VTK) // Do MPI initialization for VTK. _vtk_mpi_controller = vtkMPIController::New(); _vtk_mpi_controller->Initialize(&argc, const_cast<char ***>(&argv), /*initialized_externally=*/1); _vtk_mpi_controller->SetGlobalController(_vtk_mpi_controller); #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. // // Note: this seems overly paranoid/like it should be unnecessary, // plus we were doing it wrong for many years and not clearing the // existing GetPot object before re-parsing the command line, so all // the command line arguments appeared twice in the GetPot object... command_line.reset (new GetPot (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 performance 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; } // Process command line arguments for redirecting stdout/stderr. bool cmdline_has_redirect_stdout = libMesh::on_command_line ("--redirect-stdout"), cmdline_has_redirect_output = libMesh::on_command_line ("--redirect-output"); // The --redirect-stdout command-line option has been deprecated in // favor of "--redirect-output basename". if (cmdline_has_redirect_stdout) libmesh_warning("The --redirect-stdout command line option has been deprecated. " "Use '--redirect-output basename' instead."); // Honor the "--redirect-stdout" and "--redirect-output basename" // command-line options. When one of these is specified, each // processor sends libMesh::out/libMesh::err messages to // stdout.processor.#### (default) or basename.processor.####. if (cmdline_has_redirect_stdout || cmdline_has_redirect_output) { std::string basename = "stdout"; // Look for following argument if using new API if (cmdline_has_redirect_output) { // Set the cursor to the correct location in the list of command line arguments. command_line->search(1, "--redirect-output"); // Get the next option on the command line as a string. std::string next_string = ""; next_string = command_line->next(next_string); // If the next string starts with a dash, we assume it's // another flag and not a file basename requested by the // user. if (next_string.size() > 0 && next_string.find_first_of("-") != 0) basename = next_string; } std::ostringstream filename; filename << basename << ".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 (nullptr); // Similarly, the user can request to drop cerr on all non-0 ranks. // By default, errors are printed on all ranks, but this can lead to // interleaved/unpredictable outputs when doing parallel regression // testing, which this option is designed to support. if (libMesh::global_processor_id() != 0) if (libMesh::on_command_line ("--drop-cerr")) libMesh::err.rdbuf (nullptr); // 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()); }