MultiApp.h File Reference

Go to the source code of this file.

Classes
class	libMesh::NumericVector< T >
struct	LocalRankConfig
	Holds app partitioning information relevant to the a particular rank for a multiapp scenario. More...
class	SubAppBackups
	Helper class for holding Sub-app backups. More...
class	MultiApp
	A MultiApp represents one or more MOOSE applications that are running simultaneously. More...

Namespaces
	libMesh
	The following methods are specializations for using the libMesh::Parallel::packed_range_* routines for std::strings.
	libMesh::MeshTools

Functions
LocalRankConfig	rankConfig (processor_id_type rank, processor_id_type nprocs, dof_id_type napps, processor_id_type min_app_procs, processor_id_type max_app_procs, bool batch_mode=false)
	Returns app partitioning information relevant to the given rank for a multiapp scenario with the given number of apps (napps) and parallel/mpi procs (nprocs). More...
void	dataStore (std::ostream &stream, SubAppBackups &backups, void *context)
void	dataLoad (std::istream &stream, SubAppBackups &backups, void *context)

Function Documentation

dataLoad()

void dataLoad	(	std::istream &	stream,
		SubAppBackups &	backups,
		void *	context
	)

Definition at line 1534 of file MultiApp.C.

{
  MultiApp * multi_app = static_cast<MultiApp *>(context);
  mooseAssert(multi_app, "Not set");

  dataLoad(stream, static_cast<std::vector<std::unique_ptr<Backup>> &>(backups), nullptr);

  multi_app->restore();
}

dataStore()

void dataStore	(	std::ostream &	stream,
		SubAppBackups &	backups,
		void *	context
	)

Definition at line 1523 of file MultiApp.C.

{
  MultiApp * multi_app = static_cast<MultiApp *>(context);
  mooseAssert(multi_app, "Not set");

  multi_app->backup();

  dataStore(stream, static_cast<std::vector<std::unique_ptr<Backup>> &>(backups), nullptr);
}

rankConfig()

LocalRankConfig rankConfig	(	processor_id_type	rank,
		processor_id_type	nprocs,
		dof_id_type	napps,
		processor_id_type	min_app_procs,
		processor_id_type	max_app_procs,
		bool	batch_mode = false
	)

Returns app partitioning information relevant to the given rank for a multiapp scenario with the given number of apps (napps) and parallel/mpi procs (nprocs).

min_app_procs and max_app_procs define the min and max number of procs that must/can be used in parallel to run a given (sub)app. batch_mode affects whether 1 subapp is assigned per rank to be re-used to run each of the (napps) simulations or whether 1 subapp is created for each napps simulation (globally).

Each proc calls this function in order to determine which (sub)apps among the global list of all subapps for a multiapp should be run by the given rank.

Definition at line 1330 of file MultiApp.C.

Referenced by Sampler::constructRankConfig(), and MultiApp::init().

{
  if (min_app_procs > nprocs)
    mooseError("minimum number of procs per app is higher than the available number of procs");
  else if (min_app_procs > max_app_procs)
    mooseError("minimum number of procs per app must be lower than the max procs per app");

  mooseAssert(rank < nprocs, "rank must be smaller than the number of procs");

  // A "slot" is a group of procs/ranks that are grouped together to run a
  // single (sub)app/sim in parallel.

  const processor_id_type slot_size =
      std::max(std::min(cast_int<processor_id_type>(nprocs / napps), max_app_procs), min_app_procs);
  const processor_id_type nslots = std::min(
      nprocs / slot_size,
      cast_int<processor_id_type>(std::min(
          static_cast<dof_id_type>(std::numeric_limits<processor_id_type>::max()), napps)));
  mooseAssert(nprocs >= (nslots * slot_size),
              "Ensure that leftover procs is represented by an unsigned type");
  const processor_id_type leftover_procs = nprocs - nslots * slot_size;
  const dof_id_type apps_per_slot = napps / nslots;
  const dof_id_type leftover_apps = napps % nslots;

  std::vector<int> slot_for_rank(nprocs);
  processor_id_type slot = 0;
  processor_id_type procs_in_slot = 0;
  for (processor_id_type rankiter = 0; rankiter <= rank; rankiter++)
  {
    if (slot < nslots)
      slot_for_rank[rankiter] = cast_int<int>(slot);
    else
      slot_for_rank[rankiter] = -1;
    procs_in_slot++;
    // this slot keeps growing until we reach slot size plus possibly an extra
    // proc if there were any leftover from the slotization of nprocs - this
    // must also make sure we don't go over max app procs.
    if (procs_in_slot == slot_size + 1 * (slot < leftover_procs && slot_size < max_app_procs))
    {
      procs_in_slot = 0;
      slot++;
    }
  }

  if (slot_for_rank[rank] < 0)
    // ranks assigned a negative slot don't have any apps running on them.
    return {0, 0, 0, 0, false, 0};
  const processor_id_type slot_num = cast_int<processor_id_type>(slot_for_rank[rank]);

  const bool is_first_local_rank = rank == 0 || (slot_for_rank[rank - 1] != slot_for_rank[rank]);
  const dof_id_type n_local_apps = apps_per_slot + 1 * (slot_num < leftover_apps);

  processor_id_type my_first_rank = 0;
  for (processor_id_type rankiter = rank; rankiter > 0; rankiter--)
    if (slot_for_rank[rank] != slot_for_rank[rankiter])
    {
      my_first_rank = cast_int<processor_id_type>(slot_for_rank[rankiter + 1]);
      break;
    }

  dof_id_type app_index = 0;
  for (processor_id_type slot = 0; slot < slot_num; slot++)
  {
    const dof_id_type num_slot_apps = apps_per_slot + 1 * (slot < leftover_apps);
    app_index += num_slot_apps;
  }

  if (batch_mode)
    return {n_local_apps, app_index, 1, slot_num, is_first_local_rank, my_first_rank};
  return {n_local_apps, app_index, n_local_apps, app_index, is_first_local_rank, my_first_rank};
}