Parallel Execution in Abaqus/Explicit

Abaqus/Explicit can be executed in thread mode within one node of a compute cluster and takes advantage of the shared memory available to the threads that are running on different cores.

abaqus job=beam cpus=20 mp_mode=threads

Job module: job editor: Parallelization: toggle on Use multiple processors
and specify the number of processors, n; Number of domains: m;
Multiprocessing mode: Threads

Abaqus/Explicit can be executed in MPI mode, which uses the message passing interface (MPI) to communicate between processes running on different cores that might be spread over multiple compute nodes on an HPC cluster.

abaqus job=beam cpus=20

Job module: job editor: Parallelization: toggle on Use multiple processors
and specify the number of processors, n; Number of domains: m;
Multiprocessing mode: MPI

Abaqus/Explicit can be executed in hybrid mode using a combination of MPI and threads with each MPI process launching a user-specified number of threads. Execution in hybrid mode is invoked by setting the command line option threads_per_mpi_process=m. The number of cpus must be divisible by the number of threads per MPI process.

HPC clusters typically consist of compute nodes with multiple sockets, and each socket contains numerous cores. In addition, the cores within a socket can be further organized into multiple NUMA (non-uniform memory access) nodes with dedicated resources, such as local memory, for faster access. Hybrid execution of Abaqus/Explicit takes advantage of the NUMA architecture and the trend of increasing number of cores available on each NUMA node. It is recommended that the threads per MPI process parameter be set equal to the number of cores in a NUMA node, resulting in one MPI rank per NUMA node. However, when the number of cores in a NUMA node is large, you can experiment to allow multiple MPI ranks within a NUMA node. Furthermore, the hybrid execution is recommended only for jobs engaging one or more compute nodes fully on a homogeneous cluster. When submitting to a batch queuing system, the processors per node (ppn) should be set to the total number of cores available per compute node.

The number of domains is selected by Abaqus/Explicit automatically and does not need to be specified. If specified, Abaqus/Explicit may tune the number of domains for optimal performance. The number of domains is listed in the status (job-name.sta) file.

abaqus job=beam cpus=80 threads_per_mpi_process=20 

Job module: job editor: Parallelization: toggle on Use multiple processors
and specify the number of processors, n; threads_per_mpi_process: m;
Multiprocessing mode: Hybrid

The analysis results are independent of the number of processors used for the analysis. However, the results do depend on the number of parallel domains used during the domain decomposition. Except for cases in which the single- and multiple-domain models are different because of features that are not yet available with multiple parallel domains (discussed below), these differences should be triggered only by finite precision effects. For example, the order of the nodal force assembly may depend on the number of parallel domains, which can result in differences in trailing digits in the computed force. Some physical systems are highly sensitive to small perturbations, so a tiny difference in the force applied in one increment can result in noticeable differences in results in subsequent increments. Simulations involving buckling and other bifurcations tend to be sensitive to small perturbations.

To obtain consistent analysis results from run to run, the number of domains used in the domain decomposition should be constant. Increasing the number of domains increases the computational cost slightly; therefore, unless dynamic load balancing is being applied, it is recommended that the number of domains be set equal to the maximum number of processors used for analysis execution for optimal performance. If you do not specify the number of domains, the number defaults to the number of processors.

The use of the domain-level parallelization method is not allowed with the following features:

• Extreme value output. An alternative is to filter the output.

• Steady-state detection. This feature is typically used with ALE adaptive mesh domains.

If you include these features, Abaqus issues an error message.

Certain features cannot be split across domains. The domain decomposition algorithm automatically takes this into account and forces these features to be contained entirely within one domain. If fewer domains than requested processors are created, Abaqus/Explicit issues an error message. Even if the algorithm succeeds in creating the requested number of domains, the load may be balanced unevenly. If this behavior is not acceptable, the job should be run with the loop-level parallelization method.

If you define tracer particles in the adaptive mesh domains, the adaptive mesh domains cannot span parallel domain boundaries. In this case, the nodes on the boundary between an adaptive mesh domain and a nonadaptive domain as well as the adaptive nodes on the surface of the adaptive mesh domain cannot be shared with another parallel domain. To enforce this in a consistent manner when you specify parallel domains, Abaqus/Explicit sets all nodes shared by adjacent adaptive mesh domains as nonadaptive. The analysis results may be significantly different from that of a serial run with no parallel domains. If this behavior is undesirable, set the number of parallel domains to 1, and switch to the loop-level parallelization method. See Defining ALE Adaptive Mesh Domains in Abaqus/Explicit for details.

A contact pair cannot be split across parallel domains, but separate contact pairs are not restricted to be in the same parallel domain. A contact pair that uses the kinematic contact algorithm requires that all the nodes associated with the involved surfaces be within a single parallel domain and not be shared with any other parallel domains. A contact pair that uses the penalty contact algorithm requires that the associated nodes be part of a single parallel domain, but these nodes may also be part of other parallel domains if they are not defined in an adaptive mesh domain. Analyses in which a large percentage of nodes are involved in contact might not scale well if contact pairs are used, especially with kinematic enforcement of contact constraints. General contact does not limit the domain decomposition boundaries.

Nodes involved in kinematic constraints (About Kinematic Constraints), except for surface-based shell-to-solid constraints, will be within a single parallel domain; and they will not be shared with another parallel domain. However, two kinematic constraints that do not share nodes can be placed within different parallel domains.

In some cases beam elements that share a node may be forced into the same parallel domain. This happens only for beams whose center of mass does not coincide with the location of the beam node or for beams with additional inertia (see Adding Inertia to the Beam Section Behavior for Timoshenko Beams).

You can influence the domain decomposition by specifying one or more regions that are independently decomposed into a user-specified number of parallel domains or by specifying that an element set should be constrained to the same parallel domain.

Specifying a domain decomposition region can be useful when a local region of the model is computationally intensive. Performance gains may be achieved by identifying the local region as an independent domain decomposition region, thereby distributing computation of the local regions among all processors. You can specify the domain decomposition region by defining an element set directly, or Abaqus/Explicit can generate the domain decomposition region consisting of all elements within a user-specified box. The part of the model that is not included in any user-specified domain decomposition region is considered as the global region and is also decomposed into the user-specified number of parallel domains. You can specify that each decomposition region can be decomposed using a recursive coordinate bisection (RCB) algorithm or a graph partitioning algorithm that minimizes the number of shared nodes. The RCB algorithm is the default for all domain decomposition regions. You can also specify that each domain decomposition region can be decomposed into $N*n_{domainsUser}$ domains by specifying a decompose factor N. The domains from each independent domain decomposition are distributed evenly among the available processors, but these domains can be reassigned to different processors during the analysis if dynamic load balancing is activated. The total number of parallel domains for the simulation is

where

$n_{localRegions}$

is the number of local regions identified as independent domain decomposition regions;

$n_{globalRegions}$

is equal to 1 if any elements are not included in local regions identified as independent domain decomposition regions; otherwise, $n_{globalRegions}$ is 0;

$N_i$

is the decompose factor for domain decomposition region $i$ ;

$N_g$

is the decompose factor for the global domain decomposition region; and

$n_{domainsUser}$

is the user-specified number of domains per domain decomposition region (see Domain-Level Parallelization).

Separate domain decomposition regions might be desired, for example, in bird-strike models (where contact-impact activity is highly localized and time dependent) and coupled Eulerian-Lagrangian problems with localized adaptive mesh refinement (where elements are refined adding to the computational cost). The example below (Figure 1) shows a spherical projectile impacting a flat plate with a failure model, thus allowing the projectile to perforate the plate. One of the domains contains the projectile as well as a significant portion of the impact area. Specifying a domain decomposition region consisting of the projectile as well as the computationally intensive impact area results in a more balanced parallel processing (Figure 2). In this example $n_{localRegions}=1$ and $n_{globalRegions}=1$ ; therefore, $n_{domains}=2*n_{domainsUser}$ .

Figure 1. Original domain decomposition.

Figure 2. Modified domain decomposition.

Multiple domain decomposition regions can be specified. In the case of overlap between the domain decomposition regions, by default, the first specified decomposition keeps the overlapped elements. Some modeling features cannot be split across domains, and Abaqus/Explicit automatically merges the domain decomposition regions that contain features that cannot be split.

DOMAIN DECOMPOSITION, DEFINITION=ELSET,ELSET=element_set_name

DOMAIN DECOMPOSITION, DEFINITION=BOX,ELSET=element_set_name

DOMAIN DECOMPOSITION, METHOD=RCB

DOMAIN DECOMPOSITION, METHOD=GRAPH PARTITIONING

DOMAIN DECOMPOSITION, DECOMPOSE FACTOR=N

DOMAIN DECOMPOSITION
element_set_name, SAME DOMAIN

There are certain restrictions for restart when using domain-level parallelization. To ensure that optimal parallel speedup is achieved, the number of processors used for the restart analysis must be chosen so that the number of parallel domains used during the original analysis can be distributed evenly among the processors. Because the domain decomposition is based only on the features specified in the original analysis and steps defined therein, features that affect domain decomposition are restricted from being defined in restart steps only if they would invalidate the original domain decomposition. Because the newly added features will be added to existing domains, there is a potential for load imbalance and a corresponding degradation of parallel performance.

The restart analysis requires that the separate state and selected results files created during the original analysis be converted into single files, as described in Abaqus/Standard and Abaqus/Explicit Execution. This should be done automatically at the conclusion of the original analysis. If the original analysis fails to complete successfully, you must convert the state and selected results files prior to restart. An Abaqus/Explicit analysis packaged to run with a domain-level parallelization technique cannot be restarted or continued with a loop-level parallelization technique.

The co-simulation technique (About Co-Simulation) for run-time coupling of Abaqus/Explicit to Abaqus/Standard or to third-party analysis programs can be used with Abaqus/Explicit running either in serial or parallel.

There are no restrictions on features that can be included in steps defined in a restart analysis when using loop-level parallelization. For performance reasons the number of processors used when restarting must be a factor of the number of processors used in the original analysis. The most common case would be restarting with the same number of processors as used in the original analysis. An Abaqus/Explicit analysis packaged to run with a loop-level parallelization technique cannot be restarted or continued with a domain-level parallelization technique.