NeuroSchedule: A Novel Effective GNN-based Scheduling Method for High-level Synthesis
Anonymous Author(s)
AffiliationAddress email
Abstract
High-level synthesis (HLS) is widely used for transferring behavior-level specifications into circuit-level implementations.
As a critical step in HLS, schedulingarranges the execution order of operations for enhanced performance.
However,existing scheduling methods suffer from either exponential runtime or poor qualityof solutions.
This paper proposes NeuroSchedule, an efficient and effective GNN-based scheduling method called NeuroSchedule, with both fast runtime and enhanced solutionquality.
Major features are as follows: (1) The learning problem for HLS scheduling is formulated for the first time, and a new machine learning framework isproposed.
(2) Pre-training models are adopted to further enhance the scalabilityfor various scheduling problems with different settings.
Experimental results showthat NeuroSchedule obtains near-optimal solutions while achieving more than50,000 × improvement in runtime compared with the ILP-based scheduling method.
At the same time, NeuroSchedule improves the scheduling results by 6.10% onaverage compared with state-of-the-art entropy-directed method.
To the best of ourknowledge, this is the first GNN-based scheduling method for HLS.
Introduction
Recently, FPGA has been playing an important role in accelerating computations from the cloud tothe edge [1, 2, 3, 4, 5].
As a reconfigurable computing device, FPGA gains increasing popularityfor its high performance and great energy efficiency.
However, developers are required to writeprograms using the hardware description language (HDL) to implement applications in FPGAs,which is time-consuming and error-prone.
Therefore, the utilization of FPGA’s enormous computingpower is limited by the cumbersome developing process.
As a result the concept of high-level synthesis (HLS) is proposed in the EDA community to speed upthe developing process [6, 7, 8].
HLS automatically transfers high-level specifications (written in highlevel languages like C/C++) to behavior-level implementations (written in HDLs like Verilog/VHDL).
Figure 1 presents the whole flow of HLS.
As shown in the figure, HLS mainly comprises three parts:compilation, synthesis, and generation.
For compilation, high-level languages are transferred to
Control Data Flow Graphs (CDFGs) with the assistance of modern compilers like GCC or LLVM.
During the synthesis process, hardware resources (e.g. functional units, storage, and wires) are firstallocated.
According to the allocated hardware resources, the operations in CDFG (such as ADD and
MUL) are scheduled to certain time steps.
After scheduling, the allocated hardware resources arebound to corresponding operations and time steps.
After synthesis, the generation process generatescorresponding HDLs according to the synthesized results.
Scheduling is one of the most critical stages in the HLS process, which arranges the executionorder of operations, and thus determines the performance of generated circuits.
As depicted in int a0, m1, a2, a3, m4, a5; a0 = x0 + x1; m1 = x2 * x3; a2 = x4 + x5; a3 = a0 + m1; m4 = m1 * a2; a5 = a0 + a3;
High-level language code int a0, m1, a2, a3, m4, a5; a0 = x0 + x1; m1 = x2 * x3; a2 = x4 + x5; a3 = a0 + m1; m4 = m1 * a2; a5 = a0 + a3;
High-level language code
Synthesis
Allocation
[Figure]
Allocation
[Figure]
Binding
[Figure]
Binding
[Figure]
Storage
Connectivity
[Figure]
Hardware Library
Scheduling
[Figure] [Figure]
[Figure] [Figure]
[Figure] [Figure]
Scheduling
[Figure]
Compilation
[Figure]
Optimization
[Figure]
Compilation
[Figure]
Optimization
[Figure]
Generation
[Figure]
Generation
Figure 1, according to the allocated hardware resources and the dependencies between operations, theoperations in CDFG are arranged in different time steps.
For example, during the scheduling process,operation ADD0 is scheduled to step 0 and bound to the adder.
It is noteworthy that only one adderis allocated to the scheduling task.
So operation ADD2 could not be scheduled to step 0 same asoperation ADD0.
Therefore, determining the scheduling priority for the operations is the key objectiveof the scheduling problem.
However, the scheduling problem has been proved to be NP-hard [9].
And existing algorithms suffer from either unbearable long runtime or poor quality of solutions.
Integer linear programming (ILP) formulation has been proposed to solve the scheduling problemoptimally [10].
However, the exponential runtime of ILP is unbearable.
Therefore, various heuristicalgorithms are proposed to obtain sub-optimal solutions within acceptable runtime.
List scheduling isone of the most famous heuristic algorithms [11].
List scheduling stores ready operations in a listand arranges them according to a heuristically defined priority function.
Based on the list schedulingalgorithm, force-directed scheduling algorithm is proposed [12], which builds a force-distributiongraph for representing the priority function.
Inspired by the force-directed scheduling algorithm,
Entropy-Directed Scheduling (EDS) algorithm
[13] replaces the priority function with the entropy of
CDFGs to be scheduled.
The utilization of the entropy function not only speeds up the schedulingprocess, but also improves the quality of solutions.
Different from the algorithms in the list schedulingfamily, an algorithm based on the system of difference constraints (SDC) is proposed to speed upthe ILP-based algorithm.
SDC-based algorithm transfers the scheduling constraints into a systemof difference constraints using heuristics, which greatly reduces the number of equations to besolved.
However, the SDC-based algorithm cannot guarantee the optimal solution.
Therefore, theaforementioned heuristic algorithms all trade quality of solutions for runtime, which leaves a largeoptimization space to be explored.
On the one hand, the complicated dependencies of operations in the CDFG bring great challengesto the scheduling process.
On the other hand, Graph Neural Networks (GNNs) [14, 15, 16] havegreat representational power of complicated graphs, which is suitable for extracting complicatedrelations between operations in CDFGs.
Therefore, a natural idea is to adopt GNNs to tackle thescheduling problem for both fast runtime and high-quality solutions.
This paper proposes the first
GNN-based scheduling algorithm called NeuroSchedule.
Inspired by algorithms in the list schedulingfamily, NeuroSchedule builds a GNN model to predict the priorities of operations in the CDFG.
Thepredicted priorities are then used to arrange the operations in CDFG to obtain the scheduling results.
Major contributions of this paper are summarized as follows:
• A learning problem for the HLS scheduling is first formulated, and then a GNN-basedlearning framework is proposed to effectively and efficiently solve the problem.• Pre-training models are adopted to further enhance the scalability for different schedulingproblems with different settings.•
Experimental results indicate that NeuroSchedule obtains near-optimal solutions whileachieving more than 50,000 × speedup compared with the ILP-based algorithm [10].
At thesame time, NeuroSchedule improves the scheduling results by 6.10% on average comparedwith the state-of-the-art EDS algorithm [13].
The rest of this paper is organized as follows.
Section 2 gives a motivating example for the GNNbased scheduling method.
Section 3 gives preliminaries and the formulation of the GNN-basedscheduling problem.
The proposed machine learning framework is presented in Section 4.
Section 5.2introduces NeuroSchedule, as well as the pre-training models adopted for enhancing the scalability.
Section 6 presents the experimental results.
Finally, conclusion is drawn in Section 7.
[Table]
[Figure]
Motivation
As introduced in Section 1, the list scheduling algorithm stores ready operations in a list and schedulesthem according to a heuristically defined priority function.
Here, a ready operation means all of itspredecessing operations are finished and the operation could be scheduled for execution immediately.
For example, in Figure 2(a), node 3 is ready when node 0 and node 1 are finished.
The process oflist scheduling could be stated as follows.
First, the ready operations are stored in a list.
Next, theoperation with the highest priority in the list is picked to be scheduled to available hardware resources(e.g.
adders and multipliers) for execution.
After the operation is finished, the newly generated readyoperations are stored in the list.
The above process is iterated until all the operations are successfullyscheduled.
From the list scheduling process, defining precise priority functions is crucial to obtaingood scheduling results.
A motivating example is given in Figure 2.
Figure 2(a) presents the CDFG to be scheduled, whichconsists of 6 operations with 2 types (ADD and MUL).
And the available hardware resources forscheduling are an adder (for ADD) and a multiplier (for MUL).
Figure 2(c) depicts the entropydirected scheduling process, which takes the entropy function for the priority computation.
In thefigure, ready operations are colored blue and finished operations are colored green.
Since the entropypriority of node 3 is higher than node 2, node 3 is scheduled before node 2.
However, schedulingnode 3 first delays the scheduling of node 4, which makes the multiplier idle for 3 cycles (i.e. timesteps).
Consequently, the final scheduling result is not optimal.
In Figure 2(b), we assume there isan optimal manually designed priority function.
Based on the optimal priority function, node 2 isscheduled before node 3, and thus the hardware resources are fully utilized.
Therefore, the schedulingalgorithm based on the manual function gives the optimal solution.
The success of the manually designed function motivates us to build a machine learning framework,which learns the priority function automatically.
GNNs are an effective framework for representationlearning of graphs, which follow a neighborhood aggregation scheme.
In GNNs, representationvectors of nodes are computed by recursively aggregating and transforming representation vectorsof their neighboring nodes [14].
Therefore, GNNs are suitable to learn the CDFG embeddings forobtaining the priority function.
As a result, a GNN-based machine learning framework is proposed tolearn the priority function.
Experiments verify the effectiveness of the proposed scheduling methodbased on GNN.
Preliminaries and Problem Formulation
CDFG.
In high-level synthesis, the program in high-level language is first translated into CDFG, agraph-based representation defined as follows:
[Figure]
𝓟
[Figure]
𝓛
List Scheduling 𝓓
S’
Schedule Solution
[Figure]
Definition 1 A CDFG G =
( V, E ) is a directed graph with node set V and edge set E .
Each nodev ∈ V represents an operation, e.g. add or load.
Each directed edge e = ( v i , v j ) ∈ E, i, j ∈1 , ..., | V | represents a dependency relationship between operation v i and v j , i.e., operation v j mustbe executed after the execution of operation v i .
ASAP and ALAP.
The As-Soon-As-Possible (ASAP) algorithm and the As-Late-As-Possible
(ALAP)algorithm give the information about node flexibility during the scheduling process.
For node v i ∈ V ,the result of ASAP and ALAP can be formulated as follows:
[Equation] [Equation]
Resource-constrained scheduling problem.
Based on the CDFG, we have to solve the resourceconstrained scheduling problem: given the number of resources, find the scheduling solution withthe minimum number of execution cycles, while satisfying the given set of scheduling and resourceconstraints.
Given a functional unit set U , where u i ∈
U represents a functional unit, such as anadder.
Denote d u i as the cycle delay of functional unit u i .
Given a CDFG G =
( V, E ) , and letn = | V | , a schedule can be defined as S
=
( t 1 , t 2 , ..., t n , f 1 , f 2 , ..., f n ) , where ∀ i ∈ 1 , 2 , ..., n , (1)t i ∈ N ∗ , denoting the start cycle of operation v i ∈ V , (2) f
i ∈ U , denoting the functional unit usedby operation v i .
Let L = max i ∈ 1 ,...,n t i + d f i − 1 denote the total number of execution cycles.
Theresource-constrained scheduling problem minimizes L , which can be defined as follows:
Definition 2 Find an optimal schedule S ′
=
( t ′ 1 , t ′ 2 , ..., t ′ n , f ′ 1 , f ′ 2 , ..., f ′ n ) , such that:
a) ∀ e
= ( v i , v j
) ∈ E, i, j ∈ 1 , 2 , ..., n , t ′ i + d f ′ i ≤ t ′ jb) ∀ i, j ∈ 1 , 2 , ..., n, i ̸
= j , f ′ i = f ′ j = ⇒ | t ′ i − t ′
j | ≥
d f ′ i
c) L = max i ∈ 1 ,...,n t ′
i + d f ′ i − 1 is minimized.
List scheduling.
As introduced in Section 2, list scheduling is an effective scheduling algorithm.
Itdivides the node set V into three sets, finished nodes V F , ready nodes V R , and unscheduled nodes
V U .
Given the node priority function F , where F ( v i ) <
F ( v j ) , v i , v j ∈ V R indicates that operationv i has a higher priority than operation v j .
At each step, list scheduling algorithm chooses the nodev h ∈ V R to schedule, where F ( v h ) = min v r ∈ V R F ( v r ) .
A better priority function in the list schedulingalgorithm corresponds to a better scheduling solution.
As the ILP-based scheduling algorithm can getthe optimal scheduling results, the scheduling result S
I =
( t I 1 , t I 2 , ..., t
In , ... ) is a good candidatefor the priority function, where F ( v x ) =
t Ix , v x ∈ V .
However, for large scheduling problems, theruntime of the ILP-based algorithm is not acceptable.
Therefore, we propose the GNN model topredict the priority function.
Neural Network Model.
Denoting the input data as D , our model can be formulated as:
[Equation]
Our loss function can be formulated as:
[Equation]
Details of our loss function will be introduced in Section 4.
Figure 3 shows the framework of our
NeuroSchedule algorithm.
The ILP-based scheduling algorithm is adopted to generate the traininglabels for our GNN model.
The output of the GNN model, i.e. P , is used by the list schedulingalgorithm as the priority function, which obtains significantly enhanced scheduling solution.
[Figure]
Model Design
[Figure]
A machine learning framework is proposed to learn the priority function in the list schedulingalgorithm.
In the proposed framework, the CDFG is taken as input, and a GNN model is trained topredict the priorities of the operations.
This section gives the model input, the model architecture,and the selection of loss function.
4.1 Model Input
The input of a GNN model includes an adjacency matrix representing graph connections and a tensorrepresenting node features.
Different node features will be selected for different problems.
In thescheduling problem, the node features consist of operation type, number of cycles of the operation,along with the above-defined ASAP and ALAP.
Operation’s type and number of cycles.
As the operation type is categorical and discrete, inspiredby the graph-based program representation [17], the operation type is encoded by one-hot encoding.
For the number of cycles of an operation, the cycle number is directly used in the encoding.
Forexample, if there are two types of operations (MUL, ADD) and the cycle number of MUL operationis 1, the node feature of MUL operation could be represented as [1, 0, 1].
Here, “10" from the first“1" and second “0" in the feature denotes MUL.
Operation’s ASAP and ALAP.
Except for operation’s type and number of cycles, ASAP and ALAPare also adopted in the node features.
As introduced in Section 3, ASAP and ALAP represent theearliest step and the latest step that an operation could be scheduled, respectively.
The ASAP and
ALAP of an operation indicate the operation’s flexibility during scheduling.
For example, the ASAPof node ADD2 in Figure 5 is step 0 and the ALAP is step 1, which means node ADD2 could bescheduled between step 0 and step 1.
Different from node ADD2, the ASAP and ALAP of node
ADD3 in Figure 5 are both step 1, which means node ADD3 could only be scheduled to step 1.
Thereason why ASAP and ALAP are adopted in the node features is that the flexibility of an operationaffects its priority during scheduling.
Operations with low flexibility during scheduling tend to be thebottlenecks [13], which should be scheduled with high priority to fully utilize the hardware resources.
Finally, the operation’s type, operation’s number of cycles, along with normalized ASAP and ALAP,are concatenated as a tensor representing node features.
For example, there are two operations in
Figure 5, MUL and ADD, and the number of cycles of operations MUL and ADD are both 1.
Sonode ADD3 could be encoded as [0, 1, 1, 0.5, 0.5].
It is noteworthy that the ASAP and ALAP ofan operation are normalized according to the maximum ASAP value among all the operations.
Thenormalization is conducted because the number of operations in the CDFG varies such that using theabsolute ASAP and ALAP values will bring noises.
ADD
MUL
Step Step
Step Step
ADD ADD
MUL
Step Step
Step Step
ADD
ADD0ADD0 MUL1MUL1 ADD2ADD
ADD3ADD
ADD5ADD
MUL4MUL
ADD0 MUL1 ADD
ADD ADD
MUL
Step Step
Step00
Step Step
Step
 Step
Step
Step0022
Step
Step Step
[Figure]
4.2 Model Architecture
[Figure]
Figure 4 presents the architecture of the proposed model.
As shown in the figure, the proposedmodel is composed of a GNN model and a feed-forward network (FFN) model.
The GNN model isadopted to learn the embedding of each operation from the operation features and graph structure,while the FFN model is utilized to conduct regression tasks for predicting operations’ priorities.
Theworkflow of the model is presented as follows.
First, operation features including the operation’s type,operation’s number of cycles, along with normalized ASAP and ALAP are concatenated into a featuretensor as introduced in Section 4.1.
Next, a GNN model is adopted to learn operation embeddingfrom the feature tensor and graph structure.
Graph Isomorphism Network (GIN) is used as the GNNmodel for its strong power of learning embeddings from graph structures [14].
Finally, the learnedoperation embedding is fed into the FFN model for predicting the operations’ priorities.
In the FFNmodel, there are three fully-connected layers, and ReLU is adopted as the activation function [18].
4.3 Training Settings
As depicted in Figure 4, the proposed model outputs the operations’ priorities by regression.
Toeffectively train the proposed model, a dedicated training pipeline is proposed.
The proposed trainingpipeline mainly focuses on two questions: 1.
How to acquire the regression labels; 2.
How to selectthe training objective function (a.k.a loss function).
Training label.
As formulated in Section 3, training the priority prediction task requires a collectionof data D
= { g i , p i , c i } , where g i denotes CDFG’s graph structure, p i denotes operation properties(such as ASAP and ALAP), and c i denotes the training label.
In the proposed training pipeline,the ILP-based method is used to generate the regression labels [10].
The details are presented asfollows.
The ILP-based method gives the optimal solution, which arranges CDFG’s operations intosuitable time steps.
Obviously, operations arranged in later time steps have lower priorities than thosearranged in earlier time steps.
Therefore, in the proposed training pipeline, the time step obtainedby the ILP-based method (i.e. t Ii in Section 3) is taken as the regression label c i .
As mentioned in
Section 4.1, the time step of an operation is also normalized based on the maximum time step, whichreduces the impact of noises.
Figure 2 gives an example.
In the manually designed priority function,the time step could be solved by the ILP-based method.
As shown in the figure, the ILP-solved timesteps [0 , 0 , 1 , 2 , 2 , 3] are assigned to corresponding operations.
After normalization, the ILP-solvedtime steps are computed as [0 , 0 , 0 .
Training objective function.
The mean square error (MSE) function is commonly adopted fortraining a regression task.
Given dataset D = { g i , p i , c i } , the output of our GNN model has the form
P ( i ) =
P ( g i , p i ) .
The MSE function (cid:80) i ( P ( i )
− c i ) 2 guides the model to accurately predict theoperations’ priorities.
However, the scheduling task cares more about the operations’ relative orderrather than the absolute priority values of the operations.
Moreover, it takes more effort for training amodel to predict the absolute value than to predict the rank.
Therefore, inspired by AutoTVM [19], thefollowing rank loss function is adopted to train the model for predicting the rank of all operations [20]:
[Equation]
During training, the above rank loss function keeps the relative order of operations’ priorities withreduced training efforts.
NeuroSchedule
5.1 Pre-training for Different Scheduling Settings
As introduced in Section 4.1, the input of our model consists of the operation’s type and operation’snumber of cycles, along with normalized ASAP and ALAP.
It works well when the numbers offunctional units are fixed.
However, there are various scheduling settings in real HLS cases including:(1) different operation types, (2) different number of functional units for each type, and (3) differentnumber of cycles for different operation types.
Figure 5(d) gives a scheduling example with 2 adders,1 multiplexer, and multi-cycle operations, i.e., the MUL operation takes 2 cycles.
Therefore, forscheduling problems with different settings, specified GNN models are required to get valid solutions.
chosen 18: do 19: then 22:
However, it is infeasible to train a GNN model for each scheduling setting due to the unbearabletraining efforts.
Therefore, we build a dataset of CDFGs with different scheduling settings, andpre-train our model with the dataset.
To specify the scheduling setting, we add the number of thecorresponding functional units into the node features of each operation.
While dealing with a specificscheduling setting, we fine-tune the model using the randomly generated data from the setting.
Compared with direct training, the fine-tuning takes fewer efforts with enhanced scheduling solutions.
5.2 NeuroSchedule Algorithm
Algorithm 1 gives an overview of the proposed NeuroSchedule algorithm, which is based on thetraditional list scheduling algorithm and our neural network models.
The symbols in Algorithm 1are defined in Section 3.
We use trained network model P as priority function F (line 3), and runthe loop until each node in the CDFG is successfully scheduled (line 7).
In each cycle, we try toschedule every available functional unit using the node v chosen with the highest priority.
After thenode v chosen is selected from the ready set V R , we update the schedule S P , and the sets V R and V F(line 16).
Then we delete all the out edges ( v i , v chosen ) of v chosen (line 20).
If the in-degree of v iequals 0, we add v i into the ready set V R .
Finally, the scheduling solution is obtained in S P .
Experiments
The proposed GNN-based scheduler is implemented in Python (version 3.9.12), and the GNN modelis designed and trained with Pytorch [21] (version 1.8.0) and pyG [22] (version 2.0.4).
To trainthe GNN model, we build a dataset including 50,000 CDFGs.
The operations in the CDFGs areannotated with the priorities solved by the ILP-based method (as introduced in Section 4.3).
Forefficiency, Gurobi [23] is adopted as the ILP solver.
Details of dataset preparation are presentedin supplementary materials.
We conduct all the experiments on a Ubuntu 20.04 LTS Linux Serverwith a CPU (Intel(R) Xeon(R)
Gold 5218 CPU@2.30GHz) and a GPU (NVIDIA Tesla V100).
Theexperiments are conducted to answer the following questions:
Q1:
Could NeuroSchedule obtain better solutions than the entropy-directed algorithm?Q2: Could NeuroSchedule obtain optimal solutions with respect to the ILP-based method?Q3: How fast is the proposed algorithm compared against the ILP-based method
[Table]
do
[Table] [Table]
: What are the differences between different loss functions?
[Table]
[Table]
% CHStone motion mt_Vectors
[Table]
[Table]
CHStone sha final
[Table]
[Table] [Table]
MiBench cosine
[Table] [Table]
[Table] [Table]
MiBench
[Table]
[Table] [Table]
[Table] [Table]
MiBench
[Table]
[Table] [Table]
[Table] [Table]
MiBench
[Table] [Table]
[Table]
MiBench idctcol dfg
[Table]
[Table] [Table]
[Table] [Table]
MiBench write
[Table] [Table]
[Table] [Table]
Total
[Table]
[Table] [Table]
Rate
[Table]
6.1 Quality of Solutions
To answer Q
[Table]
we evaluate the performance of NeuroSchedule against state-of-the-art entropydirected scheduling algorithm [13] and ILP-based method [10] using the benchmarks from CHStone [24] and MiBench [25].
The experimental results are presented in Table 1.
As shown in thetable, NeuroSchedule improves the scheduling results by 6.10% on average compared with EDS.
Moreover, compared with the ILP-based method, NeuroSchedule obtains optimal solutions in 88.89%of the benchmarks and near-optimal solutions in the rest, while EDS can only obtain 16.67% optimalsolutions in all benchmarks.
To answer Q2 , we synthesize a benchmark suite including large CDFGs with complex dependenciesamong the operations.
The entangled dependencies make it hard for scheduling algorithms to findan optimal solution.
We evaluate NeruoSchedule, entropy-directed algorithm [13] and ILP-basedalgorithm [10] on the synthesized complex benchmark suite.
The results are presented in Figure 6.
Figure 6 gives the heatmaps for comparing the scheduling results among NeuroSchedule, entropydirected algorithm, and ILP-based algorithm.
As shown in Figure 6(a), NeuroSchedule obtainsoptimal solutions on 90% of the synthesized complex benchmarks.
While in Figure 6(b), the entropydirected algorithm fails to obtain optimal solutions on all of the benchmarks due to the complexoperation dependencies.
Moreover, as shown in Figure 6(c), NeuroSchedule obtains better solutionson 94% of the synthesized complex benchmarks compared with the entropy-directed algorithm.
[Figure] [Figure]
6.2 Execution Time
To answer Q3 , we evaluate the runtime of NeuroSchedule against state-of-the-art entropy-directedscheduling algorithm and ILP-based method [10] using benchmarks from CHStone [24] and
MiBench [25].
The results are presented in Table 1.
As shown in the table, NeuroSchedule achievesmore than 50,000 × speedup compared with the ILP-based method, while obtaining near-optimalsolutions.
Moreover, the ILP-based method fails to solve certain benchmarks within 10,000 secondsdue to the exponential runtime overhead.
Besides, since NeuroSchedule needs to launch CUDAkernels to compute operation priorities, it runs a little slower than the entropy-directed algorithm.
Nevertheless, NeuroSchedule is still fast and the difference in runtime between NeuroSchedule andentropy-directed algorithm could be ignored.
6.3 Pre-training and Fine-tuning
To answer Q4 , we synthesize a small dataset that consists of 1000 CDFGs.
Details of the small datasetare presented in supplementary materials.
Based on the synthesized small dataset, NeuroScheduleis trained in two different ways: from scratch and fined-tuned from the pre-training model.
Thesynthesized benchmark suite in Section 6.1 is adopted to evaluate the two models trained in differentways.
Besides, the optimal rate is selected as the metric, which indicates the number of benchmarksin the synthesized suite with optimal solutions obtained by NeuroSchedule.
Figure 7 depicts theoptimal rate curve during training.
As shown in the figure, NeuroSchedule fine-tuned from thepre-training model achieves 3% improvement in the optimal rate compared with that trained fromscratch.
Moreover, NeuroSchedule fine-tuned from the pre-training model achieves a better optimalrate while costing reduced training efforts compared with that trained from scratch.
6.4 Training Settings
To answer Q5 , NeuroSchedule is trained with MSE loss and Rank loss [20] on the synthesizedsmall dataset described in Section 6.3.
The synthesized benchmark suite in Section 6.1 is adopted toevaluate the two models trained with different loss functions.
Besides, the optimal rate is selectedas the metric.
Figure 7 depicts the optimal curves during training.
As shown in the figure, rankloss behaves slightly better than MSE loss, which indicates that training a model for predicting theabsolute value requires more effort than training a model for predicting the rank.
Therefore, the rankloss is chosen as the default training objective function.
Conclusion
This paper presents NeuroSchedule, a novel and effective GNN-based scheduling method for HLS.
NeuroSchedule learns to predict operation priorities using GNN models.
The predicted prioritiesare adopted in list scheduling process.
Besides, to enhance NeuroSchedule’s scalability for variousscheduling problems with different settings, pre-training methods are adopted.
Experimental resultsindicate that NeuroSchedule achieves significantly enhanced solutions compared with the state-ofthe-art method.
Moreover, NeuroSchedule obtains near-optimal solutions while achieving more than50,000 × speedup compared with the ILP-based algorithm.
Future work includes elaborations on thetraining details for better tuning, supporting operation chaining, and testing of NeuroSchedule onlarger and more complicated benchmarks.
Checklist
For all authors...
(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s
contributions and scope?
[Yes]
(b) Did you describe the limitations of your work?
[Yes] See Section 6 and Section 7.
(c) Did you discuss any potential negative societal impacts of your work?
[N/A](d)
Have you read the ethics review guidelines and ensured that your paper conforms tothem?
[Yes]
If you are including theoretical results...
(a) Did you state the full set of assumptions of all theoretical results?
[N/A]
(b) Did you include complete proofs of all theoretical results?
[N/A]
If you ran experiments...
(a) Did you include the code, data, and instructions needed to reproduce the main ex-
perimental results (either in the supplemental material or as a URL)?
[No] Our Neu-
roSchedule will be open-sourced once the paper is accepted.
(b) Did you specify all the training details (e
g., data splits, hyperparameters, how theywere chosen)?
[Yes] See Section 4 and the supplementary materials.
(c) Did you report error bars (e
g., with respect to the random seed after running experiments multiple times)?
[No]
(d) Did you include the total amount of compute and the type of resources used (e.g., typeof GPUs, internal cluster, or cloud provider)?
[Yes]
If you are using existing assets (e
g., code, data, models) or curating/releasing new assets...
(a)
If your work uses existing assets, did you cite the creators?
[Yes]
(b) Did you mention the license of the assets?
[N/A]
(c) Did you include any new assets either in the supplemental material or as a URL?
[Yes]We put the large CDFG dataset into our supplementary materials.
(d
) Did you discuss whether and how consent was obtained from people whose data you’re
using/curating?
[Yes] The benchmarks used in our paper are open-sourced, and we cite
them in our paper.
(e) Did you discuss whether the data you are using/curating contains personally identifiable
information or offensive content?
[N/A]
If you used crowdsourcing or conducted research with human subjects...
(a) Did you include the full text of instructions given to participants and screenshots, if
applicable?
[N/A]
(b) Did you describe any potential participant risks, with links to Institutional Review
Board (IRB) approvals, if applicable?
[N/A]
(c) Did you include the estimated hourly wage paid to participants and the total amount
spent on participant compensation?
[N/A]