CN103257904B - Optimize computing flow graph mapping method and the device of many core system repairing performances - Google Patents

Abstract

The embodiment of the present invention provides a kind of computing flow graph mapping method and device of optimizing many core system repairing performances. The method mainly comprises: for many core system computing flow graphs, for the task of each node is carried out Calculation of Reliability; Ensure that according to reliability priority and many core architecture resources generate the idle check figure order of the required vicinity taking of node; Ensure that according to the reliability obtaining priority list and system computing flow graph complete the mapping of computing flow graph to the many core frameworks of target. The method that multiple compute node is ensured in many core frameworks to priority level initializing layout by reliability that the present invention proposes, can solve preferably time delay and the power problems of many core system failures selfreparing and repair after hydraulic performance decline problem.

Description

Operation flow graph mapping method and device for optimizing repair performance of many-core system

technical field

The invention relates to the field of many-core processors, in particular to an operation flow graph mapping method and device for optimizing the repair performance of a many-core system.

Background technique

At present, with the advancement of semiconductor technology, the integration level is getting higher and higher, and the number of gates that can be integrated on a unit area is increasing. In recent years, designers in the industry have realized that the design of processor chips is facing two problems: one is the Pollack's law, the improvement of the computing efficiency of a single chip is only proportional to the square root of the design complexity (number of gates), which means The increase in the design complexity of a single chip and the improvement of operating efficiency have reached a bottleneck; the second is the increasing concern for system reliability. When the chip is in use, a failure of a basic component or computing unit may cause the entire system to crash. A system-on-a-chip recovers from a failure, increasing the lifetime of the system also becomes an issue.

The single-core system cannot meet the requirements of designers and users not only in terms of performance improvement, but also in terms of energy consumption caused by complex design, and in terms of handling measures for reliability failures. Increasing the number of cores, multi-core cooperative parallel processing can improve the efficiency of system task processing; on the other hand, the many-core system architecture has many redundant resources, which provides conditions for the self-healing of the processor system. Figure 1 shows a rectangular many-core architecture with redundant cores, routing and communication lines.

There are two main types of existing technologies: one is that when a single-core failure is detected, it will restart under the cooperation of the control core to achieve the purpose of recovery; the other is when a single-core failure is detected And when it cannot be restored after restarting, the certain core is separated from the many-core system, and the business of the redundant checking system is used to redistribute, so as to restore the system function.

The disadvantages of the above-mentioned existing two methods for improving the reliability of many-core processors are: although the first scheme can restore the soft errors caused by signal changes caused by the environment, high-energy particles, etc., if a fault occurs on the core hardware, restart It cannot be solved; although the second scheme provides a highly reliable recovery scheme, the scheme does not provide a mapping method that can improve self-healing performance. If there is no idle core, the core task will be reassigned to a location far away from the original location, or multiple core tasks will be moved, resulting in excessive system performance degradation after repair and excessive self-repair delay and excessive power consumption Large, and the impact will be greater after multiple faults are self-repaired.

For this reason, how to map the operation flow graph of a system to the many-core architecture, so that the fault self-repair delay is short, and the impact on system performance after repair is low, has become a problem to be solved. Aiming at the above problems, the present invention proposes an operation flow graph mapping method and device for optimizing the repair performance of many-core systems under the support of the subject numbered 513080102.

Contents of the invention

Aiming at the above-mentioned deficiencies in the prior art, the present invention provides an operation flow graph mapping method that optimizes the repair performance of many-core systems, and its purpose is to solve the problem of prolonged self-repair and system performance degradation after self-repair of many-core systems due to failures And other issues.

The present invention is realized through the following technical solutions:

An operation flow graph mapping method for optimizing the repair performance of many-core systems, comprising:

For a many-core system operation flow diagram that has assigned tasks, perform reliability calculations for each node task, and generate the reliability guarantee priority of each node task;

Generate the number of adjacent idle cores that the node needs to reserve based on the reliability guarantee priority;

Based on the reliability guarantee priority list and the system operation flow graph, the mapping of the operation flow graph to the target many-core architecture is completed.

Preferably, for a many-core system operation flow graph that has assigned tasks, the reliability calculation is performed for the tasks of each node, which also includes:

The more important the task, the higher the reliability assurance priority;

The higher the task failure probability, the higher the reliability guarantee priority;

Or, take these two factors into consideration.

Preferably, the method for generating the number of adjacent idle cores required by the node according to the reliability guarantee priority also includes:

To generate adjacent idle cores, the total number of task nodes and many-core architecture resources need to be considered. The number of adjacent idle cores assigned to different priorities is automatically generated by this method or manually defined by the user, and stored in the reliability guarantee priority list; many-core architecture resources are configured by the user .

Preferably, adjacent idle cores are characterized by:

The range of adjacent idle cores is user-defined.

Preferably, it is characterized in that the mapping of the operation flow graph to the target many-core architecture is completed according to the reliability guarantee priority list and the system operation flow graph, including steps:

The first step is to select the node with the highest reliability guarantee priority among the unmapped nodes;

In the second step, whether there is an undistributed core on the target many-core architecture, if there is, the third step is carried out, otherwise the fifth step is carried out;

The third step is to inquire whether there is an area to meet the requirement of the number of free cores adjacent to the node, if it does not exist, then proceed to the fourth step, otherwise proceed to the sixth step;

The fourth step is to reduce the requirement for adjacent idle cores, and repeat the third step;

The fifth step is to select the node with the lowest reliability guarantee priority among the mapped nodes and the number of adjacent idle cores, and use its idle cores as the mapping target;

The sixth step is to map the nodes to the area;

The seventh step is to check whether the mapping is completed, if it is completed, go to the eighth step, otherwise return to the first step;

The eighth step is to select a core in each node area according to a certain method as the initial position for configuration, and complete the system configuration;

In the ninth step, the remaining unconfigured cores are used as idle standby cores.

The present invention also provides an operation flow graph mapping device for optimizing the repair performance of the many-core system, which aims to solve the problems of prolonged self-repair and system performance degradation after the self-repair of the many-core system due to failure.

An operation flow graph mapping device for optimizing the repair performance of many-core systems, comprising:

The reliability estimation module is used to calculate the reliability of each node task in the system operation flow graph, and generate a reliability guarantee priority list;

The priority storage unit is used to store the reliability guarantee priority list;

The mapping configuration unit is used to map the system operation flow graph to the target many-core architecture according to the reliability guarantee priority list to complete the system configuration;

The mapping area storage unit is used to store the mapping area of each task node.

Preferably, the reliability estimation module automatically determines the priority of the task according to the importance of the task and the probability of failure;

The more important the task, the higher the reliability guarantee priority; the higher the task failure probability, the higher the reliability guarantee priority; or, the two factors are considered comprehensively.

Preferably, the priority list generated by the reliability estimation module is represented by the number of adjacent idle cores that need to be reserved, and the number of adjacent idle cores is automatically generated by the operation flow graph mapping device that optimizes the repair performance of the many-core system or is configured by the user.

Preferably, the priority storage unit is modified to reduce the number of adjacent idle cores required to be reserved when the mapping allocation cannot be completed.

Preferably, the mapping configuration unit is also used to request modification of the priority storage unit when the mapping allocation cannot be completed.

Preferably, the mapped area storage unit is also used to guide tasks to be repaired to be preferentially allocated in the area allocated by the core when the system is self-repairing.

Applying the operation flow graph mapping method and device for optimizing the repair performance of the many-core system provided by the embodiment of the present invention, since a certain amount of idle cores are reserved near the operation nodes with low reliability, when the system failure self-repair , can quickly find the repair location in the area near the fault, complete self-repair, and reduce repair delay; and because the relative position of the entire system on the many-core architecture changes little, the impact of self-repair on system performance is greatly reduced; especially for a It is more effective for vulnerable task nodes to self-heal after multiple failures.

Description of drawings

Figure 1 shows a 4×4 processor array architecture;

FIG. 2 is a flowchart of an operation flow graph mapping method for optimizing the repair performance of a many-core system provided by Embodiment 1 of the present invention;

FIG. 3 is a schematic diagram of a reliability guarantee priority list provided by Embodiment 1 of the present invention;

FIG. 4 is a flow chart of specific steps in the operation flow graph mapping configuration step in the flow of an operation flow graph mapping method for optimizing the repair performance of many-core systems provided by Embodiment 1 of the present invention;

Fig. 5 is an operation flow diagram of a system provided by Embodiment 1 of the present invention;

FIG. 6 is a schematic diagram of the mapping configuration of the node reliability guarantee priority to the target many-core architecture provided by Embodiment 1 of the present invention;

FIG. 7 is a specific structural diagram of an operation flow graph mapping device for optimizing the repair performance of a many-core system provided by Embodiment 2 of the present invention.

detailed description

The technical solutions in the embodiments of the present invention will be clearly and completely described and discussed below in conjunction with the accompanying drawings of the present invention. Obviously, what is described here is only a part of the examples of the present invention, not all examples. Based on the present invention All other embodiments obtained by persons of ordinary skill in the art without creative efforts fall within the protection scope of the present invention.

In order to facilitate the understanding of the embodiments of the present invention, several specific embodiments will be taken as examples for further explanation below in conjunction with the accompanying drawings, and each embodiment does not constitute a limitation to the embodiments of the present invention.

Embodiment one

The processing flow of an operation flow graph mapping method for optimizing the repair performance of a many-core system provided in this embodiment is shown in FIG. 2 , including the following processing steps:

Step 201, for a system operation flow graph that has been allocated, perform reliability calculation on the tasks of each node. The calculation method mentioned mainly considers the importance of the task and the failure probability, and of course, some other factors may also be considered. The more important the task, the higher the reliability guarantee priority; the higher the task failure probability, the higher the reliability guarantee priority. This step will comprehensively calculate the status of each task, and automatically give reliability guarantee priority.

Step 202, according to the reliability guarantee priority of each node task given in step 201, combined with the total number of task nodes and the resource status of the target many-core architecture, automatically or manually determine that each node needs to reserve adjacent idle cores when mapping number, to formulate a reliability guarantee priority list; obviously, the many-core architecture resources are not limited to the four-by-four rectangular structure shown in Figure 1, larger and smaller rectangles, circles or other similar structures are included .

When the reliability guarantee priority of a task node is higher, the number of adjacent idle cores assigned to the node is higher. Of course, it is also possible to set a certain number of reserved adjacent idle cores within a certain priority range.

A schematic diagram of a reliability guarantee priority list provided in this embodiment is shown in FIG. 3 . Each set of data in the table includes the name of the node task and the number of adjacent idle cores that need to be reserved when the node task is mapped. At the same time, since the reservation requirements of certain nodes may not be met during mapping, the number of reserved adjacent idle cores in the reliability guarantee priority list can be modified according to the corresponding situation.

The adjacent idle core has different definitions according to different situations; when the distance between the idle core and a certain core is less than or equal to X, it is the adjacent idle core of the core, where X is an integer greater than or equal to 1.

Step 203, based on the reliability guarantee priority list given in step 202, each node task of the system is mapped to the target many-core architecture one by one according to the priority from high to low.

This example provides a step-by-step process for mapping configurations to the target many-core architecture based on the system operation flow graph and node reliability guarantee priority, as shown in Figure 4, mainly including:

Step 400, the initial step, the mapping method knows the system operation flow graph and the reliability guarantee priority information of each node in the operation flow graph and the resource status of the mapping target many-core architecture;

Step 401, select a node with the highest reliability guarantee priority from the unmapped configuration node tasks, and use this node as the node to be mapped;

Step 402, check whether there are unallocated cores in the target many-core architecture, if there are still uncompleted cores, proceed to step 403, if all cores have been allocated, proceed to step 405;

Step 403, according to the reliability guarantee priority list given in step 202, check whether there is an area on the many-core architecture that meets the reliability guarantee requirements of the task node, if it cannot be satisfied, go to step 404, if it can be satisfied, then Taking the area as the mapping target, proceed to step 406;

Step 404, in the reliability guarantee priority list, reduce the task reliability guarantee requirements of the node, that is, reduce the number of adjacent idle cores reserved by the node, and re-execute step 403;

Step 405, since all the nodes on the many-core architecture have been allocated, the allocated task nodes are selected according to the reliability guarantee priority from low to high. If the node is allocated with a reserved idle core, this reserved idle core is used as The mapping target of the node to be allocated.

Step 406, steps 403 and 405 have determined the mapping target of the task node to be allocated, mapped the node to be mapped to the target area, and marked the allocated core as allocated;

Step 407, check whether all task nodes have completed the mapping, if not, re-execute step 401;

Step 408, in the allocation area corresponding to each task node, select a core as the configuration core according to a certain algorithm, and configure the corresponding task;

In step 409, the mapping is completed, and the configuration of the many-core system is completed. All unconfigured cores are set to be idle, and can be added to the system as alternative core configurations when the running core fails.

For example, as shown in Figure 5 and Figure 6, a schematic diagram of mapping configuration to the target many-core architecture according to the system operation flow graph and node reliability guarantee priority, in which:

Next to each task node in the system operation flow diagram, the reliability guarantee priority of the node is indicated, that is, the mapping configuration is the number of adjacent idle cores that need to be reserved;

According to the order of reliability guarantee priority, nodes C, D, E, A, B, G, and F are allocated sequentially. It is worth noting that when F is allocated, there are no unallocated cores, and the reserved idle cores of G are selected. as the F-map target core;

According to a certain algorithm, one core is selected as the configuration core in each task node area to complete the system configuration, and the remaining cores are used as idle cores for system self-repair. In particular, faulty cores are first repaired in the area assigned to this core.

It can be seen from the technical solutions provided by the above-mentioned embodiments of the present invention that the embodiments of the present invention perform reliability calculations on each task node in the system operation flow graph, and reserve more idle cores near them for nodes with low reliability. When a low-reliability task core fails and needs self-repair, it can quickly find an idle core nearby to complete self-repair, and complete system recovery efficiently and quickly; and because it can avoid the occurrence of self-repair The core position is too far away from the original position, and The need to move multiple core tasks greatly reduces the impact of self-repair on system performance, especially for multiple fault self-repair of a vulnerable task node.

Embodiment two

An operation flow graph mapping device for optimizing the repair performance of many-core systems provided in this embodiment has a specific structure as shown in FIG. 7 and includes the following modules:

The reliability estimation module 601 is used to perform reliability calculation on each node task in the system operation flow graph, and generate a reliability guarantee priority list;

A priority storage unit 602, configured to store a reliability guarantee priority list;

The mapping configuration unit 603 is used to map the system operation flow graph to the target many-core architecture according to the reliability guarantee priority list to complete the system configuration;

The mapping area storage unit 604 is configured to store the mapping area of each task node.

Specifically, the reliability estimation module 601 automatically determines the priority of the task according to the importance of the task and the probability of failure. The more important the task, the higher the priority of reliability guarantee; the higher the probability of task failure. High, the higher the reliability guarantee priority. These two factors need to be considered comprehensively, and of course other factors can also be considered comprehensively.

Specifically, the priority list generated by the reliability estimation module 601 is represented by the number of adjacent idle cores that need to be reserved, and the number of adjacent idle cores can be automatically generated or configured by the user.

Specifically, when the mapping allocation cannot be completed, the priority storage unit 602 can be modified to reduce the required number of reserved adjacent idle cores.

Specifically, the mapping configuration unit 603 is further configured to make a modification request to the priority storage unit 602 when the mapping assignment cannot be completed.

Specifically, the mapping area storage unit 604 is also used to guide tasks that need to be repaired to be preferentially configured in the area allocated by the core when the system is self-repairing.

The specific steps of implementing the mapping capable of optimizing the repair performance of the many-core architecture system using the device of the embodiment of the present invention are similar to the foregoing method embodiments, and will not be repeated here.

Those of ordinary skill in the art can understand that all or part of the processes in the methods of the above-mentioned embodiments can be completed by instructing related hardware through computer programs, and the programs can be stored in computer-readable storage media, and the programs can , the flow of the embodiments of the above-mentioned methods may be included. Wherein, the storage medium can be referred to as a magnetic disk, an optical disk, a read-only memory or a random access memory, and the like.

To sum up, the embodiment of the present invention calculates the reliability of each task node in the system operation flow graph, reserves more idle cores near the nodes with low reliability, and requires During self-repair, it can quickly find idle cores nearby to complete self-repair, and complete system recovery efficiently and quickly; and because it can avoid the situation where the core position is too far away from the original position after self-repair and the need to move multiple core tasks, It greatly reduces the impact of self-repair on system performance, especially for multiple fault self-repair of a vulnerable task node.

The embodiments of the present invention can better solve problems such as prolonged self-repair time and system performance degradation after self-repair due to failure of many-core systems.

The above is only a preferred embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any person skilled in the art can easily conceive of changes or modifications within the technical scope disclosed in the present invention. Replacement should be covered within the protection scope of the present invention. Therefore, the protection scope of the present invention should be determined by the protection scope of the claims.

Claims (10)

1. An operation flow graph mapping method for optimizing many-core system repair performance, characterized in that, comprising: For a many-core system operation flow diagram that has assigned tasks, perform reliability calculations for each node's tasks, and generate the reliability guarantee priority of each node task; Generate the number of adjacent idle cores that the node needs to reserve based on the reliability guarantee priority; Based on the reliability guarantee priority list and the system operation flow graph, complete the mapping from the operation flow graph to the target many-core architecture; Complete the mapping of the operation flow graph to the target many-core architecture according to the reliability guarantee priority list and the system operation flow graph, including steps: The first step is to select the node with the highest reliability guarantee priority among the unmapped nodes; In the second step, whether there is an undistributed core on the target many-core architecture, if there is, the third step is carried out, otherwise the fifth step is carried out; The third step is to inquire whether there is an area to meet the requirement of the number of free cores adjacent to the node, if it does not exist, then proceed to the fourth step, otherwise proceed to the sixth step; The fourth step is to reduce the requirement for adjacent idle cores, and repeat the third step; The fifth step is to select the node with the lowest reliability guarantee priority among the mapped nodes and the number of adjacent idle cores, and use its idle cores as the mapping target; The sixth step is to map the nodes to the area; The seventh step is to check whether the mapping is completed, if it is completed, go to the eighth step, otherwise return to the first step; The eighth step is to select a core in each node area according to a certain method as the initial position for configuration, and complete the system configuration; In the ninth step, the remaining unconfigured cores are used as idle standby cores. 2. The operation flow graph mapping method for optimizing many-core system repair performance according to claim 1, characterized in that, for the operation flow graph of a many-core system that has been assigned a task, the task of each node is reliably Sex calculations, also include: The more important the task, the higher the reliability assurance priority; The higher the task failure probability, the higher the reliability guarantee priority. 3. The operation flow graph mapping method for optimizing the repair performance of a many-core system according to claim 1, wherein the method for generating the number of adjacent idle cores required for a node according to the reliability guarantee priority also includes: To generate adjacent idle cores, the total number of task nodes and many-core architecture resources need to be considered. The number of adjacent idle cores assigned to different priorities is automatically generated by this method or manually defined by the user, and stored in the reliability guarantee priority list; many-core architecture resources are configured by the user . 4. The operation flow graph mapping method for optimizing the repair performance of a many-core system according to claim 1, wherein the range of adjacent idle cores is defined by a user. 5. An operation flow graph mapping device for optimizing many-core system repair performance, characterized in that it comprises: The reliability estimation module is used to calculate the reliability of each node task in the system operation flow graph, and generate a reliability guarantee priority list; The priority storage unit is used to store the reliability guarantee priority list; The mapping configuration unit is used to map the system operation flow graph to the target many-core architecture according to the reliability guarantee priority list to complete the system configuration; The mapping area storage unit is used to store the mapping area of each task node. 6. The operation flow graph mapping device for optimizing many-core system repair performance according to claim 5, wherein the reliability estimation module automatically determines the task according to the importance of the task and the probability of failure the priority size; The more important the task, the higher the reliability guarantee priority; the higher the task failure probability, the higher the reliability guarantee priority. 7. The operation flow graph mapping device for optimizing the repair performance of many-core systems according to claim 5, wherein, in the reliability estimation module, the generated priority list is represented by the number of adjacent idle cores that need to be reserved, The number of adjacent idle cores is automatically generated by the operation flow graph mapping device for optimizing the repair performance of many-core systems or configured by the user. 8. The operation flow graph mapping device for optimizing the repair performance of many-core systems according to claim 5, wherein the priority storage unit is modified to reduce the required reserved adjacent Number of idle cores. 9. The operation flow graph mapping device for optimizing many-core system repair performance according to claim 5, characterized in that, The mapping configuration unit is further configured to request modification to the priority storage unit when the mapping allocation cannot be completed. 10. The computing flow graph mapping device for optimizing the repair performance of many-core systems according to claim 5, wherein the mapping area storage unit is also used to guide tasks that need to be repaired to be prioritized when the system is self-repairing. The mapping area is stored in the mapping area storage unit.