An FPGA hardware design automation acceleration method based on StarCoder2 code generation optimization

Abstract

The embodiment of the application discloses an FPGA hardware design automation acceleration method based on StarCoder2 code generation optimization, the embodiment of the application collects FPGA design related codes, constraints and performance data to construct fine tuning data set, supervises fine tuning on StarCoder2 model, and obtains a code generation model adapted to FPGA design; resources, timing and interface constraints of the FPGA chip are sorted out and converted into a structured rule library; design requirements are input into the fine tuned model, and initial hardware description language code is generated in combination with the rule library; the code is imported into the FPGA design tool for analysis and simulation, if the constraints are not met, feedback parameters are extracted for re-generation, if the constraints are met, configuration files are generated through synthesis and layout; meanwhile, the verified effective codes and data are supplemented to the fine tuning data set, and the model generation capacity is iteratively optimized. The application can automatically complete code generation and optimization, significantly shorten the FPGA design cycle, and reduce the labor cost and error probability.

Description

Technical Field

[0001] This invention relates to the field of FPGA hardware design automation acceleration technology, specifically to an FPGA hardware design automation acceleration method based on StarCoder2 code generation optimization. Background Technology

[0002] FPGAs (Field-Programmable Gate Arrays) are widely used in communications, data centers, industrial control, and aerospace due to their high reconfigurability and outstanding parallel processing capabilities. However, traditional FPGA hardware design processes typically face challenges such as long design cycles, high coding difficulty, and complex debugging, which severely restrict product development efficiency and quality.

[0003] In the existing technology, various technical solutions have emerged to achieve automated acceleration of FPGA design, mainly including the following:

[0004] Traditional manual coding methods rely entirely on designers manually writing hardware description language (HMR) code (such as Verilog and VHDL). This method is inefficient, has a long development cycle, is highly dependent on the designer's professional experience, is prone to human error, and is difficult to handle complex or large-scale design requirements.

[0005] Template-based code generation: This method automatically generates partial code structures based on predefined code templates and configuration parameters. It is suitable for scenarios with relatively fixed design patterns, but lacks flexibility, struggles to adapt to diverse functional requirements and interface protocol changes, and cannot cover complex or customized designs.

[0006] Rule-based code generation methods involve writing design rules and constraints to drive code generation tools to output hardware code that conforms to specifications. However, building and maintaining the rule base requires deep domain knowledge, and lagging rule updates may result in generated code that fails to meet the latest timing, resource, or interface constraints.

[0007] A simple application of machine learning involves using general machine learning models (such as simple neural networks or traditional sequence models) for code generation. However, these models lack a deep understanding of FPGA design, and the generated code often falls short of practical engineering requirements in terms of syntax correctness, functional completeness, timing closure, and resource utilization, still requiring extensive manual modification and verification. Summary of the Invention

[0008] To address this, this invention provides an automated acceleration method for FPGA hardware design based on StarCoder2 code generation optimization, thereby solving the technical problems of existing technologies having significant shortcomings in terms of flexibility, intelligence, and generated code quality.

[0009] To achieve the above objectives, the embodiments of the present invention provide the following technical solutions:

[0010] According to a first aspect of the present invention, an automated acceleration method for FPGA hardware design based on StarCoder2 code generation optimization is provided, the method comprising:

[0011] Collect hardware description language code, hardware constraint rules and performance index data of FPGA design scenarios, construct fine-tuning dataset, use the fine-tuning dataset to perform supervised fine-tuning of StarCoder2 model, and obtain code generation model adapted to FPGA design.

[0012] The resource constraints, timing constraints, and interface protocol requirements of the target FPGA chip are analyzed, and these constraints are transformed into a structured constraint rule base.

[0013] The FPGA design requirements are input into the fine-tuned code generation model, and combined with the constraint rule library, the model generates the initial hardware description language code.

[0014] The generated initial hardware description language code is imported into the FPGA design tool for analysis and simulation to obtain resource usage and timing simulation results.

[0015] If the preset constraints are not met, key feedback parameters are extracted from the resource usage and timing simulation results, and the key feedback parameters are fed back to the code generation model to trigger the model to regenerate the code.

[0016] If all preset constraints are met, the hardware description language code that meets all preset constraints is synthesized and placed and routed to generate a bitstream file for FPGA configuration. At the same time, the hardware description language code that meets the constraints and its corresponding design requirements and performance index data are added to the fine-tuning dataset to iteratively optimize the generation capability of the code generation model.

[0017] Furthermore, the construction of the fine-tuning dataset specifically includes:

[0018] Collect hardware description language code samples in Verilog and / or VHDL formats, and extract the corresponding timing constraint files, physical constraint files, and performance index data;

[0019] The original code and constraints are used as the input sequence, and the optimized target code is used as the output sequence to form an input-output pair. The dataset is then divided into a training set and a validation set according to a certain ratio.

[0020] Furthermore, the supervised fine-tuning employs the cross-entropy loss function and optimizes the model parameters using stochastic gradient descent.

[0021] During training, the validation set loss is monitored to prevent overfitting. After fine-tuning, the performance of the generated code is evaluated using BLEU scores and constraint satisfaction.

[0022] Furthermore, the resource constraints include the maximum number of available logic units, block memory, digital signal processor units, and input / output pins, and are modeled as linear inequality constraints;

[0023] The timing constraints are based on clock frequency, setup time, and hold time, and the critical path delay requirements are derived and the timing margin is calculated.

[0024] Furthermore, the structured constraint rule base is defined and stored in XML or JSON format, and contains rule entries for resource constraint classes, time sequence constraint classes, and interface protocol constraint classes.

[0025] Furthermore, the FPGA design requirements are input as natural language or structured text, which is preprocessed and word-embedded into a vector representation before being input into the model.

[0026] Furthermore, when the model generates code, the constraint conditions in the constraint rule library are dynamically injected into the model's probability sampling process in the form of penalty terms through the rule engine to guide the generation of code that conforms to the constraints.

[0027] Furthermore, the analysis and simulation specifically include: using FPGA design tools to synthesize and implement the generated code, obtaining resource utilization reports for lookup tables, flip-flops, block memories, and digital signal processor units; and performing timing simulation and static timing analysis to obtain critical path delay, clock skew, and slack in setup and hold times.

[0028] Furthermore, the key feedback parameters include: the difference between the actual clock frequency and the target clock frequency, the difference between the utilization rates of various resources and the upper limit, and the timing relaxation amount in the worst case, which are organized into a quantized condition vector.

[0029] Furthermore, the iterative optimization of the code generation model's generation capability specifically includes: using a supplemented and updated fine-tuned dataset, with mean squared error as the loss function, and performing a new round of fine-tuning of the model parameters through gradient descent to minimize the error between the model's predicted performance and the actual performance metrics.

[0030] The embodiments of the present invention have the following advantages:

[0031] This invention collects FPGA design-related code, constraints, and performance data to construct a fine-tuning dataset. It then performs supervised fine-tuning of the StarCoder2 model to obtain a code generation model adapted to the FPGA design. The invention analyzes the FPGA chip's resources, timing, and interface constraints, transforming them into a structured rule base. Design requirements are input into the fine-tuned model, and the rule base is used to generate initial hardware description language (HTAL) code. This code is imported into FPGA design tools for analysis and simulation. If constraints are not met, feedback parameters are extracted and the code is regenerated; otherwise, synthesis and placement / routing are performed to generate a configuration file. Simultaneously, verified and effective code and data are added to the fine-tuning dataset, iteratively optimizing the model's generation capabilities. This invention automates code generation and optimization, significantly shortening the FPGA design cycle and reducing labor costs and error probability. Attached Figure Description

[0032] To more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are merely exemplary, and those skilled in the art can derive other embodiments based on the provided drawings without creative effort.

[0033] The structures, proportions, sizes, etc. illustrated in this specification are only for the purpose of assisting those skilled in the art in understanding and reading the content disclosed herein, and are not intended to limit the conditions under which the present invention can be implemented. Therefore, they have no substantial technical significance. Any modifications to the structure, changes in the proportions, or adjustments to the size, without affecting the effects and objectives that the present invention can produce, should still fall within the scope of the technical content disclosed in the present invention.

[0034] Figure 1 A flowchart illustrating an automated acceleration method for FPGA hardware design based on StarCoder2 code generation optimization, provided for an embodiment of the present invention;

[0035] Figure 2 This is a schematic diagram illustrating the application process of an FPGA hardware design automation acceleration method based on StarCoder2 code generation optimization, provided in an embodiment of the present invention. Detailed Implementation

[0036] The following specific embodiments illustrate the implementation of the present invention. Those skilled in the art can easily understand other advantages and effects of the present invention from the content disclosed in this specification. Obviously, the described embodiments are only some, not all, of the embodiments of the present invention. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0037] In today's technology field, FPGAs (Field-Programmable Gate Arrays) are widely used in many fields such as communications, aerospace, and data centers due to their advantages such as high reconfigurability and excellent parallel processing capabilities. However, the traditional FPGA hardware design process has many challenges, such as long design cycles, difficult and error-prone code writing, which seriously affect the development efficiency and quality of FPGA products.

[0038] The main problems addressed by FPGA hardware design automation acceleration methods are improving FPGA design efficiency, reducing design complexity, and shortening the design cycle. Their core objective is to quickly and accurately generate hardware description language code that conforms to the resource constraints, timing constraints, and interface protocol requirements of FPGA chips.

[0039] In the field of FPGA hardware design automation acceleration methods, common related technical solutions and their shortcomings are as follows: Traditional manual coding is the most primitive method, requiring designers to manually write a large amount of hardware description language code. This method has obvious drawbacks: extremely low efficiency, long design cycle, susceptibility to human error, and extremely high requirements for the designer's professional skills. Template-based code generation generates code using predefined templates. However, this method lacks flexibility and is only applicable to some common, fixed design scenarios, failing to meet complex and ever-changing design requirements. Rule-based code generation generates code according to pre-defined rules. However, rule formulation is often difficult, requiring a deep understanding of FPGA design, and if the rules are not updated in a timely manner, the generated code may not meet the latest design requirements. Simple application of machine learning uses ordinary machine learning models for code generation. However, these models lack a deep understanding of FPGA design domain knowledge, resulting in low-quality generated code that is difficult to meet actual design constraints.

[0040] In order to address the technical problems of the aforementioned existing technologies, which have significant shortcomings in terms of flexibility, intelligence, and generated code quality.

[0041] This invention is applied to FPGA hardware design scenarios, thereby achieving automated acceleration of the design process. Utilizing StarCoder2-based code generation optimization technology, the process of engineers manually writing code and repeatedly debugging during FPGA hardware design can be automated, quickly generating optimized code, significantly shortening the design cycle, and reducing labor costs and the probability of errors. For example, it can quickly and efficiently complete designs in scenarios such as developing FPGA chips for communication equipment and FPGA modules for industrial automation control. This invention has wide applications in fields such as electronic communications and industrial automation.

[0042] refer to Figure 1 and Figure 2 This invention discloses an automated acceleration method for FPGA hardware design based on StarCoder2 code generation optimization, comprising: collecting hardware description language code, hardware constraint rules and performance index data of FPGA design scenarios, constructing a fine-tuning dataset, and using the fine-tuning dataset to perform supervised fine-tuning of the StarCoder2 model to obtain a code generation model adapted to FPGA design;

[0043] The resource constraints, timing constraints, and interface protocol requirements of the target FPGA chip are analyzed, and these constraints are transformed into a structured constraint rule base.

[0044] The FPGA design requirements are input into the fine-tuned code generation model, and combined with the constraint rule library, the model generates the initial hardware description language code.

[0045] The generated initial hardware description language code is imported into the FPGA design tool for analysis and simulation to obtain resource usage and timing simulation results.

[0046] If the preset constraints are not met, key feedback parameters are extracted from the resource usage and timing simulation results, and the key feedback parameters are fed back to the code generation model to trigger the model to regenerate the code.

[0047] If all preset constraints are met, the hardware description language code that meets all preset constraints is synthesized and placed and routed to generate a bitstream file for FPGA configuration. At the same time, the hardware description language code that meets the constraints and its corresponding design requirements and performance index data are added to the fine-tuning dataset to iteratively optimize the generation capability of the code generation model.

[0048] 1) Collect hardware description language code, hardware constraint rules, and performance index data for FPGA design scenarios, construct a fine-tuning dataset, and use this dataset to perform supervised fine-tuning of StarCoder2 to obtain a code generation model adapted to the FPGA design. The specific implementation method for this step is as follows:

[0049] Collect FPGA hardware description language code samples, including Verilog and VHDL files, from open-source project repositories such as GitHub or internal enterprise databases. Extract constraint rule files such as SDC timing constraints and physical layout limitations, as well as performance metrics such as latency, power consumption, and resource utilization data. Clean the data, removing inconsistencies and standardizing the encoding format to ensure standardized processing of the input sequences. When constructing the fine-tuning dataset, define input-output pairs: input sequence... Includes source code and constraint rules, output sequence This is the optimized target code. The dataset is divided into training and validation sets in an 8:2 ratio to evaluate generalization performance.

[0050] Configure the StarCoder2 model architecture, loading its pre-trained weights as initial parameters. Set the hyperparameters for fine-tuning: learning rate. Batch size Number of training rounds The input sequence is converted into a vector representation through an embedding layer, and the model outputs a predicted probability distribution. Supervised fine-tuning uses the cross-entropy loss function:

[0051]

[0052] in This is the number of training samples. Loss minimization is optimized using stochastic gradient descent:

[0053]

[0054] Parameter update rules:

[0055]

[0056] The training process monitors and validates the loss to prevent overfitting. After fine-tuning, the model weights are saved, and a code generation model adapted to the FPGA design is generated. During the evaluation phase, the BLEU score and constraint satisfaction of the generated code are calculated using the validation set to ensure performance improvement. Model deployment supports real-time FPGA design assistance tools.

[0057] 2) Analyze the resource limitations, timing constraints, and interface protocol requirements of the FPGA chip, and transform these constraints into a structured rule base as constraint inputs for the model generation code. The specific implementation method for this step is as follows:

[0058] Extract key specifications from FPGA device datasheets, including resource constraints such as logic units (LUTs and FFs), BlockRAMs, DSP slices, and maximum I / O pin count. Model resource constraints as linear inequality constraints to ensure resource usage does not exceed the upper limit. For example, the total LUT usage must satisfy:

[0059]

[0060] in The LUT consumption coefficient for each functional module. For the number of times the module is instantiated, This represents the maximum LUT capacity of the FPGA.

[0061] Timing constraint analysis is based on clock domain definition, including clock frequency. setup / hold time When deriving the path delay requirement, the clock cycle... Convert to critical path constraint. Path delay. Must meet To avoid timing violations, Slack calculates further quantization margins:

[0062]

[0063] A negative slack value indicates that optimization is needed.

[0064] Interface protocol requirements include parsing standards such as PCIe or Ethernet, and bandwidth constraints. middle, For data packet size, For the transmission cycle. Ensure that protocol parameters such as rate and handshake timing are mapped to rule entries. All constraints are integrated into a structured rule base, using XML format to define rule classes, for example... <resource> <lut max="1000" / > < / resource> and <timing> <clock frequency="100e6" / > < / timing> The rule base is output as a JSON or XML file for loading by the model code generation tool. Finally, the integrity of the rule base is verified by checking constraint consistency and coverage using static analysis tools.

[0065] 3) Input the FPGA design requirements into the fine-tuned model, and combine it with the constraint rule base to generate the initial hardware description language code. The specific implementation method for this step is as follows:

[0066] FPGA design requirements are input into the system in natural language or structured descriptions (such as JSON format), describing functional modules, interface specifications, and performance targets. The requirement text is cleaned and standardized by a preprocessing module, removing irrelevant characters and segmenting it into token sequences. A word embedding layer is used to transform the tokens into high-dimensional vector representations, forming the model input. ,in , For sequence length, For the embedding dimension. The embedding process is defined as follows: , As the initial input to the model, the fine-tuned Transformer model, based on the GPT architecture, is pre-trained and fine-tuned on a hardware design dataset. The model processes the input through a multi-head self-attention mechanism, calculating the hidden state sequence. The state update formula is:

[0067]

[0068] in It is the first Step into hidden state, and These are learnable parameters.

[0069] The probability distribution of HDL code tokens generated by the model output layer for each position. Calculate the probability:

[0070]

[0071] Indicates the current token index. To output the weight matrix. Constraint rule base (including time-series constraints such as...) Resource constraints (such as the number of LUTs) are dynamically integrated through the rule engine. Constraints are injected into the model sampling phase in the form of a loss function, defining the adjusted probabilities:

[0072]

[0073] in To violate constraints in the rule base The penalty score The tuning coefficients control the constraint strength. The model generates a token sequence using either Beam Search or Top-k sampling strategies. Ensure that the sequence length does not exceed a predefined threshold.

[0074] The generated token sequence is decoded into initial HDL code (Verilog or VHDL format). The output file contains module declarations, signal definitions, and basic logic structures. The system performs syntax validation, checking bracket matching and keyword completeness to avoid compilation errors. The initial code serves as the starting point for subsequent optimization processes, fulfilling the core functionalities described in the requirements. The entire process is automated within the FPGA design toolchain, with an average processing time in the seconds range, ensuring scalability.

[0075] 4) Import the generated code into the FPGA design tool to analyze resource usage and timing simulation. If the constraints are not met, extract the conditions and feed them back to the model for regeneration; if they are met, proceed to the next step. The specific implementation method of this step is as follows:

[0076] Import the generated Hardware Description Language (HDL) code, such as Verilog or VHDL, into an FPGA design tool (e.g., Xilinx Vivado or Intel Quartus Prime). Load the project file via the tool's Tcl script interface or graphical user interface, set the target FPGA device model (e.g., Xilinx Artix-7 or Intel Cyclone V), and configure synthesis and implementation options. Verify the code syntax and module connectivity to ensure there are no compilation errors; use the tool's built-in parser to check the module hierarchy and generate an initial netlist report.

[0077] The synthesis and implementation processes are performed to analyze resource usage. The synthesis phase converts the HDL into a gate-level netlist and optimizes the logic structure; the implementation phase handles place and route, generating a resource utilization report. Key resource metrics are extracted, including the usage of lookup tables (LUTs), flip-flops (FFs), block RAM (BRAM), and DSP slices. Resource constraints are defined as maximum available resource thresholds, such as LUT utilization.

[0078]

[0079] Global constraints must be satisfied For all resource types i (such as LUTs, FFs), where This indicates the utilization rate of each resource.

[0080] Runtime simulation and static timing analysis (STA) are used to evaluate performance. Test vectors are applied using the tool's built-in simulator or a third-party engine (such as ModelSim) to simulate circuit behavior; STA calculates propagation delay, clock skew, and jitter on the critical path. A setup slack is then established.

[0081]

[0082] in It is the maximum propagation delay; maintain time slack.

[0083]

[0084] Constraint satisfaction must ensure that all paths are satisfied. and .

[0085] Check whether resource usage and timing analysis results meet user-defined constraints. Compare reported data, such as actual clock frequency. With the goal or resource utilization rate And the upper limit value. If any constraint is not met, extract the key feedback parameters (e.g., , Minimum relaxation min( , ), forming a quantization condition vector:

[0086]

[0087] in: , .

[0088] Feedback conditions The code is passed back to the generative model (such as a machine learning-based HDL optimizer) via an API interface (such as Python script integration), triggering code regeneration and iterative optimization. If all constraints are met, the process proceeds to the next step (such as generating a bitstream file for FPGA programming). The entire process is controlled by automated scripts to ensure efficient closed-loop verification.

[0089] 5) Synthesize and place-and-route the code that meets the constraints to generate a configuration file. Simultaneously, supplement the fine-tuning dataset with the valid code and corresponding data, iteratively optimizing the model's generation capabilities. The specific implementation method for this step is as follows:

[0090] This step involves first imposing timing, area, and power constraints on the input high-level language code, performing logic synthesis, and then converting it into a gate-level netlist using EDA tools such as Synopsys Design Compiler. The synthesis process optimizes resource usage, aiming to minimize hardware resource consumption, and the area is calculated as follows. ,in Indicates the gate type factor. For the corresponding size parameters. Next, the placement and routing phase is performed, using tools such as Cadence Innovus for physical design, placing logic cells and routing signal paths to ensure timing closure is met. The optimization objective function is defined as follows: ,here It is critical path delay. and It is a weighting factor; the layout is adjusted through iterative algorithms such as simulated annealing, and the acceptance probability is:

[0091]

[0092] For temperature parameters. Generate configuration files, such as FPGA bitstream files, and output binary configurations for hardware implementation. For validly verified code examples, extract performance metrics such as power consumption. and delay Build data points ,in It is represented by code. It is a metric vector; added to the fine-tuning dataset, the dataset is updated as follows:

[0093]

[0094] Finally, the code generation model is fine-tuned using the updated dataset to minimize the prediction error loss:

[0095]

[0096] in For true performance, Output the model parameters; optimize parameters using gradient descent:

[0097]

[0098] To improve the learning rate, the model's generation capability is iteratively enhanced. The entire process is automated, ensuring convergence and verification in each iteration, and continuously improving code quality and efficiency through feedback.

[0099] StarCoder2 is a powerful code generation model with excellent code understanding and generation capabilities. The method proposed in this invention cleverly applies StarCoder2 to FPGA hardware design, leveraging its ability to quickly generate high-quality code based on input design requirements and constraints to optimize the FPGA hardware design. By optimizing the code generation process, the workload and time spent on manual coding can be reduced, and the error rate caused by human factors can be lowered.

[0100] This automated acceleration method offers significant advantages in practical applications. In the communications field, with the continuous development of 5G and 6G technologies, the demands on the performance and flexibility of communication equipment are increasing. This method allows for the rapid design of FPGA hardware that meets different communication standards and protocols, accelerating the R&D process of communication equipment. In data centers, facing the demand for processing massive amounts of data, this method enables the efficient design of FPGA hardware for data processing and acceleration, improving the overall performance of the data center.

[0101] The core idea of ​​this invention is to leverage the StarCoder2 code generation model, perform supervised fine-tuning to adapt it to FPGA designs, and then combine it with the FPGA's constraint rule base to generate hardware description language code. A feedback mechanism is then used to continuously optimize the model. Specifically, the process involves first collecting FPGA design-related data to construct a fine-tuning dataset and then fine-tuning StarCoder2; identifying FPGA constraints to form a rule base; inputting design requirements to generate initial code; analyzing the code, and if constraints are not met, feedback is provided for regeneration; otherwise, further processing and iterative model optimization are performed. By utilizing the powerful capabilities of the pre-trained model and combining it with the characteristics of the FPGA design for customized fine-tuning, a feedback mechanism is introduced to continuously improve the quality of code generation.

[0102] The embodiments of this invention offer significant advantages over existing methods. Compared to manual coding, this patent greatly improves design efficiency, reduces human error, and lowers the skill requirements for designers. Compared to template code generation methods, it offers greater flexibility and can adapt to various complex design needs. Compared to rule-based code generation methods, the embodiments of this invention, through continuous iterative model optimization, can better adapt to changes in design requirements. Compared to simple machine learning applications, the embodiments of this invention have made targeted fine-tuning to StarCoder2, making it more adept at FPGA design and generating higher-quality code.

[0103] Using the method proposed in this invention significantly improves FPGA design efficiency, shortens the design cycle, and reduces design costs. Simultaneously, the generated code is of higher quality, better conforms to various constraints of FPGA chips, and reduces repeated modifications during the design process. In real-world scenarios, it can be applied to FPGA design in multiple fields such as communications, aerospace, and industrial control, providing strong support for the development of these fields. Therefore, there is an urgent need to further utilize the capabilities of this method to solve the problems of low efficiency, poor quality, and inability to adapt to complex design requirements in traditional FPGA design methods.

[0104] Although the present invention has been described in detail above with general descriptions and specific embodiments, modifications or improvements can be made to it, which will be obvious to those skilled in the art. Therefore, all such modifications or improvements made without departing from the spirit of the present invention fall within the scope of protection claimed by the present invention.

Claims

1. A method for automating and accelerating FPGA hardware design based on StarCoder2 code generation optimization, characterized in that, The method includes: Collect hardware description language code, hardware constraint rules and performance index data of FPGA design scenarios, construct fine-tuning dataset, use the fine-tuning dataset to perform supervised fine-tuning of StarCoder2 model, and obtain code generation model adapted to FPGA design. The resource constraints, timing constraints, and interface protocol requirements of the target FPGA chip are analyzed, and these constraints are transformed into a structured constraint rule base. The FPGA design requirements are input into the fine-tuned code generation model, and combined with the constraint rule library, the model generates the initial hardware description language code. The generated initial hardware description language code is imported into the FPGA design tool for analysis and simulation to obtain resource usage and timing simulation results. If the preset constraints are not met, key feedback parameters are extracted from the resource usage and timing simulation results, and the key feedback parameters are fed back to the code generation model to trigger the model to regenerate the code. If all preset constraints are met, the hardware description language code that meets all preset constraints is synthesized and placed and routed to generate a bitstream file for FPGA configuration. At the same time, the hardware description language code that meets the constraints and its corresponding design requirements and performance index data are added to the fine-tuning dataset to iteratively optimize the generation capability of the code generation model.

2. The FPGA hardware design automation acceleration method based on StarCoder2 code generation optimization as described in claim 1, characterized in that, The construction of the fine-tuning dataset specifically includes: Collect hardware description language code samples in Verilog and / or VHDL formats, and extract the corresponding timing constraint files, physical constraint files, and performance index data; The original code and constraints are used as the input sequence, and the optimized target code is used as the output sequence to form an input-output pair. The dataset is then divided into a training set and a validation set according to a certain ratio.

3. The FPGA hardware design automation acceleration method based on StarCoder2 code generation optimization as described in claim 1, characterized in that, The supervised fine-tuning uses the cross-entropy loss function and optimizes the model parameters using stochastic gradient descent. During training, the validation set loss is monitored to prevent overfitting. After fine-tuning, the performance of the generated code is evaluated using BLEU scores and constraint satisfaction.

4. The FPGA hardware design automation acceleration method based on StarCoder2 code generation optimization as described in claim 1, characterized in that, The resource constraints include the maximum number of logic units, block memory, digital signal processor units, and input / output pins available, and are modeled as linear inequality constraints. The timing constraints are based on clock frequency, setup time, and hold time, and the critical path delay requirements are derived and the timing margin is calculated.

5. The FPGA hardware design automation acceleration method based on StarCoder2 code generation optimization as described in claim 4, characterized in that, The structured constraint rule base is defined and stored in XML or JSON format, and contains rule entries for resource constraint classes, time sequence constraint classes, and interface protocol constraint classes.

6. The FPGA hardware design automation acceleration method based on StarCoder2 code generation optimization as described in claim 1, characterized in that, The FPGA design requirements are input as natural language or structured text, which is then preprocessed and converted into a vector representation before being input into the model.

7. The FPGA hardware design automation acceleration method based on StarCoder2 code generation optimization as described in claim 6, characterized in that, When the model generates code, the constraint conditions in the constraint rule library are dynamically injected into the model's probability sampling process in the form of penalty terms through the rule engine to guide the generation of code that conforms to the constraints.

8. The FPGA hardware design automation acceleration method based on StarCoder2 code generation optimization as described in claim 1, characterized in that, The analysis and simulation specifically include: using FPGA design tools to synthesize and implement the generated code, obtaining resource utilization reports for lookup tables, flip-flops, block memory, and digital signal processor units; and performing timing simulation and static timing analysis to obtain critical path delay, clock skew, and slack in setup and hold times.

9. The FPGA hardware design automation acceleration method based on StarCoder2 code generation optimization as described in claim 8, characterized in that, The key feedback parameters include: the difference between the actual clock frequency and the target clock frequency, the difference between the utilization rates of various resources and the upper limit, and the timing relaxation amount in the worst case, which are organized into a quantized condition vector.

10. The FPGA hardware design automation acceleration method based on StarCoder2 code generation optimization as described in claim 1, characterized in that, The iterative optimization of the code generation model's generation capability specifically includes: using a supplemented and updated fine-tuned dataset, with mean squared error as the loss function, and performing a new round of fine-tuning of the model parameters using gradient descent to minimize the error between the model's predicted performance and the actual performance metrics.

Images