CN104281495B - Method for task scheduling of shared cache of multi-core processor - Google Patents

Abstract

The invention discloses a multi-core processor shared cache task scheduling method. The first step is to divide the shared Cache of the multi-core processor into several blocks, and initialize the processing core-related parameters at the same time; the second step is to calculate all processing The earliest task execution completion time corresponding to the core and the task shared Cache block; the third step is to judge whether there is a task processing check that can meet the shared Cache block conditions required by the task; the fourth step is to find the optimal schedulable task processing check, and Tasks are scheduled to be executed on corresponding processing cores, and parameters related to multi-core processor parameters are updated. The fifth step is to judge whether all the tasks in the task queue have been scheduled, and if the scheduling is completed, the task processing check sequence is output, otherwise, the second, third, and fourth steps are cyclically executed. Compared with the existing multi-core processor-oriented task scheduling theory, this method has performance advantages such as short scheduling length and average response time.

Description

Multi-core processor shared cache task scheduling method

technical field

The invention belongs to the technical field of computer software and on-chip multi-core processor resource management and task scheduling, and relates to a task scheduling method considering a shared high-speed cache cache.

Background technique

In recent years, with the continuous improvement of VLSI integration and main frequency, integrated circuit technology has encountered insurmountable physical problems such as interconnection delay, short channel effect, drift velocity saturation, hot carrier degradation effect, etc. Extreme challenge. This challenge has brought problems such as manufacturing cost, power consumption, and heat dissipation to single-core processor technology, prompting chip manufacturers to turn to multi-core processors that integrate multiple processor cores on the chip. At present, commercial multi-core U processors integrating dozens of cores, such as twelve-core Intel Xeon E5 and AMD Opteron, have been widely used in large-scale computing services such as clusters, data centers, and cloud computing.

The most critical structural feature of an on-chip multi-core processor is that all its processor cores do not exist independently, but are connected to each other through many common resources, including high-speed cache, memory access channels, and so on. This architectural feature allows multiple user applications or parallel threads to execute on a multi-core processor, even if there is no cross-application resource and communication requirements, each application or thread still interferes with each other due to shared resources, such as shared cache Cache. Since multiple applications or threads share the last level of Cache (L2 or L3) of the on-chip multi-core processor, they compete with each other for Cache resources and conflict, resulting in a decrease in the concurrent performance of the multi-core processor.

The performance degradation of multi-core processors due to the sharing of Cache resources has always been a research hotspot at home and abroad. The present invention uses a software task scheduling strategy to overcome this problem, trying to alleviate the interference caused by resource conflicts through reasonable task allocation and regulation, and effectively reduce Concurrency performance drops.

The task scheduling problem is essentially a combinatorial optimization problem, and the optimal solution of the combinatorial optimization problem is an NP-complete problem. In particular, the present invention needs to meet the task sharing Cache block requirements, so it is an NP-complete problem. In fact, the cost of obtaining NP-complete solutions is too high.

Contents of the invention

Aiming at the phenomenon that parallel threads of multi-core processors share secondary or tertiary high-speed caches, resulting in conflicts between threads due to competing resources, resulting in a decline in concurrent performance of multi-core processors, the invention proposes a shared Cache-driven task scheduling method.

For realizing above-mentioned technical purpose, the technical scheme that the present invention adopts is:

A multi-core processor shared cache task scheduling method, the method comprises the steps of:

Step 1: Carry out Cache block division for the shared high-speed cache Cache of the multi-core processor system, first divide the shared Cache into several Cache pages according to the column address space, and then divide the shared Cache into Cache blocks composed of Cache pages;

Step 2: Initialize the earliest execution time of the task, the earliest execution completion time of a single processing core, the number of shared Cache blocks owned by a single processing core, and the number of shared Cache blocks available to the system;

Step 3: For each task in the task queue of the multi-core processor system, judge each processing core in the system according to the number of shared Cache blocks required for its execution, if the number of available shared Cache blocks in the system meets the corresponding If the sum of the shared Cache blocks owned by the processing cores is not less than the number of shared Cache blocks required by the task, then calculate the earliest execution completion time of the task on the processing core; Tasks are judged until all tasks are judged;

Step 4: According to the result of step 3, determine whether there is a processing core capable of executing tasks in the task queue, that is, whether the earliest execution completion time of any task on any processing core has been calculated, if so, perform step 6, otherwise perform step 5 ;

Step 5: Query the execution completion time of all processing cores to process existing tasks, find the processing core with the shortest remaining execution completion time of the current processing task, and update the execution completion time of this processing core so that it is no longer the earliest among all processing cores Execution completion time, wait for the processing core to complete the task, and then release the number of shared Cache blocks owned by the processing core. The number of available shared Cache blocks in the multi-core processor system is updated to the original number of blocks + the shared Cache owned by the processing core The number of blocks, set the shared Cache block owned by this processing core to 0, and go to step 7;

Step 6: According to the earliest execution completion time of each task on the corresponding processing core obtained in step 3, find out the earliest execution completion time and the corresponding task v _i and corresponding processing core p _k ; the system assigns task v _i Given the processing core p _k , update the earliest execution completion time of the processing core p _k to be the earliest execution completion time of the task v _i on the processing core p _k , and update the number of shared Cache blocks owned by the processing core p _k to the original processing core p The sum of shared cache blocks owned by _k and the number of shared cache blocks required by task v _i , the number of available shared cache blocks owned by the multi-core processor is updated as the available shared cache blocks owned by the original multi-core processor minus the number of shared cache blocks owned by the task Need to share the number of Cache blocks, go to step 7;

Step 7: Query whether there are tasks waiting to be scheduled in the task queue. If there is no task, output the task processing core scheduling sequence pair, otherwise return to step 3 to recalculate the earliest execution completion time of all tasks on the processing core and execute in a loop until all tasks Scheduled.

The multi-core processor shared cache task scheduling method, in the step 1, the size of the Cache page is 512B.

The multi-core processor shared cache task scheduling method, in the step 1, the capacity of the Cache block=shared cache capacity/(processor core number*10).

Described a kind of multi-core processor shared high-speed cache task scheduling method, in described step 3, each task in the multi-core processor system task queue can submit required Cache block number and corresponding execution simultaneously when submitting time.

The multi-core processor shared cache task scheduling method, in step 5, after finding the processing core with the shortest remaining execution completion time of the current processing task, update the execution completion time of this processing core to all processing cores The third earliest execution completion time among execution completion times.

According to the multi-core processor shared cache task scheduling method, in step 7, it is checked whether there are tasks waiting to be scheduled in the task queue, that is, checking whether the task queue is empty.

The technical effect of the present invention is that a heuristic scheduling strategy is used to provide a reasonable solution space to improve the ability of multi-core processors to execute tasks concurrently and improve processor performance. Using this method, compared with the existing multi-core processor-oriented task scheduling theory It has performance advantages such as scheduling length and short average response time.

Description of drawings

Fig. 1 is the flow chart of the multi-core processor shared cache task scheduling method provided by the present invention;

Fig. 2 is the multi-core processor high-speed cache cache level example diagram provided by the implementation of the present invention;

Figure 3 is the experimental results of 60 to 200 tasks with 4-core processors with 28 shared Cache blocks;

detailed description

The method of the present invention will be described in detail below in conjunction with the accompanying drawings and embodiments.

The present invention proposes a multi-core processor shared Cache-driven task scheduling method, the flowchart of which is shown in FIG. 1 . The method can make full use of the multi-core processor Cache to implement an efficient task scheduling mechanism, thereby improving the concurrent processing performance of the multi-core processor.

The present invention realizes through following technical scheme:

This embodiment is aimed at independent parallel application tasks, these tasks do not have dependencies such as data and control, and can run independently on their data sets. However, due to competition among multi-core processors sharing the Cache, the task data cannot be effectively loaded into the Cache and the performance of the processor is reduced. In the present invention, the execution time of each task relative to the shared Cache block is expressed as: w _i,j , where i represents task v _i , and j represents the number of shared Cache blocks required for task v _i to execute. For example, w _1,6 =19.3 indicates that the execution time for task v ₁ to obtain 6 shared Cache blocks is 19.3s, and w _1,10 =17.5 indicates that the execution time for task v ₁ to obtain 10 shared Cache blocks is 17.5s. In this embodiment, the more shared Cache blocks a task obtains within a certain range, the shorter the execution time will be. However, the number of shared Cache blocks beyond this range does not affect the task execution time.

Since the multi-core processor integrates multiple processing cores on one chip, resource sharing technology is widely used. Among them, cache Cache is the most important sharing technology. Figure 2 shows AMD's multi-core processor. Each processing core has its own local L1 and L2Cache, but both share L3Cache. In this embodiment, p _k is used to represent the kth processing core of the multi-core processor.

This embodiment proposes a software-supported Cache block division method for the shared Cache. The basic idea is to use the OS page allocation mechanism to control the size of the Cache used by tasks. First, use the multi-core processor OS function to divide the shared cache into the smallest pages according to the column address space, and then divide the shared cache into several blocks according to the number of multi-core processor cores. For example, a quad-core processor with a shared cache of 4M can be divided into 40 cache blocks. Its purpose is to calculate the Cache blocks required by the task in the scheduling algorithm, and use set associative to realize the effective mapping of data codes to shared Cache under the support of multi-core processor OS software.

The multi-core processor shared cache task scheduling method first initializes the earliest execution time of the task on each processing core, the earliest execution time of the processing core, the number of shared Cache blocks owned by all processing cores, and the number of shared Cache blocks available to the processor. , giving initial values to the following parameters respectively. EST(v _i ,p _k )=0 means that the initial execution time of task v _i on processing core p _k is 0; FT(p _k )=0 means the earliest execution completion time of tasks currently assigned to processing core p _k is 0; pSCache[k]=0 means that the initial value of shared Cache blocks owned by all processing cores is 0; AvailCache=MaxCache means that the shared Cache blocks available to the current processor are the maximum number of shared Cache blocks available in the current system, such as 40Cache in the above example Piece.

For each task in the task queue of the multi-core processor system, according to its different requirements for the number of shared Cache blocks, this embodiment calculates the earliest execution completion time of the task for each processing core in turn. Its calculation method is based on the following formula:

EFT(v _i ,p _k )＝EST(v _i ,p _k )+ET(v _i ,j,p _k )

=FT(p _k )+w _i,j

subject to j≤AvailCache+pSCache[k]

When the available shared Cache block AvailCache+pSCache[k] provided by the multi-core processor meets the shared Cache block required by the task, calculate the earliest execution completion time EFT(v _i ,p _k ) of the task on the processing core. The earliest execution completion time of the task is the sum of the earliest execution completion time FT(p _k ) of the assigned task of the processing core where the task is located and the task execution time w _i,j . In this embodiment, this calculation process is repeated until the earliest execution completion time EFT(v _i , p _k ) of the task is calculated for all tasks, different numbers of shared Cache blocks of the tasks and all processing cores.

When the multi-core processor assigns some tasks to be executed on each processing core, the available shared Cache block AvailCache will decrease. The condition AvailCache+pSCache[k] cannot be satisfied for all possible situations in some cases, at this time, the multi-core processor resource management system will release some processing cores. The scheduling method will query the earliest execution completion time FT(p _k ) of all processing cores to process their own current tasks, find the earliest execution completion time FT(p _m ) with the smallest among all processing cores, and update the multi-core processor parameters: the earliest execution completion The time FT(p _m ) is assigned as the third earliest execution completion time FT(p _k ); the available shared Cache block AvailCache is updated to AvailCache+pSCache[m]; the shared Cache block pSCache[m] owned by the processing core p _m is set is 0. After the multi-core processor updates all system parameters, it will continue to return to the previous step to recalculate all tasks, the number of different shared Cache blocks and the earliest execution completion time of tasks under the processing core.

If there is a task that meets the conditions and can be scheduled to be executed on a certain processing core, the task scheduling method of this embodiment will query the earliest execution completion time of all possible tasks, and find out the smallest task earliest execution completion time EFT(v _i ,p _k ). The system will assign the task v _i to the processing core p _k , and update the relevant parameters of the multi-core processor: the earliest execution completion time of the processing core p _k FT(p _k ) ₌ EFT(v _i ,p _k ); The existing shared Cache block pSCache[k]=pSCache[k]+j; the available shared Cache block AvailCache owned by the multi-core processor=AvailCache-j.

The shared cache task scheduling method adopted in this embodiment will continue the above steps until all tasks in the task queue of the multi-core processor are scheduled.

Performance analysis and result verification:

The multi-core processor shared cache task scheduling method of this embodiment is a scheduling technology with low time complexity and high efficiency, and its time complexity is O(N ² ML). Among them, N is the number of tasks, M is the number of cores processed by the multi-core processor, and L is the maximum number of different shared Cache blocks required by all tasks.

In the simulation experiment, the multi-core processor shared cache task scheduling method proposed by the present invention is named SCAS, and is mainly compared with the classic task scheduling algorithm MIN-MIN. In order to effectively understand the performance of the scheduling method SCAS, the experiment made some changes to SCAS. When selecting the optimal task, it is not the minimum and earliest execution completion time task and processing check, but the maximum and earliest execution completion time task and processing check. This method is named MSCAS. Performance evaluation indicators mainly include scheduling length (Makespan) and average response time (Average response time).

The experimental results are shown in Figure 3, and all experimental data are average values of multiple experiments. Figure 3 shows the experimental results of 60 to 200 tasks with 4-core processors and 28 shared Cache blocks. It can be seen from Figure 3 that the multi-core processor shared cache task scheduling method SCAS is superior to MIN-MIN and MSCAS in terms of scheduling length and average response time. In fact, in terms of average scheduling length, SCAS is 16.1% shorter than MSCAS and 8.37% shorter than MIN-MIN. For average response time, SCAS is 149% better than MSCAS and 10.5% better than MIN-MIN. The above experimental results show that the shared cache task scheduling method can effectively improve the performance of multi-core processors.

In summary, the multi-core processor shared cache task scheduling method proposed by the present invention can overcome the reduction of concurrent performance of the existing multi-core processor due to shared Cache, and effectively improve the performance of the multi-core processor.

Although the content of the present invention has been described in detail through the above embodiments, it should be understood that the above description should not be considered as limiting the present invention. Various modifications and alterations to the present invention will become apparent to those skilled in the art upon reading the above disclosure. Therefore, the protection scope of the present invention should be defined by the appended claims.

Claims (6)

1. a multi-core processor shared high-speed cache task scheduling method, is characterized in that, the method comprises the steps: Step 1: Carry out Cache block division for the shared high-speed cache Cache of the multi-core processor system, first divide the shared Cache into several Cache pages according to the column address space, and then divide the shared Cache into Cache blocks composed of Cache pages; Step 2: Initialize the earliest execution time of the task, the earliest execution completion time of a single processing core, the number of shared Cache blocks owned by a single processing core, and the number of shared Cache blocks available to the system; Step 3: For each task in the task queue of the multi-core processor system, judge each processing core in the system according to the number of shared Cache blocks required for its execution, if the number of available shared Cache blocks in the system meets the corresponding If the sum of the shared Cache blocks owned by the processing cores is not less than the number of shared Cache blocks required by the task, then calculate the earliest execution completion time of the task on the processing core; Tasks are judged until all tasks are judged; Step 4: According to the result of step 3, determine whether there is a processing core capable of executing tasks in the task queue, that is, whether the earliest execution completion time of any task on any processing core has been calculated, if so, perform step 6, otherwise perform step 5 ; Step 5: Query the execution completion time of all processing cores to process existing tasks, find the processing core with the shortest remaining execution completion time of the current processing task, and update the execution completion time of this processing core so that it is no longer the earliest among all processing cores Execution completion time, wait for the processing core to complete the task, and then release the number of shared Cache blocks owned by the processing core. The number of available shared Cache blocks in the multi-core processor system will be updated to the original number of blocks plus the share Cache block number, the shared Cache block owned by this processing core is set to 0, go to step 7; Step 6: According to the earliest execution completion time of each task on the corresponding processing core obtained in step 3, find out the earliest execution completion time and the corresponding task v _i and corresponding processing core p _k ; the system assigns task v _i Given the processing core p _k , update the earliest execution completion time of the processing core p _k to be the earliest execution completion time of the task v _i on the processing core p _k , and update the number of shared Cache blocks owned by the processing core p _k to the original processing core p The sum of shared cache blocks owned by _k and the number of shared cache blocks required by task v _i , the number of available shared cache blocks owned by the multi-core processor is updated as the available shared cache blocks owned by the original multi-core processor minus the number of shared cache blocks owned by the task Need to share the number of Cache blocks, go to step 7; Step 7: Query whether there are tasks waiting to be scheduled in the task queue. If there is no task, output the task processing core scheduling sequence pair, otherwise return to step 3 to recalculate the earliest execution completion time of all tasks on the processing core and execute in a loop until all tasks Scheduled. 2. A kind of multi-core processor shared high-speed cache task scheduling method according to claim 1, is characterized in that, in described step 1, the size of Cache page is 512B. 3. a kind of multi-core processor shared high-speed cache task scheduling method according to claim 1, is characterized in that, in described step 1, the capacity of Cache block=shared Cache capacity/(processor core number*10). 4. a kind of multi-core processor shared cache task scheduling method according to claim 1, is characterized in that, in described step 3, each task in the multi-core processor system task queue will submit simultaneously when submitting The number of Cache blocks required and the corresponding execution time. 5. A kind of multi-core processor shared high-speed cache task scheduling method according to claim 1, is characterized in that, in described step 5, after finding the processing core with the shortest execution completion time remaining of the current processing task, process this The execution completion time of the core is updated to be the third earliest execution completion time among all processing core execution completion times. 6. a kind of multi-core processor shared high-speed cache task scheduling method according to claim 1, is characterized in that, in described step 7, whether also has task waiting to schedule in the task queue of inquiry namely checks whether the task queue is empty .