https://mooseframework.inl.gov
Classes | Namespaces | Functions
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 1525 of file MultiApp.C.

1526 {
1527  MultiApp * multi_app = static_cast<MultiApp *>(context);
1528  mooseAssert(multi_app, "Not set");
1529 
1530  dataLoad(stream, static_cast<std::vector<std::unique_ptr<Backup>> &>(backups), nullptr);
1531 
1532  multi_app->restore();
1533 }
virtual void restore(bool force=true)
Restore the state of every Sub App.
Definition: MultiApp.C:774
void dataLoad(std::istream &stream, SubAppBackups &backups, void *context)
Definition: MultiApp.C:1525
A MultiApp represents one or more MOOSE applications that are running simultaneously.
Definition: MultiApp.h:112

◆ dataStore()

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

Definition at line 1514 of file MultiApp.C.

1515 {
1516  MultiApp * multi_app = static_cast<MultiApp *>(context);
1517  mooseAssert(multi_app, "Not set");
1518 
1519  multi_app->backup();
1520 
1521  dataStore(stream, static_cast<std::vector<std::unique_ptr<Backup>> &>(backups), nullptr);
1522 }
virtual void backup()
Save off the state of every Sub App.
Definition: MultiApp.C:759
void dataStore(std::ostream &stream, SubAppBackups &backups, void *context)
Definition: MultiApp.C:1514
A MultiApp represents one or more MOOSE applications that are running simultaneously.
Definition: MultiApp.h:112

◆ 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 1321 of file MultiApp.C.

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

1327 {
1328  if (min_app_procs > nprocs)
1329  mooseError("minimum number of procs per app is higher than the available number of procs");
1330  else if (min_app_procs > max_app_procs)
1331  mooseError("minimum number of procs per app must be lower than the max procs per app");
1332 
1333  mooseAssert(rank < nprocs, "rank must be smaller than the number of procs");
1334 
1335  // A "slot" is a group of procs/ranks that are grouped together to run a
1336  // single (sub)app/sim in parallel.
1337 
1338  const processor_id_type slot_size =
1339  std::max(std::min(cast_int<processor_id_type>(nprocs / napps), max_app_procs), min_app_procs);
1340  const processor_id_type nslots = std::min(
1341  nprocs / slot_size,
1342  cast_int<processor_id_type>(std::min(
1343  static_cast<dof_id_type>(std::numeric_limits<processor_id_type>::max()), napps)));
1344  mooseAssert(nprocs >= (nslots * slot_size),
1345  "Ensure that leftover procs is represented by an unsigned type");
1346  const processor_id_type leftover_procs = nprocs - nslots * slot_size;
1347  const dof_id_type apps_per_slot = napps / nslots;
1348  const dof_id_type leftover_apps = napps % nslots;
1349 
1350  std::vector<int> slot_for_rank(nprocs);
1351  processor_id_type slot = 0;
1352  processor_id_type procs_in_slot = 0;
1353  for (processor_id_type rankiter = 0; rankiter <= rank; rankiter++)
1354  {
1355  if (slot < nslots)
1356  slot_for_rank[rankiter] = cast_int<int>(slot);
1357  else
1358  slot_for_rank[rankiter] = -1;
1359  procs_in_slot++;
1360  // this slot keeps growing until we reach slot size plus possibly an extra
1361  // proc if there were any leftover from the slotization of nprocs - this
1362  // must also make sure we don't go over max app procs.
1363  if (procs_in_slot == slot_size + 1 * (slot < leftover_procs && slot_size < max_app_procs))
1364  {
1365  procs_in_slot = 0;
1366  slot++;
1367  }
1368  }
1369 
1370  if (slot_for_rank[rank] < 0)
1371  // ranks assigned a negative slot don't have any apps running on them.
1372  return {0, 0, 0, 0, false, 0};
1373  const processor_id_type slot_num = cast_int<processor_id_type>(slot_for_rank[rank]);
1374 
1375  const bool is_first_local_rank = rank == 0 || (slot_for_rank[rank - 1] != slot_for_rank[rank]);
1376  const dof_id_type n_local_apps = apps_per_slot + 1 * (slot_num < leftover_apps);
1377 
1378  processor_id_type my_first_rank = 0;
1379  for (processor_id_type rankiter = rank; rankiter > 0; rankiter--)
1380  if (slot_for_rank[rank] != slot_for_rank[rankiter])
1381  {
1382  my_first_rank = cast_int<processor_id_type>(slot_for_rank[rankiter + 1]);
1383  break;
1384  }
1385 
1386  dof_id_type app_index = 0;
1387  for (processor_id_type slot = 0; slot < slot_num; slot++)
1388  {
1389  const dof_id_type num_slot_apps = apps_per_slot + 1 * (slot < leftover_apps);
1390  app_index += num_slot_apps;
1391  }
1392 
1393  if (batch_mode)
1394  return {n_local_apps, app_index, 1, slot_num, is_first_local_rank, my_first_rank};
1395  return {n_local_apps, app_index, n_local_apps, app_index, is_first_local_rank, my_first_rank};
1396 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
auto max(const L &left, const R &right)
uint8_t processor_id_type
auto min(const L &left, const R &right)
uint8_t dof_id_type