Multi-target scheduling optimization method and system based on synchronous data flow diagram

Abstract

The invention discloses a multi-target scheduling optimization method and system based on a synchronous data flow diagram, and belongs to the technical field of edge computing. In order to solve the problem of unreasonable allocation of computing and communication resources caused by limited server resources in an edge computing environment, the method mainly adopts an optimized unloading algorithm, combines a synchronous data flow graph model, comprehensively considers a resource competition relationship between a local and a server side, dynamically updates node scheduling information and a token state of an edge, and improves the resource allocation efficiency. And generating a scheduling sequence and a delay result. According to the invention, efficient allocation of computing and communication resources can be realized under the condition that the resources are limited, and the application execution performance is effectively improved.

Description

Technical Field

[0001] The present invention belongs to the technical field of edge computing, and particularly relates to a multi-objective scheduling optimization method and system based on a synchronous data flow graph. Background Art

[0002] In a Synchronous Data Flow Graph (SDFG), nodes represent computing tasks and are annotated with the execution time of the tasks; edges represent the data dependency relationships between tasks and serve as first-in-first-out channels, marked with the production and consumption rates (sampling rates) of the data. The number of executions of a node in an SDFG within an iteration period is determined by a repetition vector, and its execution dependency relationship is determined by an equivalent homogeneous synchronous data flow graph (HSDFG).

[0003] In the target scheduling problem based on SDFG, an edge computing platform is involved. This platform includes local mobile devices and edge servers, constituting a heterogeneous multi-processor architecture, where the time consumed for communication between processors cannot be ignored. Each processor consists of multiple homogeneous processing units, and the communication costs between different processors and their internal processing units are different, and there are also energy consumption differences. For example, there are differences in execution time and energy consumption between local devices and servers, and data transmission also consumes time and energy.

[0004] Scheduling involves offloading and task scheduling. The offloading strategy refers to allocating SDFG nodes to local devices or edge servers for execution, and task scheduling is used to determine the execution order and time of each node on the processor. A legal schedule needs to satisfy the data dependency relationships of SDFG nodes, processor constraints (non-preemptive), and communication bandwidth limitations. The scheduling length of the SDFG determines the response time of the corresponding application, and different scheduling strategies will affect the overall energy consumption.

[0005] Currently, Glanon et al. proposed a heuristic scheduling algorithm for heterogeneous multi-processor SDFG to achieve the optimal response time. This algorithm first converts the SDFG into an HSDFG, and then applies list scheduling on the HSDFG to arrange the execution order of the nodes. This method to some extent utilizes the characteristics of the HSDFG to simplify the scheduling process, but the conversion process may introduce a large computational overhead, resulting in a large time consumption. Compared with the original SDFG, the converted HSDFG may contain significantly more nodes and edges, especially in complex SDFGs. In addition, this method assumes that communication resources are not restricted, and when dealing with data dependencies and communication between nodes, it can consider the communication delays between different processors.

[0006] Sun et al. proposed a hoptO based on genetic algorithmp A heuristic method is used to solve the optimal computing offloading problem of HSDFG in the mobile edge computing environment. This method encodes the offloading strategy as a chromosome and uses the iterative process of the genetic algorithm to search for the optimal solution, and to a certain extent, a better offloading strategy can be obtained. However, the existing methods do not fully consider the problem of limited communication resources in the edge computing environment when designed. In the edge computing architecture, the communication resources between devices are limited, and the communication delay has a significant impact on the overall performance. Existing scheduling algorithms usually assume infinite communication resources when formulating strategies, or do not deeply consider the impact of communication constraints on the scheduling results. Summary of the Invention

[0007] The object of the present invention is to propose a multi-objective scheduling optimization method and system based on synchronous data flow graph. Aiming at the problem of limited server resources in the edge computing environment, an optimized offloading algorithm is adopted and the resource competition between the local and the server side is comprehensively considered to ensure the reasonable allocation of computing and communication resources under limited conditions and effectively improve the application performance.

[0008] To achieve the above object, the technical solution adopted by the present invention is as follows:

[0009] A multi-objective scheduling optimization method based on synchronous data flow graph, comprising the following steps:

[0010] 1) Based on the topological structure of SDFG, initialize the scheduling information, the earliest start time of each node, and the token queue of the edges, and add the nodes that meet the conditions to the set of ready nodes according to the ready node conditions;

[0011] 2) If the set of ready nodes is not empty, calculate the scheduling information of the nodes, determine the earliest start time, end time and the allocated processor of the nodes, and add the ready nodes to the scheduling list according to the scheduling information;

[0012] 3) According to the current scheduling information, update the token queue of the edges, and re-determine the nodes that meet the ready conditions and add them to the set of ready nodes;

[0013] 4) If the set of ready nodes is empty, calculate the communication time consumption between iterations for all the scheduled nodes, update the token timestamp, and calculate the final scheduling delay; output the scheduling sequence and the final scheduling delay.

[0014] Further, the scheduling information initialized in step 1) includes: the allocated processor, start time and end time; the token queue of the edges is initialized according to the initial token number of the edges.

[0015] Further, the steps of calculating the scheduling information of the nodes in step 2) include:

[0016] Determine the set of tokens required for node execution and calculate the timestamps of each token;

[0017] Calculate the earliest start time of the node on each processor and determine the time of the latest arriving token as the benchmark;

[0018] Determine the scheduling position of the node and record its earliest start time, end time, and the allocated processor.

[0019] Further, the steps of updating the token queue of the edge in step 3) include: after the node executes, remove the corresponding number of tokens from the token queues of all input edges, and at the same time add new tokens to the token queues of all output edges, and set the timestamp of the token to the end time of the execution of the node.

[0020] Further, the ready node conditions in steps 1) and 3) are: the number of tokens on all input edges of the node is greater than or equal to the consumption rate of the edge, the node has not been scheduled, and the execution order satisfies: if the node is not executed for the first time, the next execution can only be carried out after the previous execution is completed.

[0021] Further, the steps of calculating the communication time consumption between iterations in step 4) include: traversing the token queues of all edges in the SDFG to identify the target execution node corresponding to each token; calculating the communication time consumption based on the data transfer rate between the processing units of the source execution node and the target execution node of the token and the size of the token.

[0022] Further, the steps of calculating the final scheduling delay in step 4) include: calculating the maximum value of the timestamps of all tokens and the end time of each node execution to determine the final scheduling delay.

[0023] Further, step 1) also includes: initializing the energy consumption at the current moment; the calculation method of the energy consumption at the current moment is: traversing all processing units, calculating the working time of each processing unit, and combining its energy consumption per unit time to accumulate the energy consumption in different states to obtain the total energy consumption under the current scheduling;

[0024] Step 2) also includes: introducing a trade-off factor; for each candidate processor, calculate the total energy consumption and end time after executing the node, and compare them with the energy consumption and end time of the currently selected processor; based on the comparison results, comprehensively consider the scheduling objectives to determine the finally executed processor;

[0025] Step 3) also includes: scheduling the node to the selected processor and updating the idle time period of the processor; updating the token counts of all input and output edges of the node and marking the execution status of the node; and simultaneously recalculating the total energy consumption under the current schedule.

[0026] Further, step 1) also includes: initializing a bandwidth vector that records the available time of the communication channels between processors.

[0027] Step 2) also includes: calculating the earliest transmission start time of the token on each processor according to the number of channels between processors and the available time vector between the current processor and the target processor, and calculating the earliest execution time of the node based on this; then, selecting the processor that can make the node start execution earliest according to the earliest execution time and the idle time period of the processor.

[0028] Step 3) also includes: after scheduling the node, updating the bandwidth vector to record the available time of the communication channels between processors; when data transmission is generated during node execution, for each token to be transmitted, determining its target processor and calculating its earliest transmittable time according to the available situation of the channel to ensure that data is transmitted when the channel is idle; when updating the set of ready nodes, ensuring that each node not only meets the ready node conditions, but also ensures that the token can be transmitted to the target processor within the time allowed by the channel.

[0029] A multi-objective scheduling optimization system based on a synchronous data flow graph includes a memory and a processor. The memory is used to store a computer program, and the processor is used to execute the computer program to implement the steps of the above method.

[0030] The beneficial effects achieved by the present invention are as follows:

[0031] 1. The present invention directly performs scheduling on the SDFG, avoiding the computational overhead of converting to HSDFG, improving the scheduling efficiency, and quickly constructing an efficient scheduling scheme by exploring the semantic information of the SDFG, reducing the computational overhead and enhancing the execution speed of the algorithm.

[0032] 2. The present invention records the data dependence relationship through timestamps and arranges the execution of nodes according to the ready condition and the earliest start time principle, optimizing the scheduling strategy and effectively solving the problem of time-consuming conversion in the prior art.

[0033] 3. The present invention introduces a trade-off factor F to balance the earliest completion time and the minimum energy consumption priority principle when selecting processors and time slots, enabling the algorithm to dynamically adjust between optimizing the response time and reducing the energy consumption according to actual needs, overcoming the defect of a single optimization objective, and having good scalability to adapt to different application scenarios and demand changes.

[0034] 4. The present invention comprehensively considers communication constraints, uses vectors to record the available time of the channels between processors, and fully considers the data path availability and transmission time when calculating the earliest start time of the computing nodes, enabling the scheduling scheme to adapt to the limited communication resources in the edge computing environment, avoiding performance degradation caused by communication congestion, and solving the problem that the prior art does not fully consider communication limitations.

[0035] 5. The present invention can formulate a scheduling strategy in combination with the actual situation of the edge computing environment, reasonably allocate computing and communication resources, improve the overall performance of the system, and optimize resource utilization. Brief Description of the Drawings

[0036] Figure 1 is a flowchart of a multi-objective scheduling optimization method based on a synchronous data flow graph proposed in the first embodiment. Detailed Embodiments

[0037] To make the technical features, advantages, or technical effects in the above technical solutions of the present invention more obvious and understandable, the following will be described in detail with reference to the embodiments.

[0038] Embodiment 1

[0039] This embodiment provides a multi-objective scheduling optimization method based on a synchronous data flow graph. This method is an SDFG response time optimal offloading method, and its main process is as Figure 1 shown. The following describes the processing steps of this method.

[0040] 1. Initialize the set of ready nodes:

[0041] In the initialization calculation stage, initialize the information related to the nodes in the system model and the set of ready nodes. A ready node refers to a node that has met the scheduling conditions and can be executed.

[0042] For each node v ∈ V and execution times i ∈ [0, q(v) - 1], perform initialization settings, s(v i ).(pa, st, et) = (null, -1, -1), rT(v i ) = -1. Where s(v i ) represents the scheduling information of the i-th execution of node v, including the allocated processor pa, start time st, and end time et, which are initially set to null values and invalid times; rT(v i ) represents the earliest start time of the i-th execution of node v.

[0043] Initialize the token queue of each edge according to the initial token number of the edge, so that |tq(e)| = d(e), where d(e) is the initial number of tokens on edge e.

[0044] Then, according to the ready node conditions, the nodes that meet the conditions are added to the set of ready nodes. The ready node conditions are that there are sufficient tokens on all incoming edges of the node (i.e., |tq(e)| ≥ cns(e), where cns(e) is the consumption rate of edge e), the node has not been scheduled (fired(v i ) = False), and (if it is not the first execution of the node, the previous execution has been scheduled, i.e., i = 0 ∨ fired(v i-1 ) = True). The node vi that meets these conditions is added to the set of ready nodes, completing the operation of initializing the set of ready nodes and preparing for the subsequent scheduling process.

[0045] 2. Judge the set of ready nodes:

[0046] If the set of ready nodes is not empty, take out a node and proceed to step 3; otherwise, proceed to step 5.

[0047] 3. Calculate the scheduling information of each node and add it to the scheduling list:

[0048] When calculating the node scheduling information, various factors are comprehensively considered to determine the reasonable position and time of each node in the scheduling list, ensuring that the scheduling scheme not only meets the task requirements but also optimizes the system performance. The scheduling information mainly includes the earliest start time, end time of the node on the processor, and the allocated processor. The process of calculating this information needs to be based on the characteristics of the SDFG, the data dependence relationship between nodes, and the status of the processor.

[0049] For each node v in the set i , first determine the set of tokens TK(v i ) it needs. TK(v i ) = {tk|e ∈ I(v) ∧ k ∈ [0, cns(e) - 1] ∧ tk = tq(e)[k]}, where I(v) is the set of incoming edges of the node, cns(e) is the consumption rate of edge e, and tq(e) is the token queue on edge e. Through this set, the data input required for node execution can be clarified.

[0050] Then calculate the earliest start time rT(v i on processor p, and the calculation formula is i , p), and the calculation formula is Here, tk.ts is the timestamp of the token, representing the time when the data is generated; tk.size is the size of the token; t(s(tk.src).pa, p) represents the transmission time from the source processor of the token to the target processor p. This formula comprehensively considers the generation time, size, and transmission time of the data, thereby obtaining the earliest time when the node can start execution on the processor p. When calculating the earliest start time, all tokens in TK(v i ) need to be traversed to find the token that maximizes the value of tk.ts + tk.size × t(s(tk.src).pa, p), and the corresponding value is rT(v i , p). This is because the node v i can only start execution after all required tokens have reached the processor p, so the time of the latest-arriving token should be used as the reference.

[0051] Then, based on the above scheduling information, the ready nodes are added to the scheduling list.

[0052] 4. Update the set of ready nodes:

[0053] According to the current scheduling information, the set of ready nodes is re-determined.

[0054] After completing a scheduling step, the nodes that meet the ready conditions are re-evaluated based on the current scheduling information, thereby updating the set of ready nodes. After each node v i is scheduled, its execution will cause changes in the system state, including the occupancy of the processor, the number and distribution of tokens on the edges, and the execution state of the nodes.

[0055] For all incoming edges e ∈ I(v) of the node v i , cns(e) tokens will be removed from the corresponding token queue tq(e) because these data are consumed during the node execution. For the outgoing edges e ∈ O(v), tq(e) will be updated by adding prd(e) new tokens. The timestamp tk.ts of the new tokens is set to the execution end time of the node v i , and the source identifier tk.src is set to v i to reflect the generation and flow of the data. After these operations are completed, it is re-determined whether the node is ready based on the ready conditions. The ready conditions are that is, there are enough tokens on all incoming edges of the node, the node has not been scheduled, and (if it is not the first execution of the node, the previous execution has been scheduled). The nodes that meet these conditions will be added to the set of ready nodes.

[0056] When updating the ready node set, first traverse all nodes. For each node v, check whether the number of tokens in the token queues tq(e) of all its incoming edges satisfies |tq(e)|≥cns(e). If not, the node does not meet the ready condition. If it does, continue to check the node's scheduling status fired(v i ) is False, and (if this is not the first execution of the node) the previous execution of v i-1 The dispatch status fired(v i-1 ) is True. For nodes that meet all the ready conditions, they are added to the ready node set; for nodes that do not meet the conditions, they are kept in the original set and wait for the next round of update judgment. As the scheduling process continues to advance, the ready node set will change dynamically, providing qualified nodes for subsequent scheduling steps to ensure the orderly progress of the entire scheduling process.

[0057] 5. Dealing with communication time and computing delays:

[0058] After all nodes have executed the scheduling, the communication time between iterations is processed, the final scheduling sequence is determined, and the final scheduling delay is calculated. After all nodes have executed the scheduling, the token queue tq(e) of each edge in the SDFG is processed. For each token tk in the final tq(e), it is necessary to clarify its corresponding consumption node execution (target execution), which is represented by tk.snk. The specific execution is determined by the order of tk in tq(e) and the consumption rate cns(e) of edge e. The timestamp on the token is updated according to the processing unit allocation of the source execution and target execution of the token. The calculation formula is tk.ts=tk.ts+tk.size×t(s(tk.src).pa,s(tk.snk).pa), where tk.size is the size of the token, and t(s(tk.src).pa,s(tk.snk).pa) represents the transmission time from the processing unit where the source execution of the token is located to the processing unit where the target execution is located.

[0059] After completing the timestamp update of all tokens, the formula ls = max tk∈tq(e),e∈E,v∈V {tk.ts,s(v i ).et} to calculate the final scheduling delay. This formula takes into account the timestamps of all tokens and the end time of all node executions, where s(v i ).et is the end time of the i-th execution of node v. Taking the maximum value of these times as the final scheduling delay can ensure that all node executions and data transmissions have been completed, thereby obtaining the total time consumption of the entire scheduling scheme.

[0060] Finally, output the core information of the generated scheduling scheme, i.e., the scheduling sequence and the delay time, to provide key data support for subsequent system performance evaluation, task execution planning, and further optimization.

[0061] Embodiment 2

[0062] This embodiment proposes another multi-objective scheduling optimization method based on synchronous data flow graph. This method is an SDFG response time and energy consumption comprehensive optimal offloading method, which considers the energy consumption problem on the basis of the method proposed in Embodiment 1. The following mainly elaborates on the differences of this method.

[0063] 1. Initialize the set of ready nodes:

[0064] On the basis of step 1 in Embodiment 1, further define the energy consumption ec at the current moment. The calculation formula is: Where is the time when the processing unit p is in the working state, and ls is the current scheduling length. At the end of the scheduling, ec = EC(M, s), where EC(M, s) is the energy consumption of the system M under the scheduling s.

[0065] 2. Judge the set of ready nodes: The same as step 2 in Embodiment 1.

[0066] 3. Calculate the scheduling information of each node and add it to the scheduling list:

[0067] On the basis of step 3 in Embodiment 1, in order to comprehensively consider energy consumption and response time, introduce a trade-off factor F ∈ [0, 1] to control the trade-off relationship between the two. The energy consumption weight increases with the increase of F.

[0068] During the scheduling process, for each node v in the set of ready nodes i , the method of calculating its earliest start time rT(v i , p) on each processor p is the same as step 3 in Embodiment 1. However, when selecting a processor, it no longer only depends on the earliest finish time first (EFF) principle, but comprehensively considers two rules, i.e., EFF and minimum energy consumption first (MECF), and adds the trade-off factor F.

[0069] When selecting a processor for node v i , calculate the energy consumption and finish time when using different processors p. Define the energy consumption at the current moment Where is the time when the processing unit p is in the working state, and ls is the current scheduling length. For each candidate processor p, calculate the execution of node v iThe subsequent energy consumption eE′ and end time eT′ are compared with the energy consumption eE and end time eT of the currently selected processor pa. When (1 - F)·eT + F·eE > (1 - F)·eT′ + F·eE′, the processor p is selected as the execution processor for node v i That is, pa = p, sT = sT′, eT = eT′, eE = eE′.

[0070] When F = 0, the algorithm selects the processor only according to the earliest end time first (EFF) principle, that is, only focuses on the response time, selects the processor that can complete the execution of the node as soon as possible, and does not consider the energy consumption factor; when F = 1, the algorithm selects the processor only according to the minimum energy consumption first (MECF) principle, only considers the energy consumption, and selects the processor with the lowest energy consumption for executing this node, without considering the response time; when F ∈ (0, 1), the algorithm considers both the energy consumption factor and the response time, and balances the influence of the two through the above comparison formula.

[0071] 4. Update the ready node set:

[0072] After determining the execution processor pa of node v i , schedule node v i to this processor and update the relevant information. Update the idle time period pT(pa) of processor pa, remove the used idle time period from pT(pa), and add a new idle time period (if any). For all incoming edges e ∈ I(v) of node v i , remove cns(e) tokens from tq(e); for all outgoing edges e ∈ O(v), update tq(e), add prd(e) new tokens, set the timestamp of the new tokens to the execution end time of node v i , set the source identifier to v i , and at the same time mark fired(v i ) = True. Then update the value of the energy consumption ec, and recalculate the energy consumption of the current system according to the energy consumption calculation formula where uT(p) is the time when the processing unit p is in the working state, which will be continuously updated as the nodes are scheduled.

[0073] 5. Process the communication time consumption and calculation delay: The same as step 5 of Embodiment 1.

[0074] Embodiment 3

[0075] This embodiment proposes another multi-objective scheduling optimization method based on the synchronous data flow graph. This method is an SDFG offloading method considering communication constraints, which considers communication constraints on the basis of the method proposed in Embodiment 1. The following mainly elaborates on the differences of this method.

[0076] 1. Initialize the ready node set:

[0077] Based on step 1 of the first embodiment, a broadband vector cT is introduced to record the available time of the channels between processors. cT is a two-dimensional vector, and cT(p1, p2)[k] represents the available time of the k-th channel from processor p1 to processor p2. During initialization, the available time of all channels is initialized to 0.

[0078] 2. Judge the ready node set: The same as step 2 of the first embodiment.

[0079] 3. Calculate the scheduling information of each node and add it to the scheduling list:

[0080] Based on step 3 of the first embodiment, communication constraints are considered.

[0081] For token tk and its target processor p for transmission, its earliest transmission start time is tsT(tk, p) = min k∈{0,...,CN-1} {max{tk.ts, cT(s(tk.src).pa, p)[k]}}, where CN is the number of channels between processors, and cT(s(tk.src).pa, p) is the available time vector of the channel between processors s(tk.src).pa and p.

[0082] At the same time, adjust the actual earliest start time of v i to When selecting a processor, it is necessary to select the processor that can make the node start execution earliest according to the calculation result of rT c (v i , p), combined with the idle time period of the processor. Suppose there are processors p1 and p2. For node v i , calculate rT c (v i , p1) and rT c (v i , p2). If rT c (v i , p1) < rT c (v i , p2), and the idle time period of processor p1 can accommodate the execution of node v i , then give priority to selecting processor p1.

[0083] 4. Update the ready node set:

[0084] In the algorithm considering communication constraints, the bandwidth vector cT is used to record the available time of the channels between processors, and it plays a key role when updating the ready node set. When scheduling node v iAfter that, it is necessary to traverse the bandwidth vector cT to update relevant information.

[0085] When node v i executes and causes data transmission, for each token tk that needs to be transmitted, with the target processor for its transmission being p, the earliest transmission start time is calculated according to the formula where CN is the number of channels between processors, and cT(s(tk.src).pa,p) is the available time vector of the channel between processors s(tk.src).pa and p. This formula combines the generation time tk.ts of the token and the available time cT(s(tk.src).pa,p)[k] of the channel to ensure that the token can start transmission only when the channel is available.

[0086] When updating the set of ready nodes, if for node v j the transmission of a token on an incoming edge e depends on a previously scheduled node v i , then when determining whether v j is ready, in addition to checking the number of tokens in tq(e), it is also necessary to determine according to the cT vector whether these tokens can be transmitted to the processor where v j is located within a satisfactory time. If the token cannot be transmitted in time, even if |tq(e)| ≥ cns(e), v j does not meet the ready condition. Suppose node v i transmits a token to node v j , and processors p1 and p2 are the processors where v i and v j are located respectively, and the cT(p1,p2) vector records the available time of the channel between the two processors. If cT(p1,p2) shows that a certain channel is unavailable for a period of time after the token is generated, resulting in the token not being able to reach v j on time, then v j cannot be determined as a ready node.

[0087] 5. Handling communication time consumption and calculation delay: The same as step 5 of Embodiment 1.

[0088] Experimental tests

[0089] For the experimental part of the present invention, examples from StreamIt, SDF3, and Ptolemy were selected for testing. The experimental platform is a server running the Linux system, with a configuration including a 3.10 GHz CPU and 768 GB of memory. The experimental results are shown in Table 1 below, where the execution time unit is milliseconds (ms).

[0090] Table 1 Comparison results of HPSS and HCS

[0091]

[0092] Table 1 shows the comparison results between the present invention and the existing heterogeneous multi-level processor scheduling algorithm HCS: In terms of scheduling accuracy, the performances of the two are similar, with the optimal response time on 4-core (np = 4) and 16-core (np = 16) instances being improved by 0.1% and reduced by 1.3% on average respectively; while in terms of operating efficiency, the present invention is significantly superior to the HCS algorithm, and the average operating speed of HPSS on np = 4 and np = 16 instances reaches 27 times and 17 times that of HCS respectively.

[0093] Although the present invention has been disclosed above by way of examples, it is not intended to limit the present invention. Any appropriate modifications or equivalent replacements made by those of ordinary skill in the art to the technical solutions of the present invention shall be covered within the protection scope of the present invention, and the protection scope of the present invention shall be subject to what is defined by the claims.

Claims

1. A multi-objective scheduling optimization method based on synchronous data flow graphs, characterized in that It includes the following steps: 1) Based on the topological structure of the SDFG, initialize the scheduling information, the earliest start time of each node, and the token queue of the edges, and add the nodes that meet the conditions to the set of ready nodes according to the ready node conditions; 2) If the set of ready nodes is not empty, calculate the scheduling information of the nodes, determine the earliest start time, end time, and the allocated processor of the nodes, and add the ready nodes to the scheduling list according to the scheduling information; 3) According to the current scheduling information, update the token queue of the edges, and re-determine the nodes that meet the ready conditions and add them to the set of ready nodes; 4) If the set of ready nodes is empty, calculate the communication time consumption between iterations for all scheduled nodes, update the token timestamps, and calculate the final scheduling delay; Output the scheduling sequence and the final scheduling delay.

2. The method according to claim 1, wherein The scheduling information initialized in step 1) includes: the allocated processor, the start time, and the end time; initialize the token queue of the edges according to the initial token quantity of the edges.

3. The method according to claim 1, characterized in that The steps for calculating the scheduling information of the nodes in step 2) include: Determine the set of tokens required for node execution and calculate the timestamps of each token; Calculate the earliest start time of the node on each processor and determine the time of the latest arriving token as the benchmark; Determine the scheduling position of the node and record its earliest start time, end time, and the allocated processor.

4. The method according to claim 1, wherein The steps for updating the token queue of the edges in step 3) include: when the node executes, remove the corresponding number of tokens from the token queues of all input edges, and at the same time add new tokens to the token queues of all output edges, and set the timestamp of the token to the execution end time of the node.

5. The method according to claim 1, characterized in that, The ready node conditions in steps 1) and 3) are: the number of tokens on all input edges of the node is greater than or equal to the consumption rate of the edge, the node has not been scheduled, and the execution order meets: if the node is not executed for the first time, the next execution can only be carried out after the previous execution is completed.

6. The method according to claim 1, characterized in that, The steps for calculating the communication time consumption between iterations in step 4) include: traverse the token queues of all edges in the SDFG to clarify the target execution node corresponding to each token; calculate the communication time consumption according to the data transfer rate between the processing units of the source execution node and the target execution node of the token and the size of the token.

7. The method according to claim 1, wherein The steps for calculating the final scheduling delay in step 4) include: calculate the maximum value of the timestamps of all tokens and the end time of each node execution to determine the final scheduling delay.

8. The method according to claim 1, wherein Step 1) also includes: initialize the energy consumption at the current moment; the calculation method of the energy consumption at the current moment is: traverse all processing units, calculate the working time of each processing unit, and combine its energy consumption per unit time to accumulate the energy consumption in different states to obtain the total energy consumption under the current scheduling; Step 2) further includes: introducing a trade-off factor; for each candidate processor, calculating the total energy consumption and end time after executing the node, and comparing them with the energy consumption and end time of the currently selected processor; according to the comparison results, comprehensively considering the scheduling objectives, determining the finally executed processor; Step 3) further includes: scheduling the node to the selected processor, and updating the idle time period of the processor; updating the token numbers of all input and output edges of the node, and marking the execution status of the node; at the same time, recalculating the total energy consumption under the current scheduling.

9. The method according to claim 8, wherein Step 1) further includes: initializing a bandwidth vector, which records the available time of the communication channels between processors; Step 2) further includes: according to the number of channels between processors and the available time vector between the current processor and the target processor, calculating the earliest transmission start time of the token on each processor, and calculating the earliest execution time of the node based on this; then, according to the earliest execution time and the idle time period of the processor, selecting the processor that can make the node start execution earliest; Step 3) further includes: after scheduling the node, updating the bandwidth vector to record the available time of the communication channels between processors; when data transmission is generated during the execution of the node, for each token to be transmitted, determining its target processor, and calculating its earliest transmissible time according to the available situation of the channel to ensure that data is transmitted when the channel is idle; when updating the set of ready nodes, ensuring that each node not only meets the ready node conditions, but also ensures that the token can be transmitted to the target processor within the time allowed by the channel.

10. A multi-objective scheduling optimization system based on synchronous data flow graphs, characterized in that, It includes a memory and a processor, the memory is used for storing a computer program, and the processor is used for executing the computer program to implement the steps of the method according to any one of claims 1-9.

Images