CN103970580A - Data flow compilation optimization method oriented to multi-core cluster - Google Patents

Abstract

The invention discloses a data flow compiling optimization method for a multi-core cluster system, comprising: determining calculation tasks and processing core mapping task division and scheduling steps; constructing pipelines between cluster nodes and cluster node cores according to the task division and scheduling results The hierarchical pipeline scheduling step of the scheduling table; the caching optimization step based on cache is performed according to the structural characteristics of the multi-core processor, the communication situation between the cluster nodes and the execution situation of the data flow program on the multi-core processor. The method of the present invention combines the optimization technology related to the data flow program and the system structure, fully exerts the high load balance and the high parallelism of the synchronous and asynchronous mixed pipeline code on the multi-core cluster, and aims at the cache and communication mode on the multi-core cluster, The cache access and communication transmission of the program are optimized, which further improves the execution performance of the program and has a shorter execution time.

Description

A data flow compilation optimization method for multi-core clusters

technical field

The invention belongs to the technical field of computer compilation, and more specifically, relates to a multi-core cluster-oriented data flow compilation optimization method.

Background technique

With the development of semiconductor technology, multi-core processors have been verified as a viable platform for exploiting parallelism. Multi-core cluster parallel system has become an important parallel computing platform design due to its powerful parallel computing capability and good scalability. The multi-core cluster system provides powerful computing and processing capabilities, but also puts more burdens on compilers and programmers to effectively develop coarse-grained parallelism between cores. Dataflow programming provides a viable approach to exploit the parallelism of multicore architectures. In this model, each node represents a computing task, and each edge represents the data flow between computing tasks. Each computing task is an independent computing unit. It has an independent instruction flow and address space, and the data flow between computing tasks is realized through a first-in-first-out communication queue. The data flow programming model is based on the data flow model and implemented in the data flow programming language. Dataflow compilation is the compilation technique involved in converting a dataflow programming language into an underlying target executable program. Among them, compilation optimization plays a decisive role in the running performance of the data flow program on the target processing core.

The MIT Compilation Lab has released StreamIt, a stream programming language. The language is based on Java, and the stream extension of Java introduces the concept of Filter. Filter is the most basic calculation unit, it is a program block with single input and single output. Each processing process in Filter is described by Work, and each Work uses Push, Pop and Peek operations to communicate in FIFO mode. At the same time, a stream compilation optimization technology is proposed for the next-generation high-performance computer (Raw): first, the compiler adopts a method of combining data splitting and fusion to split and fuse computing nodes to increase the ratio of computing and communication overhead. ; Then map the processed computing nodes to each processing core to achieve load balance. Each processing core adopts pipeline execution mode, and the display communication is used between processing cores to realize data transmission.

StreamIt's stream compilation optimization technology proposes a solution to the scheduling problem of the stream programming model on multi-core processors. By distributing computing tasks to each processing core, load balancing is realized and parallel execution of computing tasks on processing cores is ensured. However, there are the following defects: (1) each calculation and communication scheduled to the processing core is separated, and an independent communication time is allocated for it in the pipeline, thus increasing the communication overhead; (2) the processing is not considered The underlying storage allocation optimization problem and communication optimization problem of the core; (3) The compilation optimization method does not optimize the underlying architecture characteristics of the multi-core cluster system. In short, for a multi-core cluster system, while providing powerful computing capabilities, it also opens its hierarchical storage structure and software communication mechanism to programmers. The existing stream compilation optimization methods do not take into account the underlying architecture, and do not make full use of system hardware resources such as storage resources to improve program execution efficiency.

Contents of the invention

The purpose of the present invention is to provide a multi-core cluster-oriented data flow compilation optimization method, which optimizes the data flow program for the architecture of the multi-core cluster system, and greatly improves the execution performance of the data flow program.

The optimization method adopted in the present invention takes the intermediate representation generated by the front end of the data flow compiler - the synchronous data flow graph as input, sequentially performs three-level processing of task division and scheduling, hierarchical pipeline scheduling, and cache optimization, and finally generates executable code. Specific steps are as follows:

(1) Determine the computing tasks and multi-core cluster computing nodes and the task division and scheduling steps for processing core mapping

The nodes in the data flow graph represent computing tasks, and the edges represent the communication between computing tasks. First, process-level task division is performed on the synchronous data flow graph according to the number of nodes in the cluster. This sub-step adopts the Group task division strategy. The goal is to minimize the communication overhead between nodes and maximize program execution performance. When dividing, both load balancing and To consider the minimization of communication overhead, assign each computing task to the corresponding cluster node. Secondly, according to the computing tasks on each cluster node, assign each computing task to the processing core of the cluster node for thread-level task division. This sub-step uses the replication splitting algorithm to split the heavy-load computing tasks. The goal is Realize load balancing on the internal processing cores of the cluster nodes.

(2) According to the task division and scheduling results, construct the hierarchical pipeline scheduling steps of pipeline scheduling between cluster nodes and cluster node cores

The synchronous pipeline uses a global synchronous clock to ensure that the execution tasks on each stage of the pipeline are completed at the same time, and the subtasks of the asynchronous software pipeline are executed in a data-driven manner. First, asynchronous pipeline scheduling is performed on the synchronous data flow graph to determine the task execution process among cluster nodes. This step randomly maps the computing tasks on each process to cluster computing nodes to complete the mapping between processes and cluster nodes; secondly, according to The dependencies between computing tasks in the cluster nodes assign each computing task (node) its stage number in the pipeline to complete the synchronous pipeline construction; finally, use the above two information to construct a hierarchical pipeline scheduling table.

(3) according to the structural characteristics of the multi-core processor, the communication situation between the cluster nodes and the execution situation of the data flow program on the multi-core processor, the cache optimization step is performed

When the computing task (node) is executing, the processing core where the computing task is located will have false sharing in the use of cache, which will have a great impact on the performance of program execution.

Analyze the general multi-core processor of X86 architecture, use the combination of cache line filling mechanism and steady-state expansion technology to eliminate the false sharing of program execution, and optimize the use of cache.

The present invention combines data flow scheduling with structure-related optimization of a multi-core cluster system, and realizes a three-level optimization process for data flow programs, specifically including task division and scheduling, hierarchical pipeline scheduling, and cache optimization, and improves data flow programs in Execution performance on the target platform. Specifically, the present invention has the following advantages:

(1) The parallelism of the program is improved. Through the formal description of the problem, the present invention abstracts the scheduling of the data flow graph to the processing cores of the multi-core cluster system as a greedy problem, thereby constructing a hierarchical pipeline scheduling model for the data flow program, and mapping tasks to each On the processing core, it realizes low communication overhead and load balancing, and improves the parallelism of the program.

(2) Reduce overhead. The present invention proposes a synchronous and asynchronous mixed hierarchical pipeline scheduling model to make full use of the computing and communication resources of the system. At the same time, it optimizes the use of the internal cache of the cluster nodes, improves the locality of data access and cache utilization, and enhances the program. operating efficiency.

Description of drawings

Fig. 1 is the structural frame diagram of the inventive method in the data stream compiling system;

Fig. 2 is a flow chart of the replication and splitting algorithm within the cluster node by the data flow program in the embodiment of the present invention;

FIG. 3 is an example diagram of asynchronous pipeline execution of a data flow program on a cluster in an embodiment of the present invention;

Figure 4(a) is an example diagram of task division and stage assignment in the synchronous software pipeline scheduling in the embodiment of the present invention;

Fig. 4(b) is an example diagram of the software pipeline execution process corresponding to Fig. 4(a);

Fig. 5(a) is a schematic diagram of the implementation of the data flow program execution steady-state expansion technology to eliminate false sharing tasks in the embodiment of the present invention;

Figure 5(b) is a schematic diagram before the elimination of task false sharing in Figure 5(a);

Fig. 5(c) is a schematic diagram after eliminating false sharing of tasks in Fig. 5(a).

Detailed ways

In order to make the object, technical solution and advantages of the present invention clearer, the present invention will be further described in detail below in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described here are only used to explain the present invention, not to limit the present invention. In addition, the technical features involved in the various embodiments of the present invention described below can be combined with each other as long as they do not constitute a conflict with each other.

As shown in Figure 1 is the structural framework diagram of this embodiment in the flow compilation system. After the data flow program is parsed by the front end of the data flow compiler, an intermediate representation - Synchronous Data Flow (Synchronous Data Flow, SDF) will be generated, and then After the three-level optimization process of task division and scheduling, hierarchical pipeline scheduling, cache optimization and communication optimization, the target code encapsulated by Message Passing Interface (MPI) is finally generated and compiled.

(1) Determine the computing tasks and multi-core cluster computing nodes and the task division and scheduling steps for processing core mapping

This step includes two sub-steps: process-level task division and thread-level task division. In a multi-core cluster system, since different nodes have different network addresses, the nodes need to communicate through the network, and its communication cost is high, while the communication within the node belongs to the internal communication of the machine, and its communication cost is small, so the data flow Program task partitioning requires distinguishing between these differences between nodes and between node cores. The description of task division at different levels under the cluster is as follows: process-level task division minimizes the communication overhead between nodes under the premise of ensuring load balance between nodes, and there is no loop between division results; thread-level task division ensures load balance between nodes Under the premise of minimizing synchronization overhead, and ensuring data locality as much as possible. Specific steps are as follows:

(1.1) Process-level task division. The process task division will determine the mapping between the computing unit and the cluster node. In order to amortize the communication overhead of the unit data volume of the data flow program during execution, the inter-process data communication adopts the block communication mechanism. Only when the buffer is filled or forcibly refreshed Messaging is only triggered when cached. In order to prevent deadlock during program execution, it is necessary to avoid loops in data dependencies between partitions at the process level. Aiming at the process-level task division of synchronous data flow graph of multi-core cluster, a Group task division strategy is proposed, which is realized by greedy algorithm. Group task division introduces a group structure, and a group represents a collection composed of one or more computing units in a synchronous data flow graph. Initially, each computing unit in the synchronous data flow graph is treated as a group, and the dependencies between groups are consistent with those between computing units. Group task division mainly consists of four stages:

(1.1.1) Preprocessing stage. This stage is designed for the multi-input and multi-output of computing units in the synchronous data flow graph. In this stage, multiple computing units are fused into a group, which reduces the number of communication edges between a single computing unit in a group and computing units in other groups.

(1.1.2) Group coarse-grained stage. In this stage, the preprocessed group graph is coarsened, and multiple adjacent groups are merged into one. When coarse-grained, loops in the group graph should be avoided. The income generated by the fusion of a pair of groups is called the coarsening income, and the calculation formula is as follows:

$\mathrm{<span\; class="notranslate">\; gain</span>}<span\; class="notranslate">\; =</span>\frac{\mathrm{<span\; class="notranslate">\; comm</span>}<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; SrcGroup</span>}<span\; class="notranslate">\; )</span>}{\mathrm{<span\; class="notranslate">\; workload</span>}<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; srcGroup</span>}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; workload</span>}<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; snkGroup</span>}<span\; class="notranslate">\; )</span>}$

Among them, workload(srcGroup) and workload(snkGroup) represent the respective loads of srcGroup and snkGroup, comm(srcGroup, snkGroup) represents the communication overhead between srcGroup and snkGroup, and the communication overhead includes two aspects of data sending and data receiving.

Coarse-grainedness adopts the greedy heuristic idea, first calculates the coarsening income of all adjacent groups and saves the result in a priority queue, selects a pair of groups with the highest income from the priority queue for fusion, if the load of the new group formed after fusion If it is not greater than the theoretical average value of the divided load and there will be no loops in the group graph after fusion, then the fusion is valid. The group that has been effectively fused will be deleted from the group graph, and the new group obtained by fusion will be inserted into the graph. Update the dependencies between groups, update the revenue in the priority queue according to the new group, and iterate the above process repeatedly. The termination condition of the algorithm is that the fusion between any pair of groups will not produce positive returns or the number of groups in the group graph is less than the threshold.

(1.1.3) Initial division stage. At this stage, the preliminary decision is made on the mapping between the group and the cluster nodes in the group graph after coarsening. The initial division is to balance the load of each division and minimize the communication between divisions as much as possible. The initial division adopts the strategy of preventing deadlock, and avoids loops in the division results at the beginning of the division. The coarse-grained group graph is a directed acyclic graph (Directed Acyclic Graph, DAG). For DAG graph topology sorting, a topological sequence can be obtained by using the partial order relationship between the nodes in the graph. In the initial division, the group graph is examined one by one according to the group topology sequence. In the group node, determine the specific division number of each group.

(1.1.4) Fine-grained adjustment stage. In this stage, the divided boundary computing unit, that is, the computing unit that communicates with computing units on other cluster nodes, is further optimized according to the communication situation to reduce node communication overhead. For a boundary computing unit, the partition set where the computing unit is located is called the source partition (srcPartition), and the partition where the computing unit that has a dependency relationship with the computing unit is called the target partition (objPartition). A computing unit has only one srcPartition and There may be multiple objPartitions, the communication volume between the computing unit and other computing units in the srcPartition is internalData, the communication traffic between the computing unit and the computing unit in the i-th objPartition is externalData[i], and a priority queue is maintained during fine-grained adjustments , whose weight is externalData[i]–internalData. In the adjustment process, the one with the largest weight is selected for processing. Whether a computing unit can be moved to an objPartition depends on the following two factors: first, it will not introduce loops in the partition; second, it will not destroy to a certain extent Load balancing across partitions. After a computing unit is adjusted, the priority queue should be updated according to the adjusted result, but the adjusted computing unit will no longer be used as an adjustment object.

(1.2) Thread-level task division. Thread-level task division needs to determine the mapping between the internal processing core of the cluster node and the computing unit on the node. The task execution in the node adopts the synchronous pipeline scheduling method, and the thread-level task division adopts the allocation strategy with the goal of load balancing and minimizing synchronization overhead. The main considerations for partitioning between threads are load balancing and locality. The thread-level task division steps are as follows: firstly, the computing units inside each cluster node are initially divided using the multi-layer K-path graph division algorithm; secondly, the computing units with heavy loads are split using the replication splitting algorithm to reduce the granularity of the computing units , as shown in Figure 2, describes the flow chart of the data flow program replicating the splitting algorithm inside the multi-core cluster nodes. The steps of this algorithm are as follows: the results of the K-road graph partitioning algorithm in the above stages are used as input, and the calculation load of each division is calculated in turn, sorted according to the load, and the division number with the largest load that can be split actor (a basic calculation unit) is found MaxPartition and workload maxWright, then find the partition number MinPartition with the smallest load and workload minWeight, and then judge according to the result of the inequality maxWeight<minWeight*balanceFactor (balanceFactor is the balance factor). If the result is true, the algorithm ends. If the result is If false, continue to find the splittable actor with the largest workload in MaxPartition, calculate the split score repFactor of the actor, repFactor=Max(repFactor, 2), then split the actor horizontally into repFactor parts, and put one part in MinPartition, The remaining repFactor-1 is placed in MaxPartition, remove the split actors from MaxPartition, and then return to the beginning of the program (find and sort the calculation load of each partition), and execute in a loop until the algorithm meets the exit conditions and exits; Finally, the multi-layer K-path graph partition algorithm is used again to partition the split graph to ensure load balance and good locality on the processing core.

(2) According to the task division and scheduling results, construct the hierarchical pipeline scheduling steps of pipeline scheduling between cluster nodes and cluster node cores

This step mainly determines the pipeline execution process of the tasks divided by the process level and the thread level according to the task division result of step (1), so that the program execution delay is as small as possible. It includes two steps: asynchronous pipeline scheduling between cluster nodes and synchronous software pipeline scheduling between internal cores of cluster nodes. The synchronous pipeline utilizes a global synchronous clock to ensure that the execution tasks on each stage of the pipeline are completed at the same time, and each execution stage has an equal execution delay. The subtasks of the asynchronous software pipeline are executed in a data-driven manner. When the data generated by the execution of a subtask is sent to another subtask that has a dependency relationship with it, the subtask can receive the data when other conditions are met. Start execution, the execution of the entire pipeline in the asynchronous pipeline does not require global synchronization, and the calculation and communication are separated. In order to balance the calculation time and data transmission time, the data transmission between asynchronous pipeline subtasks usually adopts the block transmission mechanism. As long as the communication buffer between tasks is filled, the message transmission can be triggered, and the data can be transmitted without waiting for the execution of the current stage of the subtask. . Specific steps are as follows

(2.1) Asynchronous pipeline scheduling between cluster nodes

Process-level division not only assigns subtasks to nodes, but also determines the dependencies between subtasks. Asynchronous pipeline scheduling does not have a global synchronous clock, the execution of subtasks meets the characteristics of data-driven, and the execution of subtasks conforms to the producer-consumer mode. As shown in Figure 3, a schematic diagram of the execution of the corresponding data flow program on a cluster composed of 3 machines is described. In the figure, there are 3 multi-core machines corresponding to the compiler, which divides the data flow program into three subtasks I, II and III through process-level task division. The execution of actors in the machine is related to the parallel architecture and scheduling method inside the machine. On the shared storage multi-core platform, synchronous pipeline scheduling is adopted inside the node. In order to amortize the overhead of unit data volume in the transmission of the asynchronous pipeline between nodes, the data flow program adopts a block communication method between nodes. When the producer fills up the communication block, the message delivery mechanism is triggered, and the consumer starts to execute after receiving the message. Taking I and II in Figure 3 as an example, when actor C executes for a period of time, the communication buffer between actor C and actor F is filled, C sends data to F, F starts to execute after receiving the data generated by C, and at the same time C can continue to generate new data. Guarantee the execution of data flow programs on the cluster through asynchronous pipeline execution.

(2.2) Internal synchronous pipeline scheduling of cluster nodes

Thread-level synchronous pipeline scheduling includes two steps: stage allocation and pipeline scheduling table construction. After the thread-level task division is completed, stage assignment is performed to build a synchronous software pipeline. Specific steps are as follows

(2.2.1) Phase Allocation. First, perform topological sorting on the computing nodes in the data flow graph inside the cluster nodes to form a topological sequence; secondly, initialize the stage number of each computing node in the topological sequence to 0, and then judge whether it is consistent with Whether the predecessor node is on the same cluster node, if it is on the same cluster node, judge whether it is on the same processing core as the predecessor node, if it is on the same processing core, then it is at the same stage as the predecessor node, If it is not on the same processing core, its phase number is 1 greater than the phase number of the predecessor computing node. If it is not on the same cluster node, its phase number has nothing to do with the predecessor computing node. By traversing the topology sequence of computing nodes, Assign phase numbers to all nodes

(2.2.2) Construction pipeline scheduling. The results of task division and stage allocation are used to construct a synchronous pipeline schedule. As shown in FIG. 4 , the abscissa represents resources including processing cores, and the ordinate represents stage numbers. As shown in Figure 4(a), P, Q, and S are allocated to the same core Core0, R, T are allocated to the same core Core1, and U, V are allocated to the same core Core2. P is the initial node, the phase number is 0, Q and its parent node P are in the same core, so its phase number is also 0; the phase number of R is 1, the phase number of S is 2, the phase number of T is 3, U, V The phase number is 4. As shown in Figure 4(b), during the execution of the software pipeline, it has experienced the filling phase, full phase and emptying phase of the software pipeline.

(3) according to the structural characteristics of the multi-core processor, the communication situation between the cluster nodes and the execution situation of the data flow program on the multi-core processor, the cache optimization step is performed

Since multiple threads share the cached data, the cache uses the cache line as the storage unit. When multiple threads modify independent variables and these variables share the same cache line, there is false sharing (False Sharing), which affects the performance of program execution. . This step is mainly optimized from two aspects for file sharing with cache access:

(3.1) Cache line filling eliminates the false sharing caused by the synchronization of the pipeline stage. Through the line filling mechanism, variables of different threads will not share the same cache line, eliminating false sharing.

(3.2) The steady-state expansion technology is used to eliminate the false sharing caused by data transmission between computing units. As shown in Figure 5(a), if P and C are executed in parallel on different cores in the producer-consumer chain, false sharing will also occur when the space accessed by P and C is on the same cache line, as shown in Figure 5( b) as shown. There will be multiple inter-core communication edges in a complex data flow graph. If the cache line filling mechanism is still used, a lot of space will be wasted, storage utilization will be reduced, and high communication delay will be generated. In order to eliminate the false sharing of the communication buffer and improve the utilization rate of the cache as much as possible, a steady-state expansion technology is adopted. Figure 5(c) shows the usage of cache after eliminating false sharing. The steady-state expansion technology algorithm adopts the greedy idea. First, calculate the coefficients that the relevant computing units should expand after the data flow program is executed in a steady state once all output edges are eliminated. The maximum coefficient that will never cause the L1 data cache to overflow is used as the final expansion coefficient. In order to make the cache more effective, it is not necessary to ensure that all computing units execute without data cache overflow when looking for expansion coefficients. According to the "90/10 principle", 10% of computing units are allowed to overflow when executing The L1 data cache does not overflow the L2/L3 cache, which can also achieve better performance.

It is easy for those skilled in the art to understand that the above descriptions are only preferred embodiments of the present invention, and are not intended to limit the present invention. Any modifications, equivalent replacements and improvements made within the spirit and principles of the present invention, All should be included within the protection scope of the present invention.

Claims (9)

1. A data flow compilation optimization method for multi-core clusters, characterized in that, comprising the following steps: Determine computing tasks and multi-core cluster computing nodes and process task division and scheduling steps for core mapping; According to the task division and scheduling results, the hierarchical pipeline scheduling steps of pipeline scheduling between cluster nodes and cluster node cores are constructed; The caching optimization step is performed according to the structural characteristics of the multi-core processor, the communication situation among the cluster nodes and the execution situation of the data flow program on the multi-core processor. 2. The multi-core cluster-oriented data stream compilation and optimization method according to claim 1, wherein the task division and scheduling steps are specifically: First, divide the synchronous data flow graph into process-level tasks, and determine the corresponding cluster nodes assigned to each computing task; Secondly, the tasks in the synchronous data flow graph in the cluster nodes are divided into thread-level tasks, and the corresponding processing cores in the cluster nodes assigned to each computing task are determined. 3. The multi-core cluster-oriented data flow compilation and optimization method according to claim 2, wherein the task division is converted into a graph division problem, and according to the difference between process-level and thread-level task division objectives, respectively It is obtained by solving it by using the Group division strategy and the replication split strategy. 4. The multi-core cluster-oriented data flow compilation and optimization method according to claim 3, wherein the process-level task division adopts the Group division strategy step as follows: In the preprocessing stage, multiple computing units are fused into a group, which reduces the number of communication edges between a single computing unit in a group and computing units in other groups; In the coarse-grained stage, multiple adjacent groups are merged into one; In the initial division stage, the group is mapped to the cluster computing nodes, and the mapping between the computing nodes and the cluster nodes is determined at the same time; In the fine-grained adjustment stage, the boundary nodes on each division after the initial division are optimized to reduce communication overhead. 5. The multi-core cluster-oriented data flow compilation and optimization method according to any one of claims 2 to 4, wherein the step of dividing the thread-level tasks is specifically: First, use the multi-layer K-path graph partition algorithm to initially partition the computing units inside each cluster node; Secondly, use the copy splitting algorithm to split the computing unit with heavy load to reduce the granularity of the computing unit; Finally, the multi-layer K-path graph partition algorithm is used again to partition the split graph to ensure load balance and good locality on the processing core. 6. The multi-core cluster-oriented data flow compilation optimization method according to any one of claims 1 to 5, wherein the hierarchical pipeline scheduling step is specifically: First, asynchronous pipeline scheduling is adopted between cluster nodes. Second, synchronous pipeline scheduling is adopted within the cluster nodes. 7. The multi-core cluster-oriented data flow compilation and optimization method according to claim 6, wherein the asynchronous pipeline scheduling method is to use the producer and consumer model to randomly assign the results of the process level division to on each node of the cluster. 8. according to claim 6 or 7 described oriented multi-core cluster data stream compilation optimization method, it is characterized in that, the specific process of the synchronous pipeline scheduling that is carried out is as follows: First, topologically sort the computing nodes in the data flow graph inside the process to form a topological sequence; Secondly, for each computing node in the topology sequence, initialize its node phase number to 0, and then judge whether it is on the same cluster node as the predecessor node, and if it is on the same cluster node, judge whether it is on the same cluster node as Whether the node is on the same processing core, if it is on the same processing core, then it has the same stage as the predecessor node, if it is not on the same processing core, then its stage number is 1 greater than the stage number of the predecessor node, if If they are not on the same cluster node, then its phase number has nothing to do with the predecessor node. By traversing the topological sequence of computing nodes, assign phase numbers to all nodes, and construct a synchronous pipeline scheduling table inside the cluster node. 9. The multi-core cluster-oriented data stream compilation and optimization method according to any one of claims 6 to 8, wherein the specific process of performing cache optimization is: First, the cache line filling mechanism is used to eliminate the false sharing caused by the synchronization between the stages of the synchronous software pipeline in the cluster nodes; Secondly, the steady-state expansion technology is used to eliminate the false sharing caused by the data transmission of computing units.