Autonomous preemptive load balancing method for slave core array based on Shenwei multi-core processor

Abstract

The present invention relates to an autonomous preemptive load balancing method for a slave core array based on a Shenwei multi-core processor, and belongs to the technical field of electronic information, including: 1) for large-scale tasks, a divide-and-conquer method is used for decomposition; 2) for the obtained small-scale tasks, a dynamic and static mixed task division is performed; in the static task area, a uniform allocation method is used, and in the dynamic task area, a dynamic allocation method is used; 3) each task execution information of the dynamic task area is mapped to an identification buffer; at the same time, a double buffering strategy is adopted, and two identification buffers are configured to achieve the reset of the buffer used in the next round while executing the current round of tasks; after the slave core successfully obtains the task execution information to be executed, the task read in the dynamic task area is calculated in the LDM private space of the slave core by using DMA. The present invention has a relatively obvious acceleration effect.

Description

Technical Field

[0001] The present invention belongs to the technical field of electronic information, and in particular relates to an autonomous preemptive load balancing method for a slave core array based on a Shenwei multi-core processor. Background Art

[0002] High-performance computing has played an important role in promoting scientific and technological innovation and economic development. my country has made remarkable achievements in the field of high-performance computing, especially in the independent research and development and application of supercomputers. The new generation of Sunway supercomputer is a representative work of domestic supercomputers. For the first time, it has achieved complete localization of core components such as processors, network chipsets, storage and management systems, demonstrating my country's innovative strength in the field of supercomputers.

[0003] The Shenwei multi-core processor SW26010Pro is a new generation of high-performance heterogeneous multi-core processor independently developed by my country. The architecture of the Shenwei multi-core processor SW26010Pro is as follows: Figure 1 As shown, the Shenwei multi-core processor SW26010Pro has 6 core groups. Each core group contains a management processing unit and 64 computing processing units. The management processing unit is also called the master core, and the computing processing unit is also called the slave core. The 64 slave cores form an 8*8 slave core array. Each slave core has a high-speed local local data storage space LDM with a size of 256KB. The LDM space can be divided into two parts, private space and continuous shared space. The private space is the local private space of the slave core, and the continuous shared space is the distributed shared space between the slave core arrays. Each slave core in the array provides LDM of the same capacity for continuous addressing.

[0004] At present, there are usually two methods for parallel optimization of the new generation of Sunway supercomputers and Sunway multi-core processors. One is process-level parallel optimization, and the other is thread-level parallel optimization. Common methods of thread-level parallel optimization can be divided into two types, master-slave accelerated parallelism and master-slave cooperative parallelism. Master-slave accelerated parallelism means that the hot part of the calculation is loaded into the slave core array for calculation, and the master core is only responsible for communication operations between processes and calculations of the serial part. Master-slave cooperative parallelism means that the computing tasks are divided according to the computing power between the master and slave cores, and the master core and the slave core complete a computing task equally.

[0005] In the two commonly used thread-level parallel optimization methods, it is necessary to load tasks into each slave core or distribute tasks between the master and slave cores before the calculation begins. In this process, the execution time of each independent subtask cannot be predicted, so the general method is to evenly distribute the computing tasks to each computing core. When the execution time of each subtask varies greatly, the method of evenly distributing computing tasks will cause the overhead of different computing cores to be different. The core that completes the computing task faster needs to wait for other cores to complete the calculation, resulting in a waste of computing resources. The execution effect of the even distribution task method is as follows: Figure 2 shown.

[0006] In summary, during the single-core group optimization process, the execution time of each task to be optimized is inconsistent and the difference is large. Evenly distributing the tasks to each slave core will result in different overheads for each slave core, causing load imbalance. Summary of the invention

[0007] In order to solve the deficiencies in the prior art, the present invention designs an autonomous preemptive load balancing method for a slave core array based on the Shenwei multi-core processor for the new generation of Shenwei multi-core processors. It is different from the static allocation method of evenly distributing tasks in the commonly used thread-level parallel optimization. Each slave core will spontaneously preempt the next computing task after the current task is completed. And when the next computing task is successfully applied for, this task is marked as "executed", and other slave cores no longer execute tasks marked as "executed". When processing large-scale tasks, the idea of ​​divide and conquer is adopted to further decompose large-scale problems into several small-scale sub-tasks. Load balancing is performed in small-scale sub-tasks, thereby achieving overall load balancing and improving the execution efficiency of the program. After all computing tasks are completed, the slave core automatically exits the computing task stage, and the master core is handed over to post-process the calculation results of the slave core.

[0008] The technical solution of the present invention is:

[0009] The slave core array autonomous preemptive load balancing method based on the Shenwei multi-core processor includes:

[0010] 1) For large-scale tasks, use the divide-and-conquer method to decompose them, including: decomposing large-scale tasks into several small-scale tasks with the same properties; large-scale tasks refer to tasks with more than 10,000 computing problems, which are a collection of a large number of computing problems; small-scale tasks refer to tasks with less than 10,000 computing problems, which are subsets of large-scale tasks; for small-scale tasks, go directly to step 2);

[0011] 2) For the obtained small-scale tasks, a mixed dynamic and static task division is performed; including: firstly, the small-scale tasks are divided into a static task area and a dynamic task area;

[0012] Each slave core uses DMA to read the tasks in the static task area in blocks from the main memory to the local LDM;

[0013] In the static task area, the uniform allocation method is adopted, and in the dynamic task area, the dynamic allocation method is adopted; the uniform allocation method is to evenly allocate the tasks in the static task area to the processing units before the program starts to execute; the dynamic allocation means that during the task execution process, each processing unit autonomously seizes the computing task through optimization methods according to the actual situation;

[0014] 3) Map each task execution information of the dynamic task area to an identification buffer; the task execution information includes the execution status of the task, including two states: executed and not executed; the information in the identification buffer corresponds to each task and stores the execution information of the task; the identification buffer containing the task execution information is stored in the LDM shared space; each slave core obtains the task execution information of the next task in the identification buffer; at the same time, a double buffering strategy is adopted, and by configuring two identification buffers, the buffer used in the next round is reset while executing the current round of tasks; after the slave core successfully obtains the task execution information to be executed, the task read in the dynamic task area is calculated in the LDM private space of the slave core using DMA.

[0015] Further preferably, in step 2), the small-scale task is divided into a static task area and a dynamic task area as a whole; including:

[0016] Before the calculation begins, the small-scale task is divided into a static task area and a dynamic task area. The static task area accounts for 30% of the small-scale task, and the dynamic task area accounts for 70% of the small-scale task.

[0017] Further preferably, in step 3), a master-slave acceleration parallel acceleration method is adopted, where the master core calls the slave core array to perform accelerated calculation;

[0018] Automatic dynamic task division is achieved by automatically applying for computing tasks in the dynamic task area from the core;

[0019] After the master core calls the slave core startup function, the master core starts waiting, and the slave core array starts to execute the entire computing task until the slave core calculation is completed and then data processing is performed.

[0020] Further preferably, the slave core automatically applies for computing tasks in the dynamic task area, realizes automatic dynamic task division, and performs computing tasks; including:

[0021] When applying for a task, each slave core determines the currently used identification buffer; after determining the identification buffer to be used, it determines whether the current subtask has been preempted by other slave cores; if the current subtask has been executed, it applies for the next subtask; if the current subtask has not been executed, the slave core preempts the current subtask and marks the status of the current subtask as "executed";

[0022] After the current subtask is executed, the execution information of another identification buffer is reset to prepare for the next use. This process is repeated until all tasks in the dynamic task area are executed.

[0023] Further preferably, in step 3), a double buffering strategy is adopted to achieve resetting the buffer used in the next round while executing the current round of tasks by configuring two identification buffers; including:

[0024] The identification buffer corresponds to each task one by one, and the initial states of the two identification buffers are exactly the same, and all corresponding tasks are marked as unexecuted; when executing the current round of tasks, the task information in the identification buffer used in this round is marked as executed, and the task information in the identification buffer used in the next round is reset to unexecuted.

[0025] The beneficial effects of the present invention are:

[0026] Compared with serial programs and common multi-core optimization programs, the slave core array autonomous preemptive load balancing method based on the Shenwei multi-core processor of the present invention has a more obvious acceleration effect. BRIEF DESCRIPTION OF THE DRAWINGS

[0027] Figure 1 It is a schematic diagram of the architecture of the Shenwei multi-core processor of the present invention;

[0028] Figure 2 This is a schematic diagram of the execution effect of the method of evenly distributing tasks;

[0029] Figure 3 Schematic diagram of load balancing effect after optimization by the method of the present invention;

[0030] Figure 4 A schematic diagram of the process of decomposing large-scale tasks using the divide-and-conquer method of the present invention;

[0031] Figure 5 This is a schematic diagram of the dynamic and static mixing task division method of the present invention;

[0032] Figure 6 A schematic diagram of the storage structure of the dynamic task allocation of the present invention;

[0033] Figure 7 This is an execution flow chart of dynamically acquiring tasks from a core according to the present invention. DETAILED DESCRIPTION

[0034] The present invention will be further defined below in conjunction with the accompanying drawings and embodiments, but is not limited thereto.

[0035] Example 1

[0036] The slave core array autonomous preemptive load balancing method based on the Shenwei multi-core processor includes:

[0037] In view of the special architecture of the Shenwei multi-core processor SW26010Pro, each slave core has only 256KB of LDM. It is impossible to load all tasks into the slave core's LDM for storage at one time. In the slave core array of the single-core group, LDM provides a continuous shared space. Continuous shared space is a logically continuous and physically distributed LDM in each slave core, that is, each slave core in the array provides LDM of the same capacity for continuous addressing. However, when the scale of the problem is too large, it is impossible to store all tasks in the slave core's LDM, and this method will also cause a waste of storage space. In order to solve this problem, the present invention adopts a divide-and-conquer strategy for large-scale tasks.

[0038] LDM: Local Data Memory, each slave core has a local local data storage space, which has the characteristics of fast spatial memory access speed, but its capacity is limited. It needs to be cherished when used and usually requires explicit management.

[0039] DMA: Direct Memory Access, a slave core interface initiated by the slave core, implements the function of bulk data transfer between main memory and LDM.

[0040] 1) For large-scale tasks, use the divide-and-conquer method to decompose, including: decomposing large-scale tasks into several small-scale tasks with the same properties; large-scale tasks refer to tasks with more than 10,000 computing problems, which are a collection of a large number of computing problems; small-scale tasks refer to tasks with less than 10,000 computing problems, which are a subset of large-scale tasks; for example, large-scale tasks refer to computing tasks that simulate more than 10,000 particles, and small-scale tasks refer to computing tasks that simulate less than 10,000 particles. For small-scale tasks, go directly to step 2);

[0041] The divide-and-conquer method decomposes the process of large-scale tasks such as Figure 4 shown.

[0042] In the thread-level parallel optimization of slave cores, the commonly used task allocation methods can be divided into static allocation and dynamic allocation. Static allocation refers to the allocation of tasks to processing units in a predetermined manner before the program starts executing, and remains unchanged throughout the calculation process. The advantage of static allocation is that the task allocation process is simple and does not require additional overhead. However, this method has an inevitable disadvantage, that is, it cannot adapt to dynamic changes during task execution. If the load difference between tasks is large or the performance difference between processing units is large, some slave cores may be overloaded while other slave cores are idle. Dynamic allocation refers to the dynamic allocation of tasks to processing units according to actual conditions during task execution. The advantage of dynamic allocation is that task allocation can be dynamically adjusted according to actual conditions, improving resource utilization and system performance. It can cope with dynamic changes in task load and achieve better load balancing. The dynamic allocation process may introduce certain overhead, including communication overhead and scheduling overhead. At the same time, it is necessary to monitor and adjust task allocation in real time, which increases the complexity of management and scheduling.

[0043] Combining the advantages and disadvantages of the two task allocation methods, the present invention adopts a dynamic and static hybrid task division method. Figure 5 Schematic diagram of the dynamic and static hybrid task division method.

[0044] 2) For the obtained small-scale tasks, a mixed dynamic and static task division is performed; including: firstly, the small-scale tasks are divided into a static task area and a dynamic task area;

[0045] Each slave core uses DMA to read the tasks in the static task area in blocks from the main memory to the local LDM; specifically, each slave core calculates the starting position and number of tasks assigned to it, and reads the calculation tasks in blocks into the LDM at one time through DMA operations.

[0046] In the static task area, a uniform allocation method is adopted, and in the dynamic task area, a dynamic allocation method is adopted; the uniform allocation method is to evenly allocate the tasks in the static task area to the processing units before the program starts to execute; the dynamic allocation means that during the task execution process, each processing unit autonomously preempts the computing tasks through optimization methods according to the actual situation; specifically, each slave core obtains the execution information of the next task from the task execution information identification buffer after completing the current computing task according to the actual execution status of the slave core. If the acquired task execution status is not executed, the slave core autonomously preempts the task to start the calculation, and marks the requested task execution status as executed. If the acquired task status is executed, continue to obtain the execution status of the next computing task. Each slave core autonomously repeats this process until the execution status of all tasks is marked as executed, which means that all computing tasks have been completed. The uniform allocation method in static allocation is used to reduce the communication overhead of the slave core in obtaining tasks; at the same time, the advantage of dynamically adjusting the task allocation according to the actual situation in dynamic allocation is used to cope with the dynamic changes of task load and achieve load balancing;

[0047] The method provided by the present invention is used to achieve load balancing on each small-scale task, thereby achieving load balancing of large-scale tasks from the core as a whole. The static hybrid task division method can achieve a good load balancing effect while effectively reducing the dynamic allocation overhead.

[0048] 3) In order to reduce the LDM space occupied by each slave core, the execution information of each task in the dynamic task area is mapped to an identification buffer; the task execution information includes the execution status of the task, including the two states of executed and unexecuted; the information in the identification buffer corresponds to each task and stores the execution information of the task; Figure 6 The schematic diagram of the storage structure allocated for dynamic tasks stores the identification buffer containing the task execution information in the LDM shared space; each slave core obtains the task execution information of the next task in the identification buffer; at the same time, a double buffering strategy is adopted, and two identification buffers are configured to reset the buffer used in the next round while executing the current round of tasks; the number of cycles is effectively reduced and the execution efficiency is improved. After the slave core successfully obtains the task execution information to be executed, the task read in the dynamic task area is calculated in the LDM private space of the slave core using DMA.

[0049] Example 2

[0050] The difference between the autonomous preemptive load balancing method for slave core array based on Shenwei multi-core processor described in Example 1 is that:

[0051] In step 2), the small-scale task is divided into a static task area and a dynamic task area; including:

[0052] Before the calculation begins, the small-scale task is divided into a static task area and a dynamic task area. The static task area accounts for 30% of the small-scale task, and the dynamic task area accounts for 70% of the small-scale task.

[0053] In step 3), a master-slave acceleration parallel acceleration method is adopted, where the master core calls the slave core array to perform accelerated calculations;

[0054] Automatic dynamic task division is achieved by automatically applying for computing tasks in the dynamic task area from the slave core; this process does not require the participation of the master core and can effectively reduce the frequency of data exchange between the master and slave.

[0055] After the master core calls the slave core startup function, the master core starts to wait, and the slave core array starts to execute the entire computing task until the slave core calculation is completed before data processing. Data processing includes processing the results of the slave core calculation in the master core, as well as some subsequent tasks that should have been calculated by the master core.

[0056] Automatically apply for computing tasks in the dynamic task area from the core, realize automatic dynamic task division, and perform computing tasks; Figure 7 The execution flow chart for dynamically obtaining tasks from the core. Including:

[0057] When applying for a task, each slave core determines the currently used identification buffer; after determining the identification buffer to be used, it determines whether the current subtask has been preempted by other slave cores; if the current subtask has been executed, it applies for the next subtask; if the current subtask has not been executed, the slave core preempts the current subtask and marks the status of the current subtask as "executed";

[0058] After the current subtask is executed, the execution information of another identification buffer is reset to prepare for the next use. This process is repeated until all tasks in the dynamic task area are executed.

[0059] In step 3), a double buffering strategy is adopted to configure two identification buffers to reset the buffer used in the next round while executing the current round of tasks; including:

[0060] The identification buffer corresponds to each task one by one, and the initial states of the two identification buffers are exactly the same, and all corresponding tasks are marked as unexecuted; when executing the current round of tasks, the task information in the identification buffer used in this round is marked as executed, and the task information in the identification buffer used in the next round is reset to unexecuted.

[0061] The pseudo code of the slave core array autonomous preemptive load balancing method based on the Shenwei multi-core processor of the present invention is implemented as follows:

[0062] enter:

[0063] split_times : number of times the problem is decomposed

[0064] split_size : minimum problem size

[0065] static_size: static task allocation area size

[0066] dynamic_size: Dynamic task allocation area size

[0067] flag_buffer_1: Task flag buffer 1

[0068] flag_buffer_2: Task flag buffer 2

[0069] buffer_switch: task identification buffer switch flag

[0070] calculate:

[0071] for i=0,1,…, split_timesdo

[0072] DMA_Get(); / / Get the tasks in the static task allocation area in blocks through DMA

[0073] for j =0,1,…,static_size

[0074] / / Static task allocation area hotspot calculation

[0075] initialize_history / / Initialize calculation data

[0076] computing_simulation / / Start computing

[0077] end for

[0078] if buffer_switch then / / switch identification buffer

[0079] for j=0,1,…, dynamic_size do

[0080] if flag_buffer_1 == 0then / / Judge the current task execution status

[0081] flag_buffer_1 = 1 / / Occupancy task

[0082] flag_buffer_2 = 0 / / Flag buffer reset

[0083] else

[0084] continue / / Enter the next judgment process

[0085] endif

[0086] DMA_Get(); / / Get the task of the dynamic task allocation area through DMA

[0087] / / Dynamic task allocation area hotspot calculation

[0088] initialize_history / / Initialize calculation data

[0089] computing_simulation / / Start calculation

[0090] end for

[0091] endif

[0092] end for

[0093] OpenMC is a program that simulates the particle transport process by the Monte Carlo method, and can evaluate the operating stability of a nuclear reactor by calculating the k-eff value. The test sample program used in the present invention is the core hotspot segment in the OpenMC program, and the core hotspot segment calculates the k-eff value by tracking and sampling random particles. The calculation result of the OpenMC program is related to the number of simulated particles. The more particles there are, the more accurate the calculation result is, and the longer the calculation time is. The hardware used in the test is a core group of a single Shenwei multi-core processor SW26010Pro; the data used are 10,000 particles, 100,000 particles and 1 million particles, corresponding to small-scale, medium-scale and large-scale tasks, respectively. In order to ensure the correctness and repeatability of the experimental results, the data of each scale are tested three times, and the results are taken as the average of the three tests. The test time of the optimization method of the invention is compared with the test time of the serial program and the ordinary multi-core optimization program, and the time unit is seconds.

[0094] The specific results are shown in Table 1.

[0095] Table 1 Optimization effect (seconds) of the optimization method of the present invention;

[0096]

[0097] The acceleration effect analysis is as follows. The efficiency of medium-scale data is improved compared with that of small-scale data, which shows that the load balancing method of the present invention can play a better role as the amount of data increases. The efficiency of large-scale data has decreased because the overhead of the dynamic application task part in the dynamic allocation task will increase with the increase of data scale. However, the acceleration effect of the invention method for large-scale data is still significantly improved compared with the acceleration effect of the ordinary method. Therefore, the method of the present invention has a more obvious acceleration effect compared with the ordinary optimization method.

Claims

1. The autonomous preemptive load balancing method for slave core array based on Shenwei multi-core processor is characterized in that: include: 1) For large-scale tasks, use the divide-and-conquer method to decompose them, including: decomposing large-scale tasks into several small-scale tasks with the same properties; for small-scale tasks, directly go to step 2); 2) For the obtained small-scale tasks, a mixed dynamic and static task division is performed; including: firstly, the small-scale tasks are divided into a static task area and a dynamic task area; Each slave core uses DMA to read the tasks in the static task area in blocks from the main memory to the local LDM; In the static task area, a uniform allocation method is adopted, and in the dynamic task area, a dynamic allocation method is adopted; dynamic allocation means that during the task execution process, each processing unit autonomously seizes the computing task through an optimization method according to the actual situation; specifically, each slave core obtains the execution information of the next task from the task execution information identification buffer after completing the current computing task according to the actual execution status of the slave core; if the acquired task execution status is not executed, the slave core autonomously seizes the task to start the calculation, and marks the applied task execution status as executed; if the acquired task status is executed, it continues to obtain the execution status of the next computing task; each slave core autonomously repeats this process until the execution status of all tasks is marked as executed, which means that all computing tasks have been completed; 3) Map each task execution information of the dynamic task area to an identification buffer; the task execution information includes the execution status of the task, including two states: executed and not executed; the information in the identification buffer corresponds to each task and stores the execution information of the task; the identification buffer containing the task execution information is stored in the LDM shared space; each slave core obtains the task execution information of the next task in the identification buffer; at the same time, a double buffering strategy is adopted, and by configuring two identification buffers, the buffer used in the next round is reset while executing the current round of tasks; after the slave core successfully obtains the task execution information to be executed, the task read in the dynamic task area is calculated in the LDM private space of the slave core using DMA.

2. The method for autonomous preemptive load balancing of slave core array based on Shenwei multi-core processor according to claim 1 is characterized in that: Large-scale tasks refer to tasks with more than 10,000 computing problems, which are a collection of a large number of computing problems; small-scale tasks refer to tasks with less than 10,000 computing problems, which are a subset of large-scale tasks.

3. The method for autonomous preemptive load balancing of slave core array based on Shenwei multi-core processor according to claim 1 is characterized in that: The uniform distribution method is to evenly distribute the tasks in the static task area to the processing units before the program starts executing.

4. The method for autonomous preemptive load balancing of slave core array based on Shenwei multi-core processor according to claim 1 is characterized in that: In step 2), the small-scale task is divided into a static task area and a dynamic task area; including: Before the calculation begins, the small-scale task is divided into a static task area and a dynamic task area. The static task area accounts for 30% of the small-scale task, and the dynamic task area accounts for 70% of the small-scale task.

5. The method for autonomous preemptive load balancing of slave core array based on Shenwei multi-core processor according to claim 1 is characterized in that: In step 3), a master-slave acceleration parallel acceleration method is adopted, where the master core calls the slave core array to perform accelerated calculations; Automatic dynamic task division is achieved by automatically applying for computing tasks in the dynamic task area from the core; After the master core calls the slave core startup function, the master core starts waiting, and the slave core array starts to execute the entire computing task until the slave core calculation is completed and then data processing is performed.

6. The method for autonomous preemptive load balancing of slave core array based on Shenwei multi-core processor according to claim 1, characterized in that: Automatically apply for computing tasks in the dynamic task area from the core, realize automatic dynamic task division, and perform computing tasks; include: When applying for a task, each slave core determines the currently used identification buffer; after determining the identification buffer to be used, it determines whether the current subtask has been preempted by other slave cores; if the current subtask has been executed, it applies for the next subtask; if the current subtask has not been executed, the slave core preempts the current subtask and marks the status of the current subtask as executed; After the current subtask is executed, the execution information of another identification buffer is reset to prepare for the next use; and so on, until all tasks in the dynamic task area are executed.

7. The autonomous preemptive load balancing method for slave core array based on Shenwei multi-core processor according to any one of claims 1 to 6, characterized in that: In step 3), a double buffering strategy is adopted to configure two identification buffers to reset the buffer used in the next round while executing the current round of tasks; including: The identification buffer corresponds to each task one by one, and the initial states of the two identification buffers are exactly the same, and all corresponding tasks are marked as unexecuted; when executing the current round of tasks, the task information in the identification buffer used in this round is marked as executed, and the task information in the identification buffer used in the next round is reset to unexecuted.

Images