Computer cluster parallel processing method of reverse time migration program

Abstract

The embodiment of the invention discloses a computer cluster parallel processing method for a reverse time migration program, which comprises the following steps that: a main node carries out parallel processing according to a list file containing to-be-processed shot information in a global disk, a flag file in a first global file directory and a flag file in a second global file directory; determining a specified gun and distributing a gun data processing task corresponding to the specified gun to the computing node; the first global file directory is used for storing mark files of shots which are subjected to reverse time migration processing on each computing node, and the second global file directory is used for storing mark files of shots which are subjected to reverse time migration processing on each computing node; and the computing node responds to the received shot data processing task, calls a single-shot reverse time migration program to execute reverse time migration processing for the corresponding specified shot, and updates the flag file in the first global file directory and / or the second global file directory according to the processing state. In this way, the processing efficiency of the multi-shot reverse time migration task can be improved.

Description

Technical Field

[0001] This application relates to the field of exploration geophysics, specifically to a computer cluster parallel processing method for a reverse time migration program. Background Technology

[0002] Reverse time migration (RTM) is an important pre-stack depth migration imaging method in seismic exploration, widely used in imaging complex structures. RTM demands significant computational resources and requires a large amount of computation. In practice, it must be processed using computer clusters. A single RTM process typically involves dozens or even hundreds of computing nodes and can take anywhere from several hours to hundreds of hours. Therefore, the stability, flexibility, and efficiency of the cluster's parallel operation are of paramount importance.

[0003] Cluster parallel operation control relies on a deep understanding of computer cluster hardware and software systems, involves specialized programming skills, and optimization experience based on large-scale real-world production applications. Researchers of reverse time offset methods often lack these necessary qualifications. Therefore, there is an urgent need for a method for parallelizing reverse time offset programs in computer clusters that is widely applicable to various reverse time offset programs, various computer cluster hardware configurations, and various practical application conditions. Summary of the Invention

[0004] In view of the above problems, this application is made in order to provide a computer cluster parallel processing method, computing device, computer storage medium and computer program product for a time-off offset program that overcomes or at least partially solves the above problems.

[0005] According to one aspect of the embodiments of this application, a computer cluster parallel processing method for a reverse time offset program is provided, comprising: The master node determines the designated gun and distributes the corresponding gun data processing task to the compute node based on the list file containing gun information to be processed in the global disk, the flag file in the first global file directory, and the flag file in the second global directory. The first global file directory is used to store the flag files of guns undergoing reverse time migration processing on each computing node, and the second global file directory is used to store the flag files of guns that have completed reverse time migration processing on each computing node. In response to the received gun data processing task, the computing node calls the single-gun reverse time offset procedure to perform reverse time offset processing for the corresponding specified gun, and updates the flag file in the first global file directory and / or the second global file directory according to the processing status.

[0006] Optionally, the method further includes: After the reverse time migration processing for a specified shot is completed, the computing node performs partial superposition processing and gather extraction processing on the reverse time migration processing results, and obtains the node partial superposition result and the node gather extraction result, respectively. The master node collects the node partial superposition results and node gather extraction results from each computing node. It performs superposition processing on the collected node partial superposition results to obtain the global superposition result, and performs gather sorting processing on the collected node gather extraction results to obtain the global gather extraction result.

[0007] Optionally, the master node, based on a list file containing gun information to be processed in the global disk, a flag file in the first global file directory, and a flag file in the second global file directory, determines a specific gun and distributes the gun data processing task corresponding to the specified gun to the computing nodes, further including: After any one of the multiple computing nodes completes the reverse time offset processing, the master node determines the designated gun and distributes the gun data processing task corresponding to the designated gun to the computing node based on the list file in the global disk, the flag file in the first global file directory, and the flag file in the second global file directory.

[0008] Optionally, the method further includes: In the event of an interruption in the shot data operation, the master node deletes all flag files in the first global file directory, and each compute node deletes the temporary data generated by the incomplete reverse time offset processing.

[0009] Optionally, the cannon's identification file is named after the cannon's identifier.

[0010] Optionally, the method further includes: The compute node creates a work area directory on its local disk, and then creates a first local file directory and a second local file directory under the work area directory. The compute node stores the flag file of the specified gun that is undergoing reverse time migration processing in the first local file directory corresponding to the compute node, and moves the flag file of the specified gun that has completed reverse time migration processing from the first local file directory corresponding to the compute node to the second local file directory.

[0011] Optionally, the computation node's partial overlay processing and gather extraction processing of the reverse-time migration results further includes: The computing node determines whether the shot identifier corresponding to any of the flag files in the second local file directory exists in the flag array. If not, it performs partial superposition processing and gather extraction processing on the reverse time offset processing result of the shot corresponding to the flag file. After processing, the shot identifier corresponding to the flag file is recorded in the flag array.

[0012] According to another aspect of the embodiments of this application, a computing device is provided, including: a processor, a memory, a communication interface and a communication bus, wherein the processor, the memory and the communication interface communicate with each other through the communication bus; The memory is used to store at least one executable instruction that causes the processor to perform the operation corresponding to the computer cluster parallel processing method of the above-described time-offset program.

[0013] According to another aspect of the embodiments of this application, a computer storage medium is provided, wherein the storage medium stores at least one executable instruction, the executable instruction causing a processor to perform an operation corresponding to the computer cluster parallel processing method of the above-described time-offset program.

[0014] According to another aspect of the embodiments of this application, a computer program product is provided, including at least one executable instruction, which causes a processor to perform operations corresponding to the computer cluster parallel processing method of the above-described time-offset program.

[0015] According to the parallel processing method of the reverse-time offset program provided in the embodiments of this application, the master node determines the designated gun and distributes the corresponding gun data processing task to the computing nodes based on the list file containing gun information to be processed in the global disk, the flag file in the first global file directory, and the flag file in the second global file directory; the first global file directory is used to store the flag files of guns that are undergoing reverse-time offset processing on each computing node, and the second global file directory is used to store the flag files of guns that have completed reverse-time offset processing on each computing node; in response to the received gun data processing task, the computing node calls the single-gun reverse-time offset program to perform reverse-time offset processing for the corresponding designated gun, and updates the flag files in the first global file directory and / or the second global file directory according to the processing status. In the above method, the master node distributes the gun data processing tasks to each computing node, allowing computing nodes of different models and computing power to process the same multi-gun reverse time migration task simultaneously. This can improve the processing efficiency of multi-gun reverse time migration tasks. At the same time, it can quickly and easily transform existing reverse time migration programs into parallel processing programs for actual computer clusters. The code modification is small and the overall program size is small. It is widely applicable to different types of reverse time migration such as isotropic, anisotropic, and elastic waves, as well as different types of single-gun parallel methods such as CPU and GPU. It can quickly form reverse time migration technology for computer clusters and shorten the research and development cycle.

[0016] The above description is merely an overview of the technical solutions of the embodiments of this application. In order to better understand the technical means of the embodiments of this application and to implement them in accordance with the contents of the specification, and to make the above and other objects, features and advantages of the embodiments of this application more obvious and understandable, specific implementation methods of the embodiments of this application are described below. Attached Figure Description

[0017] Various other advantages and benefits will become apparent to those skilled in the art upon reading the following detailed description of preferred embodiments. The accompanying drawings are for illustrative purposes only and are not intended to limit the embodiments of this application. Furthermore, the same reference numerals denote the same parts throughout the drawings. In the drawings: Figure 1 A flowchart illustrating a computer cluster parallel processing method for a reverse time offset procedure according to an embodiment of this application is shown. Figure 2 A flowchart illustrating a computer cluster parallel processing method for a reverse time offset procedure according to another embodiment of this application is shown; Figure 3 A schematic diagram of a common detector gather in a practical application case is shown; Figure 4 A schematic diagram of a three-dimensional velocity field in a real-world application case is shown; Figure 5 A schematic diagram of the superposition results in a real-world application example is shown; Figure 6 A functional block diagram of a computer cluster parallel processing method for a reverse time offset procedure according to an embodiment of this application is shown; Figure 7 A schematic diagram of the structure of a computing device according to an embodiment of this application is shown. Detailed Implementation

[0018] Exemplary embodiments of the present disclosure will now be described in more detail with reference to the accompanying drawings. While exemplary embodiments of the present disclosure are shown in the drawings, it should be understood that the present disclosure may be implemented in various forms and should not be limited to the embodiments set forth herein. Rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the scope of the disclosure to those skilled in the art.

[0019] Figure 1 A flowchart illustrating a computer cluster parallel processing method for a reverse-time offset procedure according to an embodiment of this application is shown, as follows: Figure 1 As shown, the method includes the following steps: In step S110, the master node determines the designated gun and distributes the corresponding gun data processing task to the computing nodes based on the list file containing gun information to be processed in the global disk, the flag file in the first global file directory, and the flag file in the second global file directory.

[0020] The global disk refers to the storage location used to store global files. Global files include: a list file containing information about the guns to be processed, a flag file in the first global file directory, and a flag file in the second global file directory.

[0021] A gun data job refers to a series of processing operations performed on the data of all guns to be processed. The method in this application embodiment completes the gun data job through a master node and its corresponding multiple computing nodes in a computer cluster. The master node and computing nodes can be GPUs or CPUs. At the start of the gun data job, the master node identifies all guns to be processed, obtains the identification information of all guns, generates a list file containing information about the guns to be processed, and stores it on a global disk.

[0022] The first global file directory is used to store the flag files of the guns undergoing reverse time migration on each computing node, and the second global file directory is used to store the flag files of the guns that have completed reverse time migration on each computing node. Therefore, the flag files stored in the first and second global file directories are dynamically changing during the gun data operation.

[0023] By using the list file on the global disk, the flag file in the first global file directory, and the flag file in the second global file directory, it is possible to determine which guns have completed time-reverse offset processing, which guns are undergoing time-reverse offset processing, and which guns have not yet undergone time-reverse offset processing. For each compute node, a gun that has not yet undergone time-reverse offset processing is identified as a designated gun. A gun data processing task containing the gun identifier of the designated gun is generated and distributed to the compute nodes. The gun data processing task is used to notify the compute nodes to perform time-reverse offset processing on the corresponding designated gun. The gun data processing task corresponds one-to-one with the gun, and the gun data processing task is a single-gun task.

[0024] In step S120, the computing node responds to the received shot data processing task by calling the single-shot reverse time offset program to perform reverse time offset processing for the corresponding specified shot, and updates the flag file in the first global file directory and / or the second global file directory according to the processing status.

[0025] The single-gun reverse-time offset program is a reverse-time offset program that operates independently with a single gun. It is designed to operate independently with a single gun, meaning that the reverse-time offset program only performs single-gun input, reverse-time offset processing, and output processing.

[0026] After receiving the shot data processing task for a specified shot, the computing node calls the single-shot reverse time migration program to perform reverse time migration calculation on the shot data of the specified shot, that is, to perform reverse time migration processing on the specified shot. In addition, the node updates the flag file in the flag file directory according to the processing status. After the reverse time migration processing is completed, the imaging results are compressed and stored in the work area directory of the computing node.

[0027] Specifically, the processing status includes in-process time-offset processing and completed time-offset processing. Since the first global file directory is used to store the flag files of guns that are in-process time-offset processing on each computing node, after starting to execute the time-offset processing for a specified gun, the flag file corresponding to the specified gun is stored in the first global file directory. Since the second global file directory is used to store the flag files of guns that have completed time-offset processing on each computing node, after completing the time-offset processing for the specified gun, the flag file corresponding to the specified gun is transferred from the first global file directory to the second global file directory.

[0028] The computer cluster parallel processing method for the reverse-time migration program provided in this application distributes gun data processing tasks to each computing node through the master node, allowing computing nodes of different models and computing power to process the same multi-gun reverse-time migration task simultaneously, thereby improving the processing efficiency of multi-gun reverse-time migration tasks. At the same time, it can quickly and easily transform existing reverse-time migration programs into parallel processing programs for actual computer clusters. The computer cluster transformation and development work does not involve modification of the core reverse-time migration code, with small code modification and small overall program size. It is widely applicable to different types of reverse-time migration such as isotropic, anisotropic, and elastic waves, as well as different types of single-gun parallel methods such as CPU and GPU, and can quickly form reverse-time migration technology for computer clusters, shortening the development cycle.

[0029] Figure 2 A flowchart illustrating a computer cluster parallel processing method for a reverse-time offset procedure according to another embodiment of this application is shown, as follows: Figure 2 As shown, the method includes the following steps: Step S210: The master node scans the seismic record to extract the shot number of each shot and the start and end trace index of each shot in the seismic record, obtains the shot information to be processed, generates a list file containing the shot information to be processed and stores it in the global disk, and creates a first global file directory and a second global file directory in the global disk.

[0030] At the start of the shot data operation, the master node creates a work area directory on the global disk, generates a list file containing all shot information to be processed, and stores it on the global disk. A shot information to be processed includes the shot number and the start and end trace index of the shot in the seismic record. The master node extracts the shot number and the start and end trace index of each shot in the seismic record by scanning the seismic record, thereby obtaining all shot information to be processed. The master node also creates a first global file directory and a second global file directory under the work area directory on the global disk.

[0031] Specifically, a shot number management program is established, which is used to perform the following functions: create a work area directory, create a first global file directory and a second global file directory, scan seismic records to obtain shot information to be processed and write it into a text file to form a list file, store the list file in the work area directory, compile the shot number management program to obtain the shot number management program module executable file, and the master node calls the executable file to perform the above operations.

[0032] The first global file directory is used to store the flag files of guns undergoing reverse time migration on each computing node, and the second global file directory is used to store the flag files of guns that have completed reverse time migration on each computing node. Specifically, the flag files of guns are named with the gun identifier.

[0033] Step S220: After the reverse time offset processing is completed on any of the multiple computing nodes, the master node determines the designated gun and distributes the corresponding gun data processing task to the computing node based on the list file in the global disk, the flag file in the first global file directory, and the flag file in the second global file directory.

[0034] The gun data processing task is a single-gun task. The compute node calls the single-gun reverse-time migration program to perform reverse-time migration processing on the specified gun corresponding to the gun data processing task. After the compute node completes the reverse-time migration processing of the specified gun corresponding to the most recently received gun data processing task, the master node needs to distribute new gun data processing tasks. Specifically, the master node retrieves the list file and, based on the flag files in the first global file directory and the second global file directory, sequentially determines a gun that has not yet undergone reverse-time migration processing, generates the corresponding gun data processing task, and distributes it to the compute node.

[0035] In practical applications, the problems that need to be solved in the clustered parallel processing of reverse-time offset include: the computational workload of different individual guns may be inconsistent, and the computing power of different computing nodes may be inconsistent. For example, different models of CPUs have different computing power, and CPU nodes and GPU nodes have different computing power. In this case, how to ensure the balanced distribution of processing load? In the method of this application embodiment, when a computing node completes the reverse-time offset processing for the specified gun corresponding to the received gun data processing task, the master node distributes a new gun data processing task to that computing node. This enables dynamic allocation of computational complexity under conditions such as inconsistent computing speeds of computing nodes and inconsistent computational workload of individual guns. It controls each node to adaptively allocate the single-gun reverse-time offset processing task, and finally the time difference between the completion of processing by all computing nodes does not exceed the running time of a single-gun reverse-time offset processing task.

[0036] In the method of this application embodiment, computing nodes that perform parallel operations can be added or deleted as needed during the artillery data operation. For example, the master node is set to determine the computing nodes that perform parallel operations through the computing node identifier in the scheduling list, and the addition or deletion of computing nodes for parallel operations is realized by adding or deleting computing node identifiers in the scheduling list of the master node.

[0037] In step S230, the computing node responds to the received shot data processing task by calling the single-shot reverse time offset program to perform reverse time offset processing for the corresponding specified shot; if the processing status is reverse time offset processing in progress, the flag file of the specified shot is stored in the first global file directory; if the processing status is reverse time offset processing completed, the flag file of the specified shot is moved from the first global file directory to the second global file directory.

[0038] The method in this embodiment further includes the following steps: the computing node creates a work area directory on its local disk, and creates a first local file directory and a second local file directory under the work area directory; wherein, the first local file directory is used to store the flag files of the guns undergoing inverse time offset processing on the corresponding computing node, and the second local file directory is used to store the flag files of the guns that have completed inverse time offset processing on the corresponding computing node. The method further includes: the computing node stores the flag files of the specified guns undergoing inverse time offset processing in the first local file directory corresponding to the computing node, and moves the flag files of the specified guns that have completed inverse time offset processing from the first local file directory corresponding to the computing node to the second local file directory. Through the first local file directory and the second local file directory, the processing status of the gun data processing tasks assigned to the computing node is recorded, increasing the data management dimension.

[0039] Specifically, the existing reverse-time offset program is modified to run independently per shot, allowing the program to perform single-shot input, reverse-time offset, and output processing based on the shot number of a specified shot, resulting in a single-shot reverse-time offset program. A shot number status management function is added to the single-shot reverse-time offset program. This function works as follows: at program startup, it checks whether the flag file for the specified shot corresponding to the currently received shot data processing task already exists in the first local file directory (i.e., the currently processed shot number directory on the local disk) and the second local file directory (i.e., the completed shot number directory on the local disk). If it exists, the program exits; if it does not exist, it creates the flag file for the specified shot corresponding to the currently received shot data processing task in the currently processed shot number directory. Finally, after completing the reverse-time offset processing for the specified shot corresponding to the currently received shot data processing task, the flag file for the specified shot corresponding to the currently received shot data processing task is moved from the currently processed shot number directory to the completed shot number directory. Compile the single-shot counter-clockwise migration program to obtain the executable file of the single-shot counter-clockwise migration processing module, so that the computing node can perform the above operations through the executable file when calling the single-shot counter-clockwise migration program.

[0040] A multi-node parallel time-reverse migration program based on MPI or Shell is established. This program is set up on each compute node and is used to obtain the shot data processing tasks distributed by the master node on each compute node. It then calls the single-shot time-reverse migration program to perform time-reverse migration processing on the corresponding specified shot, thereby executing multi-shot processing in parallel. In other words, a mechanism is established for the master node to distribute shot data processing tasks to each compute node based on MPI or Shell. The multi-node parallel time-reverse migration program is compiled to obtain an executable file for the multi-node parallel time-reverse migration processing module, which allows compute nodes to execute the above operations through the executable file when calling the multi-node parallel time-reverse migration program.

[0041] If the reverse time offset processing for all shots to be processed is completed normally, the number of flag files in the first global file directory in the global disk and the first local file directory in the local disk are both zero. The number of flag files in the second global file directory in the global disk is the total number of shots, i.e. the total number of shots to be processed. The number of flag files in the second local file directory in the local disk is the total number of shots that have completed the reverse time offset processing on the corresponding computing node.

[0042] Step S240: After the reverse time migration processing for the specified shot is completed, the computing node performs partial superposition processing and gather extraction processing on the reverse time migration processing results to obtain the node partial superposition result and the node gather extraction result, respectively.

[0043] After completing the reverse time migration processing for a specified shot, the computing node performs partial superposition processing on the reverse time migration processing results. Partial superposition processing means superimposing the imaging results of each shot together according to their position. That is, the reverse time migration processing results are superimposed on the existing node partial superposition results to obtain new node partial superposition results. At the same time, the reverse time migration processing results are subjected to gather extraction processing. Gather extraction processing means arranging the imaging results belonging to each imaging point according to the offset distance or angle based on the position of the imaging point.

[0044] Specifically, the compute node determines whether the gun identifier corresponding to any flag file in the second local file directory exists in the flag array. If not, it performs partial superposition and gather extraction processing on the reverse time migration result of the gun corresponding to that flag file. After processing, the gun identifier corresponding to that flag file is recorded in the flag array. The flag array is used to store the gun numbers of the guns that have completed partial superposition and gather extraction processing on the compute node. For any gun number corresponding to any flag file in the second local file directory, it determines whether it exists in the flag array. If not, it means that the gun has completed the reverse time migration process but has not undergone partial superposition and gather extraction processing on the reverse time migration result. Therefore, it performs partial superposition and gather extraction processing on the reverse time migration result of that gun, and records the gun number in the flag array after processing.

[0045] Specifically, the node partial overlay program and the trace set extraction processing program are designed as daemons, that is, the node partial overlay processing and trace set extraction processing processes are started on the computing node, and the computing node processes the reverse time offset processing results through the process.

[0046] A Shell-based node partial overlay program is established to perform partial overlay processing on each computing node. Specifically, whenever a computing node completes a reverse time offset process, the reverse time offset processing result is overlaid onto the existing node partial overlay result until the computing node has completed all reverse time offset processes. Specifically, on each computing node, based on the given processing range or the entire work area processing range, a node partial overlay result is established and initialized to 0; a flag array is created to record the gun numbers that have completed partial overlay processing; an infinite loop is established in the node partial overlay program, and the following operations are performed in each step of the loop: First, the program is paused for a few seconds; then, a list of gun numbers that have completed reverse time offset processing on the computing node is obtained, and each gun number in the list is checked to see if it already exists in the flag array. If a gun number that does not exist in the flag array is found, the existing overlay program is called to overlay the reverse time offset processing result corresponding to the gun number onto the existing node partial overlay result, and the gun number is appended to the flag array; finally, if all the gun numbers of the guns that have completed reverse time offset processing already exist in the flag array, and there is no flag file in the processing gun number directory (i.e., the first local file directory), the infinite loop is exited; the node partial overlay program also implements the following function: the node partial overlay result is named after the computing node and saved to the work area directory. Compile the node partial overlay program to obtain the node partial overlay module executable file, so that when the computing node calls the node partial overlay program, it can perform the above operations through the executable file.

[0047] Step S250: The master node collects the node partial superposition results and node gather extraction results of each computing node, performs superposition processing on the collected node partial superposition results to obtain the global superposition result, and performs gather sorting processing on the collected node gather extraction results to obtain the global gather extraction result.

[0048] After the node-wise stacking and node gather extraction processes of the reverse time offset results of all shots to be processed are completed, the master node collects the node-wise stacking and gather extraction results of each computing node for further processing to obtain the final global stacking and global gather extraction results.

[0049] The master node obtains the node partial superposition results of each computing node, and further superimposes the obtained node partial superposition results to obtain the global superposition result, which is the final superposition result of the shot data operation.

[0050] A global overlay program is established to perform the following functions: It obtains the final global overlay imaging range from all node partial overlay result files in the work area directory; creates and initializes a global overlay result array; reads the node partial overlay results of each compute node and accumulates them into the global overlay result array; and outputs the global overlay result array to a file in the required format. The global overlay program is compiled to obtain an executable file for the global overlay module, which the master node uses to execute the above operations when calling the global overlay program.

[0051] The master node obtains the node gather extraction results from each computing node, aggregates the node gather extraction results together, and then performs gather sorting processing. The gather sorting processing has the same processing purpose as the gather extraction processing, thus obtaining the global gather result.

[0052] In practical applications, the processing of multi-shot overlay and gather extraction is time-consuming. In the method of this application embodiment, each computing node performs partial overlay and gather extraction of the shot immediately after completing the reverse time offset processing for the shot. This enables the computing node to complete the multi-shot reverse time offset task and the partial overlay and gather extraction task simultaneously. Then, the master node summarizes and processes the node partial overlay results and node gather extraction results of each computing node. This enables parallel and concurrent processing based on multiple computing nodes, thereby significantly reducing the time consumption of shot data processing tasks.

[0053] In step S260, if the shot data operation is interrupted, the master node deletes all flag files in the first global file directory, and each computing node deletes the temporary data generated by the incomplete reverse time offset processing.

[0054] During the processing of artillery data, the interruption of artillery data operation can be manually controlled. Machine failure can also cause the interruption of artillery data operation. For example, if at least one computing node malfunctions, the reverse time offset processing on the computing node will be interrupted, which will in turn cause the artillery data operation to be abnormally interrupted.

[0055] In the event of an interruption in the gun data processing, the master node deletes all flag files in the gun number directory (i.e., the first global file directory) under the global disk work area directory. Therefore, the guns corresponding to each flag file in the first global file directory will be re-identified by the master node as guns that have not undergone reverse time offset processing, and the corresponding gun data processing tasks will be distributed to the compute nodes. Guns that were undergoing reverse time offset processing at the time of the interruption will undergo reverse time offset processing again after the gun data processing is restarted. At the same time, each compute node checks whether there are any guns that have not completed reverse time offset processing. If so, the temporary data generated by the reverse time offset processing for that gun is deleted. After that, the gun data processing is restarted, and the master node continues to distribute gun data processing tasks to each compute node according to the list file, the flag files in the first global file directory, and the flag files in the second global file directory.

[0056] A breakpoint resume cleanup procedure based on MPI is established to clean up redundant files after a shot data job is interrupted and before it is restarted, ensuring that shots that have completed inverse time offset processing can be skipped and that processing of shots that have not yet completed inverse time offset processing can continue. Specifically, the breakpoint resume cleanup procedure adds the following functions: the master node performs the operation to delete all flag files in the shot number directory (i.e., the first global file directory) under the work area directory; and each compute node checks for shots that have not completed inverse time offset processing, and if so, deletes the temporary data generated by the incomplete inverse time offset processing. The breakpoint resume cleanup procedure is compiled to obtain an executable file of the breakpoint resume cleanup module, which allows the master node and compute nodes to perform the above-mentioned operations through the executable file when calling the breakpoint resume cleanup procedure.

[0057] In practical applications, the problem that needs to be solved in the cluster parallel processing of reverse time offset is: how to restart the job and continue processing from the breakpoint after the reverse time offset cluster processing job is interrupted by human error or abnormality. In the method of this application embodiment, when the shot data job is interrupted, the processed shot number directory (i.e., the second global file directory) in the global disk remains unchanged, all the flag files in the processed shot number directory (i.e., the first global file directory) under the work area directory are deleted, and each computing node deletes the temporary data generated by the incomplete reverse time offset processing, thereby directly skipping the shot corresponding to the processed shot number directory in the work area directory of the global disk, and starting the calculation from the shot corresponding to the shot number directory being processed in the work area directory of the global disk.

[0058] Figure 3 The diagram shows a common receiver gather in a real-world application case. The horizontal axis represents the gather information corresponding to the common receiver, the vertical axis represents time (s), and the color scale is used to indicate the amplitude value of the seismic signal. Figure 4 The diagram shows a three-dimensional velocity field in a real-world application. Inline and Crossline represent longitudinal and transverse survey lines, respectively. The other axis represents depth (m). Color scales are used to indicate attribute values. In this diagram, the attribute is velocity (m / s). Figure 5 The diagram shows the overlay results in a real-world application case. Part 5a shows the overlay result of a single computing node, and part 5b shows the global overlay result. The horizontal axis represents the crossline number (i.e., the cross-survey line number), and the vertical axis represents time (s). Different colors represent different imaging result values.

[0059] According to the computer cluster parallel processing method of the reverse time offset program provided in the embodiments of this application, a computer cluster parallelization transformation method based on the reverse time offset program is provided. By modifying the existing reverse time offset program, it can be made to perform parallel operations on the computer cluster and adapt to various computer cluster hardware configurations and various practical application conditions.

[0060] The parallel processing method for computer clusters using the reverse-time migration program provided in this application can quickly and conveniently transform existing reverse-time migration programs into parallel processing programs for actual computer clusters, and has the following technical effects: it allows the simultaneous use of CPUs and GPUs of different models and computing power to process multi-shot reverse-time migration tasks in parallel; it can ensure adaptive and balanced distribution of processing load among computing nodes without prior planning of task allocation when the computational load of a single shot is inconsistent and / or the computing power of computing nodes is inconsistent; it allows the addition or removal of computing nodes during processing; it reduces the processing time of shot data jobs by concurrently executing single-shot reverse-time migration processing and node partial superposition and gather extraction on computing nodes; and it enables breakpoint continuation by republishing the original processing job after job interruption. Therefore, it is adaptable to various computer cluster hardware configurations and various practical application conditions.

[0061] The computer cluster parallel processing method for the reverse-time migration program provided in this application embodiment enables efficient and practical development of reverse-time migration technology. The core reverse-time migration algorithm development is conducted on a single node basis, without involving code development and optimization for cluster parallel computation. The computer cluster transformation development does not involve modification of the core reverse-time migration code, resulting in minimal code modification and a small overall program size. It is widely applicable to different types of reverse-time migration, such as isotropic, anisotropic, and elastic waves, as well as different single-shot parallel processing methods such as CPU and GPU. Therefore, reverse-time migration technology for computer clusters can be quickly developed, shortening the development cycle. The method in this application embodiment is applicable to various types of reverse-time migration programs, achieving separation of reverse-time migration method development from cluster parallel computation development. Users only need to develop and optimize the reverse-time migration single-shot processing program, which can then be further modified into a program suitable for computer cluster parallel processing using the method in this application embodiment.

[0062] The computer cluster parallel processing method for the reverse time migration program provided in this application separates the development of the core reverse time migration processing program from the process of parallelizing the computer cluster. This allows reverse time migration developers to focus only on the development of core processing programs such as single-shot migration and stacking. Furthermore, without involving the core reverse time migration processing program, the reverse time migration program can be modified to achieve stable, efficient, and flexible cluster processing.

[0063] Figure 6A functional block diagram of a computer cluster parallel processing method for a reverse time offset procedure according to an embodiment of this application is shown, as follows: Figure 6 As shown, it includes the following functional modules: The artillery number management program module 61 creates a work area directory, a flag file directory, and an artillery number list file in the global disk.

[0064] The single-shot reverse-time offset processing module 62 is obtained by modifying the existing reverse-time offset program. It also has a shot number status management function and is mainly used to perform reverse-time offset processing on shot data.

[0065] The multi-node parallel reverse time offset processing module 63 is built on the single-shot reverse time offset processing module. It is mainly used to obtain the shot data processing tasks distributed by the master node on each computing node and call the single-shot reverse time offset processing module to perform reverse time offset processing on the corresponding specified shot.

[0066] The node-specific overlay module 64 runs concurrently with the single-shot reverse-time offset processing module on the computing nodes, and is used to perform partial overlay on each computing node.

[0067] The job publishing module 65 calls the gun number management module to complete the preparation work, and publishes the gun data processing task based on the list file containing the gun information to be processed, the flag file in the first global file directory, and the flag file in the second global file directory. In the background running mode, it calls the multi-node parallel reverse time offset processing module and the node part overlay module.

[0068] The breakpoint resume cleanup module 66 is used to perform preparatory work before republishing the job after the processing job is interrupted, namely, deleting all flag files in the first global file directory and deleting temporary data generated by incomplete reverse time offset processing.

[0069] The global overlay module 67 is used to further overlay the node partial overlay results to obtain the global overlay result. When all specified processing for all shots (including inverse time offset processing, partial overlay processing, and gather extraction processing) is completed, further processing is performed through the global overlay module. If not all specified processing for all shots is completed, the shot data processing task is continued to be published through the processing job publishing module, or the shot data processing task can be continued through the breakpoint continuation cleanup module and then published through the processing job publishing module.

[0070] Each of the above functional modules performs its corresponding function by being called. The description of each functional module is the same as the description in the method embodiment, and will not be repeated here.

[0071] This application provides a non-volatile computer storage medium storing at least one executable instruction or computer program that enables a processor to perform operations corresponding to the computer cluster parallel processing method of the time-offset program in any of the above method embodiments.

[0072] This application provides a computer program product, which includes at least one executable instruction or computer program that enables a processor to perform operations corresponding to the computer cluster parallel processing method of the time-offset program in any of the above method embodiments.

[0073] Figure 7 The diagram shows a structural schematic of an embodiment of the computing device of this application. The specific embodiments of this application do not limit the specific implementation of the computing device.

[0074] like Figure 7 As shown, the computing device may include: a processor 702, a communications interface 704, a memory 706, and a communications bus 708.

[0075] The processor 702, communication interface 704, and memory 706 communicate with each other via communication bus 708. Communication interface 704 is used to communicate with other network elements such as clients or other servers. Processor 702 executes program 710, specifically performing the relevant steps in the above-described embodiment of the computer cluster parallel processing method for calculating the time-off offset program of the computing device.

[0076] Specifically, program 710 may include program code that includes computer operation instructions.

[0077] The processor 702 may be a central processing unit (CPU), an application-specific integrated circuit (ASIC), or one or more integrated circuits configured to implement the embodiments of this application. The computing device includes one or more processors, which may be processors of the same type, such as one or more CPUs; or processors of different types, such as one or more CPUs and one or more ASICs.

[0078] Memory 706 is used to store program 710. Memory 706 may include high-speed RAM memory, and may also include non-volatile memory, such as at least one disk storage device.

[0079] Specifically, program 710 can be used to cause processor 702 to execute the computer cluster parallel processing method of the reverse time offset program in any of the above method embodiments. The specific implementation of each step in program 710 can be found in the corresponding descriptions of the steps and units in the above embodiments of the computer cluster parallel processing of the reverse time offset program, and will not be repeated here. Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working process of the devices and modules described above can be referred to the corresponding process descriptions in the foregoing method embodiments, and will not be repeated here.

[0080] The algorithms and displays provided herein are not inherently related to any particular computer, virtual system, or other device. Various general-purpose systems can also be used in conjunction with the teachings herein. The required structure for constructing such systems is apparent from the above description. Furthermore, the embodiments of this application are not directed to any particular programming language. It should be understood that the contents of the embodiments of this application described herein can be implemented using various programming languages, and the above description of specific languages ​​is for the purpose of disclosing the best implementation of the embodiments of this application.

[0081] Numerous specific details are set forth in the specification provided herein. However, it will be understood that embodiments of this application may be practiced without these specific details. In some instances, well-known methods, structures, and techniques have not been shown in detail so as not to obscure the understanding of this specification.

[0082] Similarly, it should be understood that, in order to simplify this disclosure and aid in understanding one or more of the various inventive aspects, in the foregoing description of exemplary embodiments of the present application, various features of the present application embodiments are sometimes grouped together into a single embodiment, figure, or description thereof. However, this approach to disclosure should not be construed as reflecting an intention that the claimed embodiments of the present application require more features than expressly recited in each claim. Rather, as reflected in the following claims, inventive aspects lie in fewer than all features of a single foregoing disclosed embodiment. Therefore, the claims following the detailed description are hereby expressly incorporated into that detailed description, wherein each claim itself is a separate embodiment of the present application.

[0083] Those skilled in the art will understand that modules in the device of the embodiments can be adaptively changed and placed in one or more devices different from that embodiment. Modules, units, or components in the embodiments can be combined into a single module, unit, or component, and further, they can be divided into multiple sub-modules, sub-units, or sub-components. Except where at least some of such features and / or processes or units are mutually exclusive, any combination can be used to combine all features disclosed in this specification (including the accompanying claims, abstract, and drawings) and all processes or units of any method or device so disclosed. Unless expressly stated otherwise, each feature disclosed in this specification (including the accompanying claims, abstract, and drawings) may be replaced by an alternative feature that serves the same, equivalent, or similar purpose.

[0084] Furthermore, those skilled in the art will understand that although some embodiments described herein include certain features but not others included in other embodiments, combinations of features from different embodiments are meant to be within the scope of the embodiments of this application and form different embodiments. For example, in the following claims, any one of the claimed embodiments can be used in any combination.

[0085] The various component embodiments of this application can be implemented in hardware, or as software modules running on one or more processors, or a combination thereof. Those skilled in the art will understand that microprocessors or digital signal processors (DSPs) can be used in practice to implement some or all of the functions of some or all of the components according to the embodiments of this application. The embodiments of this application can also be implemented as device or apparatus programs (e.g., computer programs and computer program products) for performing part or all of the methods described herein. Such programs implementing the embodiments of this application can be stored on a computer-readable medium, or can be in the form of one or more signals. Such signals can be downloaded from an Internet website, provided on a carrier signal, or provided in any other form.

[0086] It should be noted that the above embodiments are illustrative of the embodiments of this application and not limiting of the embodiments of this application, and those skilled in the art can devise alternative embodiments without departing from the scope of the appended claims. In the claims, any reference signs placed between parentheses should not be construed as limiting the claims. The word "comprising" does not exclude the presence of elements or steps not listed in the claims. The word "a" or "an" preceding an element does not exclude the presence of a plurality of such elements. Embodiments of this application can be implemented by means of hardware comprising several different elements and by means of a suitably programmed computer. In the unit claims enumerating several means, several of these means may be embodied by the same item of hardware. The use of the words first, second, and third, etc., does not indicate any order. These words can be interpreted as names.

Claims

1. A computer cluster parallel processing method for a reverse-time offset program, characterized in that, include: The master node determines the designated gun and distributes the corresponding gun data processing task to the compute node based on the list file containing gun information to be processed in the global disk, the flag file in the first global file directory, and the flag file in the second global directory. The first global file directory is used to store the flag files of guns undergoing reverse time migration processing on each computing node, and the second global file directory is used to store the flag files of guns that have completed reverse time migration processing on each computing node. In response to the received gun data processing task, the computing node calls the single-gun reverse time offset procedure to perform reverse time offset processing for the corresponding specified gun, and updates the flag file in the first global file directory and / or the second global file directory according to the processing status.

2. The computer cluster parallel processing method for the reverse time offset program according to claim 1, characterized in that, The method further includes: After the reverse time migration processing for a specified shot is completed, the computing node performs partial superposition processing and gather extraction processing on the reverse time migration processing results, and obtains the node partial superposition result and the node gather extraction result, respectively. The master node collects the node partial superposition results and node gather extraction results from each computing node. It performs superposition processing on the collected node partial superposition results to obtain the global superposition result, and performs gather sorting processing on the collected node gather extraction results to obtain the global gather extraction result.

3. The computer cluster parallel processing method for the reverse time offset program according to claim 1, characterized in that, The master node, based on the list file containing gun information to be processed in the global disk, the flag file in the first global file directory, and the flag file in the second global directory, determines the designated gun and distributes the gun data processing task corresponding to the designated gun to the computing nodes, further including: After any one of the multiple computing nodes completes the reverse time offset processing, the master node determines the designated gun and distributes the gun data processing task corresponding to the designated gun to the computing node based on the list file in the global disk, the flag file in the first global file directory, and the flag file in the second global file directory.

4. The computer cluster parallel processing method for the reverse time offset program according to claim 1, characterized in that, The method further includes: In the event of an interruption in the shot data operation, the master node deletes all flag files in the first global file directory, and each compute node deletes the temporary data generated by the incomplete reverse time offset processing.

5. The computer cluster parallel processing method for the reverse time offset program according to claim 1, characterized in that, The cannon's identification file uses the cannon's identifier as its filename.

6. The computer cluster parallel processing method for the reverse time offset program according to any one of claims 1-5, characterized in that, The method further includes: The compute node creates a work area directory on its local disk, and then creates a first local file directory and a second local file directory under the work area directory. The compute node stores the flag file of the specified gun that is undergoing reverse time migration processing in the first local file directory corresponding to the compute node, and moves the flag file of the specified gun that has completed reverse time migration processing from the first local file directory corresponding to the compute node to the second local file directory.

7. The computer cluster parallel processing method for the reverse time offset program according to claim 6, characterized in that, The computation node performs partial superposition processing and gather extraction processing on the reverse time migration results, which further includes: The computing node determines whether the shot identifier corresponding to any of the flag files in the second local file directory exists in the flag array. If not, it performs partial superposition processing and gather extraction processing on the reverse time offset processing result of the shot corresponding to the flag file. After processing, the shot identifier corresponding to the flag file is recorded in the flag array.

8. A computing device, comprising: The processor, memory, communication interface, and communication bus are provided, wherein the processor, memory, and communication interface communicate with each other via the communication bus. The memory is used to store at least one executable instruction that causes the processor to perform the operation corresponding to the computer cluster parallel processing method of the time-offset program as described in any one of claims 1-7.

9. A computer storage medium storing at least one executable instruction that causes a processor to perform an operation corresponding to the computer cluster parallel processing method of the time-offset program as described in any one of claims 1-7.

10. A computer program product comprising at least one executable instruction that causes a processor to perform an operation corresponding to the computer cluster parallel processing method of the time-offset program as described in any one of claims 1-7.

Images