A parallel off-grid dynamics Monte Carlo simulation method based on hybrid architecture

Abstract

The present invention discloses a non-lattice dynamics Monte Carlo parallel simulation method based on a hybrid architecture, comprising the following steps: S1: dividing the calculation tasks; S2: initializing the main process; S3: initializing the working process; S4: searching for reaction events: the working process executes the event search algorithm from the initial state, searches for reaction events, and sends the searched reaction events to the main process; S5: receiving reaction events; S6: selecting reaction events: randomly selecting reaction events, and broadcasting the number of the working process corresponding to the selected event, and the working process is responsible for the synchronization of the simulation data of the next time step, completing the simulation of a time step, repeating the above process until the predetermined time step is reached, and sending the simulation end signal; S7: updating the simulation system. The present invention occupies less memory, the main process does not save atomic information, and only maintains the event table; the communication efficiency is high, the reaction event adopts asynchronous communication, and the reaction communication overlaps with the event search.

Description

Technical Field

[0001] The present invention relates to the technical fields of nuclear material radiation damage simulation and parallel computing, and in particular to a non-lattice dynamics Monte Carlo parallel simulation method based on a hybrid architecture. Background Art

[0002] The device materials in the nuclear reactor are exposed to high-energy particle radiation for a long time, which changes their internal structure, affects the material performance, and thus affects the service life of the nuclear power plant. To this end, it is necessary to study the evolution behavior of materials in high temperature, high pressure, and high radiation environments. However, experiments on nuclear material radiation damage are difficult and have long cycles. Therefore, computational simulation and experiments are usually combined for research. Among them, in the computational simulation of the microstructure of materials, the commonly used simulation method is a multi-scale method consisting of a series of methods at different time and space scales.

[0003] The Kinetic Monte Carlo (KMC) method is a widely used stochastic method for micro-scale material evolution. The KMC method constructs an approximate model based on the transition state theory. The model regards the evolution process as a transition process between a series of configurations, which can accurately depict the evolution trajectory of the atomic system. It is a powerful tool for studying the material evolution process. Due to the limitation of computing power, the multi-scale computational simulation of materials is still far from the engineering requirements in terms of time and space scale. The atom kinetic Monte Carlo (AKMC) method is a simulation method that takes atoms as calculation objects and does not need to represent specific defect types. The AKMC method can be divided into two methods: lattice-based kinetic Monte Carlo (on-lattice KMC) and off-lattice kinetic Monte Carlo (off-lattice KMC) according to whether the lattice mapping method is used for modeling. The former fixes the atoms in the simulation process on the lattice points to achieve the purpose of simplifying the modeling; the latter allows atoms to move freely without being fixed on the lattice points, so it supports the simulation of more complex defects and has a wider adaptability.

[0004] The kinetic Monte Carlo method needs to know all possible reaction events under the current configuration in order to correctly complete the calculation of the transition rate. For on-lattice KMC, since the atoms are fixed on the lattice points and the atomic positions are relatively fixed, transition events obtained from experimental data are usually used as a substitute. However, off-lattice KMC simulation has greater flexibility. The atoms in the system can move freely, which makes the system complex and cannot be directly estimated using experimental results. All possible transition events must be found dynamically in the system. A complete transition event must include not only the initial and final states, but also the position and energy of the saddle point. However, the search for saddle points is a complex calculation process. A single saddle point search often requires multiple calculations of the system's global forces. However, there is currently no fast and effective search method, which also makes it difficult for off-lattice KMC to simulate large-scale systems.

[0005] Supercomputers are usually hybrid heterogeneous architectures, which can provide powerful parallel computing capabilities and huge data throughput, and excel in handling large-scale numerical computing problems. The use of heterogeneous processors can accelerate the saddle point search process, which makes it possible to implement off-lattice KMC simulations. Therefore, it is of universal significance to propose a parallel simulation method for off-lattice dynamics Monte Carlo method for hybrid architecture computers.

[0006] Therefore, it is necessary to provide a non-grid dynamics Monte Carlo parallel simulation method for hybrid architecture supercomputers, which will help solve the problem that Monte Carlo simulation has large computational complexity and is difficult to perform large-scale simulations. Summary of the invention

[0007] The present invention discloses a non-grid dynamics Monte Carlo parallel simulation method based on a hybrid architecture, which can effectively improve the scale and computational efficiency of non-grid dynamics Monte Carlo simulation.

[0008] In order to achieve the above object, the present invention adopts the following technical solutions:

[0009] A non-grid dynamics Monte Carlo parallel simulation method based on a hybrid architecture includes the following specific steps:

[0010] S1: Divide computing tasks: Divide all processes into a main process responsible for selecting reaction events and several working processes responsible for searching reaction events;

[0011] S2: Initialize the main process: The main process initializes the system atomic information and sends the atomic information to each working process;

[0012] S3: Initialize the working process: The working process synchronizes the system atomic information from the main process and initializes the initial state of the response event;

[0013] S4: Searching for reaction events: The working process executes the event search algorithm from the initial state, searches for reaction events, and sends the searched reaction events to the main process;

[0014] S5: Receive reaction events: Receive reaction events sent by the working process and store them in the reaction event table. Repeat the above process until the number of events required to be accepted by a single batch is reached, and send a signal to end the calculation of this batch.

[0015] S6: Selecting a reaction event: Randomly selecting a reaction event, and broadcasting the number of the work process corresponding to the selected event, and the work process is responsible for synchronizing the simulation data of the next time step, thereby completing the simulation of a time step, repeating the above process until the predetermined time step is reached, and sending a simulation end signal;

[0016] S7: Update simulation system: When receiving the calculation end signal of this batch, the work process corresponding to the selected event synchronizes the system atomic information after the event execution to other work processes until receiving the simulation end signal, then the process ends.

[0017] In a preferred scheme, in S1, a unique MPI process number PID is determined for each MPI process, where PID is an integer, and the PID number ranges from 0 to N-1. The MPI process is the current process, and N is the total number of MPI processes. The processes in the communication domain are divided into a main process and several working processes. If the current process PID is 0, the process is marked as the main process and jumps to step S2, otherwise the process is marked as a working process and jumps to step S3.

[0018] In a preferred embodiment, the step S2 specifically includes the following steps:

[0019] (1) Create a simulation system and an array to store the atomic information of the simulation system. Each bit of the array stores one atomic information.

[0020] (2) Create a dynamic array to store the reaction events calculated by the worker process;

[0021] (3) Send system atomic information to other working processes.

[0022] In a preferred solution, S3 specifically includes the following steps:

[0023] (1) Create communication data structure;

[0024] (2) Synchronize atomic coordinate information with the main process and create an array to store the information;

[0025] (3) Initialize the final state array to save the final state and initialize it to 0;

[0026] (4) Construct an array to store asynchronous request sending handles to save asynchronous request handles.

[0027] In a preferred embodiment, the step S4 specifically includes the following steps:

[0028] (1) Copy the array as the initial value for this reaction event search;

[0029] (2) Calculate the saddle point state and the final state. This process requires frequent global calculation of the system force, which is the hotspot of the entire event search process. However, for the hybrid architecture, the calculation of the force can be handed over to an accelerator device with strong computing power, thereby greatly shortening the calculation time.

[0030] (3) Calculate the initial state system energy and saddle point energy;

[0031] (4) Constructing a transition event;

[0032] (5) Build a communication data structure, communicate with the main process with PID 0, send it to the main process, and store the request handle in a dynamic array;

[0033] (6) Store the final state into a dynamic array;

[0034] (7) Check the data receiving queue. If the stop signal sent by the main process is not received, continue steps (1) to (6). Otherwise, block and wait until all requests are sent, and jump to step S7.

[0035] In a preferred embodiment, the step S6 specifically includes the following steps:

[0036] (1) Set the number of events received in the current batch to 0;

[0037] (2) Receive the response events sent by the working process and update the number of events received in the current batch;

[0038] (3) Count the number of feasible events, the number of erroneous events, and the number of repeated events among all the reaction events received in this round;

[0039] (4) Calculate the confidence level, which reflects the confidence level of the event set and is used to measure whether most events have been discovered;

[0040] (5) Send a termination signal to other processes, causing the working process to stop searching for reaction events and synchronously receive all remaining events;

[0041] (6) Randomly select a reaction event, construct a communication data structure, and broadcast the selected reaction event.

[0042] As can be seen from the above, the hybrid architecture-based non-grid dynamics Monte Carlo parallel simulation method provided by the present invention separates the two tasks of reaction event search and reaction event selection. The reaction event search process with large computational complexity is divided into work process groups for execution in a task parallel manner. A work process group is composed of multiple MPI processes, so that each MPI process is responsible for multiple event search tasks. In addition, the selection of reaction events is solely responsible for one MPI process. It is suitable for hybrid heterogeneous architecture supercomputers, and thus has the following advantages:

[0043] (1) It takes up little memory. The main process does not save atomic information and only maintains the event table.

[0044] (2) High communication efficiency. Asynchronous communication is used to respond to events, and response communication overlaps with event search. BRIEF DESCRIPTION OF THE DRAWINGS

[0045] Figure 1 This is a task division diagram for a non-grid dynamics Monte Carlo parallel simulation method based on a hybrid architecture proposed in the present invention.

[0046] Figure 2 This is a flow chart of a non-grid dynamics Monte Carlo parallel simulation method based on a hybrid architecture proposed by the present invention.

[0047] Figure 3 This is a pseudo code diagram of a non-grid dynamics Monte Carlo parallel simulation method based on a hybrid architecture proposed in the present invention. DETAILED DESCRIPTION

[0048] The technical solutions in the embodiments of the present invention will be described clearly and completely below in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, rather than all the embodiments.

[0049] Reference Figure 1-3 , a non-grid dynamics Monte Carlo parallel simulation method based on a hybrid architecture, including the following specific steps:

[0050] S1: Divide computing tasks: Divide all processes into a main process responsible for selecting reaction events and several working processes responsible for searching reaction events;

[0051] S2: Initialize the main process: The main process initializes the system atomic information and sends the atomic information to each working process;

[0052] S3: Initialize the working process: The working process synchronizes the system atomic information from the main process and initializes the initial state of the response event;

[0053] S4: Searching for reaction events: The working process executes the event search algorithm from the initial state, searches for reaction events, and sends the searched reaction events to the main process;

[0054] S5: Receive reaction events: Receive reaction events sent by the working process and store them in the reaction event table. Repeat the above process until the number of events required to be accepted by a single batch is reached, and send a signal to end the calculation of this batch.

[0055] S6: Selecting a reaction event: Randomly selecting a reaction event, and broadcasting the number of the work process corresponding to the selected event, and the work process is responsible for synchronizing the simulation data of the next time step, thereby completing the simulation of a time step, repeating the above process until the predetermined time step is reached, and sending a simulation end signal;

[0056] S7: Update simulation system: When receiving the calculation end signal of this batch, the work process corresponding to the selected event synchronizes the system atomic information after the event execution to other work processes until receiving the simulation end signal, then the process ends.

[0057] In a preferred embodiment, in S1, a unique MPI process number PID is determined for each MPI process, where PID is an integer, and the PID number ranges from 0 to N-1.

[0058] In a preferred embodiment, in S1, the processes in the communication domain are divided into a main process and several working processes. If the current process PID is 0, the process is marked as the main process and jumps to step S2, otherwise the process is marked as a working process and jumps to step S3.

[0059] In a preferred embodiment, S2 specifically includes the following steps:

[0060] (1) Create a simulation system and an array to store the atomic information of the simulation system. Each bit of the array stores one atomic information.

[0061] (2) Create a dynamic array to store the reaction events calculated by the worker process;

[0062] (3) Send system atomic information to other working processes.

[0063] In a preferred embodiment, S3 specifically includes the following steps:

[0064] (1) Create communication data structure;

[0065] (2) Synchronize atomic coordinate information with the main process and create an array to store the information;

[0066] (3) Initialize the final state array to save the final state and initialize it to 0;

[0067] (4) Construct an array to store asynchronous request sending handles to save asynchronous request handles.

[0068] In a preferred embodiment, S4 specifically includes the following steps:

[0069] (1) Copy the array as the initial value for this reaction event search;

[0070] (2) Calculate the saddle point state and the final state. This process requires frequent global calculation of the system force, which is the hotspot of the entire event search process. However, for the hybrid architecture, the calculation of the force can be handed over to an accelerator device with strong computing power, thereby greatly shortening the calculation time.

[0071] (3) Calculate the initial state system energy and saddle point energy;

[0072] (4) Constructing a transition event;

[0073] (5) Build a communication data structure, communicate with the main process with PID 0, send it to the main process, and store the request handle in a dynamic array;

[0074] (6) Store the final state into a dynamic array;

[0075] (7) Check the data receiving queue. If the stop signal sent by the main process is not received, continue steps (1) to (6). Otherwise, block and wait until all requests are sent, and jump to step S7.

[0076] In a preferred embodiment, S6 specifically includes the following steps:

[0077] (1) Set the number of events received in the current batch to 0;

[0078] (2) Receive the response events sent by the working process and update the number of events received in the current batch;

[0079] (3) Count the number of feasible events, the number of erroneous events, and the number of repeated events among all the reaction events received in this round;

[0080] (4) Calculate the confidence level, which reflects the confidence level of the event set and is used to measure whether most events have been discovered;

[0081] (5) Send a termination signal to other processes, causing the working process to stop searching for reaction events and synchronously receive all remaining events;

[0082] (6) Randomly select a reaction event, construct a communication data structure, and broadcast the selected reaction event.

[0083] As attached Figure 1The central processing unit (CPU) - graphics processing unit (GPU) hybrid heterogeneous architecture shown in the figure is a computationally intensive task. Since the event search task needs to complete the calculation of the system's global force multiple times, it consumes a lot of computing resources and can be handed over to heterogeneous acceleration devices that provide powerful computing power to complete the accelerated calculation, such as GPU accelerators. The event selection task process does not require large-scale calculations, but it needs to frequently receive reaction events of completed calculations. Most of the time is spent waiting for IO operations to complete. It is an IO-intensive task and can be handed over to a central processing unit with weak computing power and a high-speed Internet network to complete. Figure 1 The figure shows the CPU and GPU interconnection architecture commonly used in hybrid architecture supercomputers. One CPU is composed of multiple Dies. Die numbered 0 contains the main process responsible for event selection and work process management. Other Dies contain work processes responsible for event search tasks. Heterogeneous accelerators are used to accelerate calculations, making full use of the computing power of hybrid heterogeneous supercomputers.

[0084] Attached Figure 3 The pseudo code for the main process and the worker process to perform tasks is shown in the figure. The main process is mainly responsible for the management of the worker process and the selection of response events, and the worker process is mainly responsible for the search of response events.

[0085] Working principle: The present invention is further described below by taking the total number of atoms in the simulation area as ATOM_NUMS, the dimension of the simulation as D, the total number of MPI processes as N, and BATCH_SIZE events searched in each round as an example, where ATOM_NUMS is a positive integer, N is a positive integer greater than or equal to 2, and D is an integer and 1≤D≤3;

[0086] Each atom is stored in the form of structure Atom, and the Atom structure includes atom_id, atom_type, and atom_location[D], where atom_id stores the number of each atom, atom_type stores the type of each atom, and atom_location is an array of length D, which stores the location of each atom;

[0087] Each reaction event is stored in the form of a structure Event. The Event structure includes rank_id, seq_id, energy, and event_type. The rank_id stores the sender MPI process number, the seq_id stores the number in the system array after the reaction, the energy stores the transition energy of the reaction event, and the event_type stores the reaction event type.

[0088] Divide the computing tasks:

[0089] (1) Determine a unique MPI process number PID for each MPI process. PID is an integer, where the PID number ranges from 0 to N-1;

[0090] (2) As attached Figure 2 As shown in the example, the processes in the communication domain are divided into a main process and several working processes. If the current process PID is 0, the process is marked as the main process and jumps to the "Initialize Main Process" step; otherwise, the process is marked as a working process and jumps to the "Initialize Working Process" step.

[0091] Initialize the main process:

[0092] (1) Create a simulation system and create an array atoms_array[ATOM_NUMS] to store the atomic information of the simulation system. The array size is ATOM_NUMS, and each bit of the array stores an atomic information in the form of an Atom structure.

[0093] (2) Create a dynamic array event_vector, which is used to store the reaction events calculated by the working process. The array can dynamically store several reaction events stored in the form of Event structures;

[0094] (3) Send system atomic information to other working processes.

[0095] Initialize the worker process:

[0096] (1) Create the communication data structure comm_atoms;

[0097] (2) Synchronize atomic coordinate information with the main process and create an array atoms_array to store comm_atoms information;

[0098] (3) Initialize the final state array end_state_vector to save the final state, and initialize cur_seq_id to 0;

[0099] (4) Construct the request_handle_vector array to store the asynchronous request sending handles to save the asynchronous request handles.

[0100] Search reaction events:

[0101] (1) Copy the array atoms_array as the initial value atoms_array_start for this reaction event search;

[0102] (2) Use atoms_array_start as the initial state to calculate the saddle point state atoms_array_saddle and the final state atoms_array_end. This process requires frequent global calculation of system forces, which is the hotspot of the entire event search process. However, for the hybrid architecture, the calculation of forces can be handed over to an accelerator device with strong computing power, thereby greatly shortening the calculation time.

[0103] (3) Calculate the initial state system energy energy_start and the saddle point energy energy_end;

[0104] (4) Construct the transition event event, where event.rank_id = PID, event.seq_id = cur_seq_id, event.energy = energy_end – energy_start.

[0105] (5) Build the communication data structure comm_event, communicate with the main process with PID 0, send comm_event to the main process, and store the request handle into the request_handle_vector dynamic array;

[0106] (6) Store the final state atoms_array_end into the end_state_vector dynamic array and update cur_seq_id, that is, cur_seq_id = cur_seq_id + 1;

[0107] (7) Check the data receiving queue. If the stop signal sent by the main process is not received, continue the above operation. Otherwise, block and wait until all requests are sent, and jump to the "Update Simulation System" step.

[0108] Select the reaction event:

[0109] (1) Set the number of events received in the current batch to cur_batch_num, that is, cur_batch_num = 0;

[0110] (2) Accept the response event sent by the working process, update the number of events received in the current batch, so that cur_batch_num = cur_batch_num + 1, and repeat the above process until cur_batch_num is greater than BATCH_SIZE;

[0111] (3) Count the number of feasible events good_event_num, the number of wrong events bad_event_num, and the number of repeated events same_event_num among all the reaction events received in this round;

[0112] (4) Calculate the confidence same_event_rate = same_event_num / (same_event_num +good_event_num). If same_event_rate is greater than CONFIDENCE_THREOLD, continue. Otherwise, perform the calculation for the next batch and jump to the "Select reaction events" step.

[0113] (5) Send a termination signal to other processes, causing the working process to stop searching for reaction events and synchronously receive all remaining events;

[0114] (6) Randomly select a reaction event, set the selected reaction event as select_event, construct the communication data structure commSelect, and broadcast the selected reaction event.

[0115] Updated simulation system:

[0116] (1) Receive the commSelect sent by the main process, obtain the rank_id and seq_id of the event, if the rank_id is the current process, and build the communication data structure commAtoms, synchronously send end_state_vector[seq_id] to other processes other than the main process, and jump to the "search reaction event" step;

[0117] (2) Synchronously receive the commAtoms data structure sent by the process numbered rank_id, extract the atomic information to atoms_array, and use it as the initial state for the next round;

[0118] (3) Clear the request_handle_vector and end_state_vector arrays, reset cur_seq_id to 0, and jump to the "Search for response events" step.

[0119] The above description is only a preferred specific implementation manner of the present invention, but the protection scope of the present invention is not limited thereto. Any technician familiar with the technical field can make equivalent replacements or changes according to the technical scheme and inventive concept of the present invention within the technical scope disclosed by the present invention, which should be covered by the protection scope of the present invention.

Claims

1. A non-grid dynamics Monte Carlo parallel simulation method based on a hybrid architecture, characterized in that: The specific steps include: S1: Divide computing tasks: Divide all processes into a main process responsible for selecting reaction events and several working processes responsible for searching reaction events; S2: Initialize the main process: The main process initializes the system atomic information and sends the atomic information to each working process; S3: Initialize the working process: The working process synchronizes the system atomic information from the main process and initializes the initial state of the response event; S4: Searching for reaction events: The working process executes the event search algorithm from the initial state, searches for reaction events, and sends the searched reaction events to the main process; S5: Receive reaction events: Receive reaction events sent by the working process and store them in the reaction event table. Repeat the above process until the number of events required to be accepted by a single batch is reached, and send a signal to end the calculation of this batch. S6: Selecting a reaction event: Randomly selecting a reaction event, and broadcasting the number of the work process corresponding to the selected event, and the work process is responsible for synchronizing the simulation data of the next time step, thereby completing the simulation of a time step, repeating the above process until the predetermined time step is reached, and sending a simulation end signal; S7: Update simulation system: When receiving the calculation end signal of this batch, the work process corresponding to the selected event synchronizes the system atomic information after the event execution to other work processes until receiving the simulation end signal, then the process ends.

2. According to the hybrid architecture-based non-grid dynamics Monte Carlo parallel simulation method of claim 1, it is characterized in that: In S1, a unique MPI process number PID is determined for each MPI process, where PID is an integer, wherein the PID number ranges from 0 to N-1, the MPI process is the current process, and N is the total number of MPI processes.

3. The non-grid dynamics Monte Carlo parallel simulation method based on a hybrid architecture according to claim 2, characterized in that: In S1, the processes in the communication domain are divided into a main process and several working processes. If the current process PID is 0, the process is marked as the main process and jumps to step S2, otherwise the process is marked as a working process and jumps to step S3.

4. The non-grid dynamics Monte Carlo parallel simulation method based on a hybrid architecture according to claim 1, characterized in that: The S2 specifically includes the following steps: (1) Create a simulation system and an array to store the atomic information of the simulation system. Each bit of the array stores one atomic information. (2) Create a dynamic array to store the reaction events calculated by the worker process; (3) Send system atomic information to other working processes.

5. The hybrid architecture-based non-grid dynamics Monte Carlo parallel simulation method according to claim 1, characterized in that: The S3 specifically includes the following steps: (1) Create communication data structure; (2) Synchronize atomic coordinate information with the main process and create an array to store the information; (3) Initialize the final state array to save the final state and initialize it to 0; (4) Construct an array to store asynchronous request sending handles to save asynchronous request handles.

6. The hybrid architecture-based non-grid dynamics Monte Carlo parallel simulation method according to claim 2, characterized in that: The S4 specifically includes the following steps: (1) Copy the array as the initial value for this reaction event search; (2) Calculate the saddle point state and final state; (3) Calculate the initial state system energy and saddle point energy; (4) Constructing a transition event; (5) Build a communication data structure, communicate with the main process with PID 0, send it to the main process, and store the request handle in a dynamic array; (6) Store the final state into a dynamic array; (7) Check the data receiving queue. If the stop signal sent by the main process is not received, continue steps (1) to (6). Otherwise, block and wait until all requests are sent, and jump to step S7.

7. The non-grid dynamics Monte Carlo parallel simulation method based on a hybrid architecture according to claim 1, characterized in that: The S6 specifically includes the following steps: (1) Set the number of events received in the current batch to 0; (2) Receive the response events sent by the working process and update the number of events received in the current batch; (3) Count the number of feasible events, the number of erroneous events, and the number of repeated events among all the reaction events received in this round; (4) Calculate the confidence level, which reflects the confidence level of the event set and is used to measure whether most events have been discovered; (5) Send a termination signal to other processes, causing the working process to stop searching for reaction events and synchronously receive all remaining events; (6) Randomly select a reaction event, construct a communication data structure, and broadcast the selected reaction event.

Images