Systematic high-level comprehensive automatic processing method, device, equipment, storage medium and program product

Abstract

This invention discloses a systematic high-level synthesis automated processing method, apparatus, device, storage medium, and program product. Through a large language model-driven approach and the coordination of multiple parsing tools, it achieves the conversion of algorithms to high-level synthesis and design optimization. A fine-tuned large language model proxy system is employed to execute the key technology chain structure and communication, significantly improving design optimization and code error correction capabilities. The entire design process is coupled with the model proxy system and high-level synthesis tools, ensuring a high degree of automation and design correctness. An optimization and error correction iterative system overcomes the limitations of one-time model inference. This invention can bridge the gap between algorithm development and hardware design, lower the design experience threshold, and improve chip design efficiency.

Description

Technical Field

[0001] This invention relates to a systematic, high-level integrated automated processing method, apparatus, equipment, storage medium, and program product, belonging to the fields of design automation and artificial intelligence technology. Background Technology

[0002] In recent years, the exponential growth in computing demand has driven the rapid development of domain-specific accelerators. However, traditional integrated circuit design and verification processes are lengthy and highly dependent on manual labor, making it difficult to meet the agile development needs of domain-specific accelerator chips. High-Level Synthesis (HLS) has emerged as a key technology, bridging the gap between software and hardware through a C-like language description method, significantly improving hardware development efficiency.

[0003] However, to achieve efficient conversion from software algorithms to hardware designs, HLS tools impose specific constraints on programming paradigms, leading to portability overhead. Currently, HLS tools employ multi-tiered compilers to translate high-level programming languages ​​into hardware dataflow designs, but the rapid iteration of vendor-specific HLS tools and the improper use of design instructions often introduce various problems during synthesis. Developers must strictly constrain HLS-compatible C code while managing complex hardware-specific optimizations, resulting in time-consuming and low-automation development processes. Furthermore, HLS development requires significant hardware expertise, and ensuring consistency between software code and the synthesized RTL code remains error-prone, posing a barrier for software engineers attempting to leverage HLS for hardware design. Therefore, establishing an efficient and robust workflow for converting software code into HLS designs is crucial for agile hardware accelerator development.

[0004] To address these challenges in HLS development, existing technologies have proposed domain-specific language (LSL) approaches, providing simplified hardware kernel descriptions through script-based languages. While LSL-based solutions mitigate some coding flaws, they introduce additional learning curves, exhibit limited expressive power, and restrict their applicability in specific domains such as computational kernel optimization. Furthermore, traditional automated code-fixing methods attempt to directly identify and resolve compatibility issues between algorithms and HLS designs through code transformation, utilizing compilers to verify the equivalence between the original and transformed code. However, these automated solutions remain limited by template dependence and suboptimal convergence characteristics, requiring iterative verification and human supervision to ensure code synthesizability within HLS tools.

[0005] Given the complex challenges of traditional HLS design, industry and academia are actively exploring innovative solutions to simplify the development process and reduce the burden on developers. Integrating Large Language Models (LLMs) into the hardware design workflow is a promising approach. LLMs demonstrate exceptional capabilities in code understanding and generation, and can be effectively applied to the generation and debugging of hardware description language code, with the potential for automatic conversion, enhanced optimization processes, and reduced manual intervention. While initial applications in hardware description languages ​​have demonstrated code generation and debugging capabilities through various methods, challenges remain regarding syntactic correctness and quality assurance.

[0006] The limitations of LLM in hardware description language applications have spurred research interest in HLS. HLS uses the C language to abstract hardware designs into algorithmic representations, while the performance of LLM on specific tasks is related to the size and quality of the dataset used for training. Since C and C++ are mainstream programming languages, and a large number of high-quality datasets exist on open-source platforms, this suggests that LLM is better suited for handling high-level algorithms than hardware description languages. However, current LLMs have significant limitations in understanding the hardware constraints and optimization principles specific to HLS code, leading to unreliable code generation and frequent algorithm incompatibility errors. Furthermore, obtaining HLS code is limited by the need for specialized development environments and hardware design expertise, making it difficult to construct large amounts of high-quality datasets to enhance the capabilities of LLM.

[0007] Optimizing the HLS algorithm requires exploring a complex design space. The combination of numerous design optimization instructions and their non-linear impact on performance necessitates extensive optimization experience. Furthermore, incorrect instruction allocation can lead to resource over-utilization and synthesis errors. These constraints can result in suboptimal instruction selection and location allocation, ultimately affecting the quality of the hardware implementation.

[0008] In summary, HLS utilizes C language algorithm abstraction for hardware design, enabling LLM (Limited Language Modeling) proficiency in mainstream programming languages ​​to be effectively applied to hardware development. However, LLM-based HLS design and optimization face challenges; the automated algorithm-to-hardware conversion process remains error-prone, inefficient, and insufficiently optimized. Summary of the Invention

[0009] Objective: In order to overcome the shortcomings of the existing technology, the present invention provides a systematic high-level integrated automated processing method, device, equipment, storage medium and program product, which relates to high-level integration technology, as well as large language model fine-tuning and automated dataset construction technology.

[0010] Technical solution: To solve the above technical problems, the technical solution adopted by the present invention is as follows:

[0011] Firstly, a systematic, high-level, integrated, and automated processing method includes:

[0012] The software code is processed by a large language model proxy system responsible for algorithm conversion to obtain the initial HLS design.

[0013] Based on the design metrics requirements, the initial HLS design is iteratively optimized through a large language model proxy system responsible for design optimization to obtain the target HLS design.

[0014] During the generation of the target HLS design, if an error exists in the intermediate HLS design generated during the generation process, the generation process is interrupted. The intermediate HLS design and the corresponding error information are input into the large language model agent system responsible for code correction for iterative error correction processing, and the generation process continues after the intermediate HLS design is correct. The error information of any HLS design is obtained by performing functional verification on the corresponding HLS design.

[0015] One alternative approach involves using a large language model proxy system responsible for algorithm transformation to perform algorithm transformation on the software code, resulting in the initial HLS design, specifically including:

[0016] Extract loop and array parameter information from the software code, add tagged comments to the corresponding code segments, and generate refactored code;

[0017] The refactored code is transformed by a large language model proxy system responsible for algorithm transformation to obtain the initial HLS design.

[0018] Among them, the large language model agent system responsible for algorithm conversion supports the mounting of retrieval enhancement generation technology retrieval guidance information. The initial HLS design supports the conversion of the refactored code based on the guidance information, which includes HLS design specifications and / or specific code constraints.

[0019] One alternative approach involves a large language model proxy system responsible for design optimization, comprising: a large language model proxy system for design space exploration and a large language model proxy system for code transformation. Based on design metric requirements, the initial HLS design is iteratively optimized using the large language model proxy system responsible for design optimization to obtain the target HLS design, specifically including:

[0020] An optimized instruction allocation strategy is generated based on the initial HLS design and corresponding optimization metrics by using a large language model agent system for space exploration.

[0021] An optimized HLS design is generated based on an optimized instruction assignment strategy using a large language model proxy system for code warping.

[0022] If the optimized HLS design meets the iteration stopping condition, the optimized HLS design is taken as the target HLS design; otherwise, the optimized HLS design and corresponding optimization indicators are input into the large language model agent system for design space exploration for iteration until the target HLS design is obtained. The iteration stopping condition includes that the optimization indicators meet the design indicator requirements. The corresponding optimization indicators of any HLS design are obtained by comprehensive processing of the corresponding HLS design. The optimization indicators include performance indicators and / or resource utilization indicators.

[0023] One alternative is that the large language model agent system responsible for code correction includes: a large language model agent system for error analysis and a large language model agent system for code repair; for HLS designs with errors, the large language model agent system responsible for code correction performs iterative error correction processing in the following ways:

[0024] The large language model agent system used for error analysis reads the error codes and corresponding error information of the HLS design that has errors. After a reasoning process of error location, cause analysis and modification suggestions, it generates a debugging strategy.

[0025] The large language model agent system used for code repair modifies the erroneous code according to the debugging strategy, resulting in the repaired HLS design;

[0026] Functional verification was performed on the repaired HLS design, and the verification results were obtained.

[0027] If the verification result indicates that there is an error in the repaired HLS design, the process is iterated based on the repaired HLS design and the corresponding error information until a correct HLS design is obtained. The error information of any HLS design is extracted from the verification result obtained by performing functional verification on the corresponding HLS design.

[0028] An alternative approach is to iterate based on the corrected HLS design and the corresponding error information if the verification results indicate an error in the corrected HLS design, until a correct HLS design is obtained. This includes:

[0029] If the verification result indicates that there is an error in the repaired HLS design, the large language model agent system used for error analysis reads the error code and corresponding error information of the repaired HLS design and iterates until the correct HLS design is obtained.

[0030] Alternatively, if the verification results indicate that there is an error in the repaired HLS design, the repaired HLS design and the corresponding error information are input into the large language model agent system that evaluates the optimal correction strategy. The multi-terminal large language model synthesis system generates multiple debugging suggestions, and the evaluation model evaluates the multiple debugging suggestions and selects the optimal solution to construct a new round of debugging strategy. The evaluation dimensions for evaluating the multiple debugging suggestions include at least one of the following: simulation synthesis results, code logic integrity, and the extent of modification to the source code by the debugging suggestions.

[0031] A new round of debugging strategies is input into the large language model agent system used for code repair, so as to modify the erroneous code in the repaired HLS design until the correct HLS design is obtained.

[0032] One alternative approach, for any given HLS design, is to perform functional verification of the corresponding HLS design in the following ways:

[0033] The simulation tools in the HLS tool suite are used to perform syntax verification on the HLS design, and the correctness of the HLS design functionality is verified by combining the test files, thereby obtaining the compilation information corresponding to the simulation stage.

[0034] The HLS design, simulated, is then synthesized using the synthesis tools within the HLS suite to obtain compilation information for the synthesis phase.

[0035] The compilation information generated by the HLS tool is read, and the success of the corresponding stage is identified based on the extracted compilation information. The corresponding execution results are then extracted as the verification results for functional verification. If the synthesis stage is successful, the corresponding execution results include performance indicators and resource utilization indicators. If any stage fails, the corresponding execution results include error information.

[0036] One alternative approach involves a large language model agent system designed and optimized, including a large language model agent system for design space exploration. This system is fine-tuned based on a specially constructed dataset. The construction of the specialized dataset includes:

[0037] Obtain information on multiple HLS designs to be optimized and their corresponding array and loop parameters;

[0038] By employing a design space exploration based on genetic algorithms and HLS optimization instruction insertion techniques, multiple HLS designs to be optimized are optimized to obtain corresponding candidate HLS designs.

[0039] Obtain the quality metrics of results from multiple candidate HLS designs;

[0040] Filter multiple candidate HLS designs to obtain at least one optimized HLS design sample; the result quality indicators of any optimized HLS design sample meet the result quality indicator requirements, including: performance indicators and / or resource utilization indicators.

[0041] A dedicated dataset is constructed based on the optimized HLS design samples, the corresponding HLS designs to be optimized, the corresponding result quality indicators, and the corresponding array and loop parameter information.

[0042] One alternative is that the large language model agent system responsible for code correction includes a large language model agent system for error analysis, which is obtained by directly optimizing the fine-tuned model based on the fine-tuned dataset after model fine-tuning.

[0043] Secondly, a systematic, high-level integrated automated processing device specifically includes:

[0044] The algorithm conversion module is used to perform algorithm conversion processing on the software code through the large language model proxy system responsible for algorithm conversion, so as to obtain the initial HLS design;

[0045] The design optimization module is used to iteratively optimize the initial HLS design based on design metrics requirements, through a large language model proxy system responsible for design optimization, to obtain the target HLS design.

[0046] The code correction module is used to interrupt the generation process of the target HLS design if there is an error in the intermediate HLS design generated during the generation process. The intermediate HLS design and the corresponding error information are input into the large language model agent system responsible for code correction for iterative error correction processing, and the generation process continues after the intermediate HLS design is correct. The error information of any HLS design is obtained by performing functional verification on the corresponding HLS design.

[0047] Thirdly, a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements a systematic, high-level integrated automated processing method as described in any of the first aspects.

[0048] Fourthly, a computer device comprising:

[0049] Memory is used to store instructions.

[0050] A processor for executing the instructions, causing the computer device to perform operations of a systematic, high-level integrated automated processing method as described in any of the first aspects.

[0051] Fifthly, a computer program product includes a computer program adapted to be loaded by a processor and executed as a systematic, high-level integrated automated processing method as described in any of the first aspects.

[0052] Beneficial Effects: The systematic high-level synthesis automated processing method, apparatus, equipment, storage medium, and program products provided by this invention, through large language model driving and the coordination of multiple parsing tools, realize the conversion of algorithms to high-level synthesis and design optimization. A fine-tuned (open-source) large language model proxy system is used to execute the key technology chain structure and communication, significantly improving design optimization and code error correction capabilities. The entire design process is coupled through the model proxy system and high-level synthesis tools, ensuring a high degree of automation and design correctness. An optimization and error correction iterative system is provided to overcome the limitations of one-time model inference. This invention can reduce the gap between algorithm development and hardware design, lower the design experience threshold, and improve chip design efficiency.

[0053] A platform for implementing a systematic high-level synthesis automation method (referred to as the systematic high-level synthesis design and optimization platform) leverages artificial intelligence's capabilities in code writing and hardware design analysis to enable agile development of high-level synthesis designs. The platform consists of an HLS design generation module and an HLS design debugging module, significantly shortening the lengthy development process from algorithm design to hardware implementation and lowering the barrier to hardware design optimization. This platform features a highly automated and robust design process and rapid optimization space exploration capabilities, expanding the application of large-scale language models in chip development and solving technical problems such as the inability of existing artificial intelligence to organically integrate with high-level synthesis design development and the high barriers between algorithm developers and hardware designers.

[0054] Compared with the prior art, the technical solution of the present invention has the following advantages and beneficial effects:

[0055] (1) The improved hierarchical synthesis design and optimization platform of this invention realizes the construction and communication of key technology chains through a large language model proxy system, making full use of the capabilities of large language models in task reasoning and code processing, significantly shortening the time and manpower costs from algorithm development to hardware design, and providing a new paradigm for next-generation design automation technology. This paradigm can effectively reduce the experience threshold required for hardware design and optimization, and greatly improve chip design efficiency. Among them, the HLS design generation module can accelerate the agile development process of HLS, provide efficient design space exploration functions, and reduce the difficulty of hardware optimization; the HLS design debugging module can solve the problem of incompatibility between the HLS code generated by the large language model and the native HLS algorithm, improve the correctness of the HLS design code generated by the platform, and significantly reduce the cost of manual error correction.

[0056] (2) The fine-tuning technology for agents of specific large language models proposed in this invention significantly improves the processing capabilities of HLS design optimization and code correction agents, enabling open-source models with a small number of parameters to rival or even surpass the most advanced closed-source models in terms of inference capabilities. Through fine-tuning, the agent responsible for design optimization can deeply analyze the performance bottlenecks and optimization space of the current design, thereby improving the ability to optimize instruction scheduling and generating HLS designs with better optimization effects; the agent responsible for code correction can accurately analyze the error codes and their corresponding error messages, and provide correction suggestions and specific correction processes, significantly improving the success rate of error code repair and ensuring that the designs generated by the platform have higher robustness.

[0057] (3) The entire process of HLS design generation, optimization, and debugging proposed in this invention is achieved through the organic coupling of the large language model proxy system and the HLS tool. The large language model proxy system ensures a high degree of automation in the development process, while the HLS tool verifies and calibrates the HLS design at each stage of the process. During algorithm conversion and design optimization, the generated intermediate HLS design is simulated and synthesized using the HLS tool before entering the next process or iteration. For designs with errors, the system prioritizes sending them to the debugging module for code correction, thereby reducing manual intervention while ensuring the reliability of the output results.

[0058] (4) The development process described in this invention requires a large amount of information to construct the reasoning chain and to provide sufficient corpus for the large language model to improve the quality of the output content. However, using commercial closed-source models may incur high costs due to processing a large number of semantic units. To this end, the platform of this invention adopts an open-source model as a proxy for the key large language model, and uses fine-tuning technology to ensure that the performance of the open-source model is not inferior to that of the closed-source model, thereby significantly reducing development costs and lowering the barrier to entry for users.

[0059] (5) The platform proposed in this invention is user-friendly, providing an interface for inputting the original algorithm and an interface for setting the quality requirements of the design optimization results during the development process. Users can set specific optimization directions and acceptable margins by writing prompts according to different development needs, design costs, and performance priorities. The overall development process is highly flexible and transparent, and can meet diverse user needs.

[0060] (6) The platform optimization and error correction processes proposed in this invention are both equipped with an iterative system to improve the ability to handle complex tasks and overcome the "illusion" problem that may occur in a single inference output of a large language model. The iterative mechanism of the design optimization process can achieve a trade-off between performance and design cost by repeatedly exploring the design space, and meet the user's expected indicators of result quality within a certain number of iterations; the iterative system of the code error correction process can further handle complex or unidentified problems, thereby improving the coverage of design verification and ensuring the robustness of the platform development process.

[0061] (7) The HLS designs generated by the platform proposed in this invention have all been simulated and synthesized for verification, and implemented in a specific hardware structure. By optimizing the design under the constraints of target hardware resources, the platform can provide front-end analysis of the resource consumption and expected performance required for hardware implementation, providing effective support for specific hardware implementation.

[0062] (8) The HLS design generation module and debugging module proposed in this invention have low coupling and can be used or optimized independently. The generation module can be used alone to generate HLS designs, while the debugging module can be used independently to correct erroneous HLS designs, and is not limited to algorithm conversion or design optimization processes. This modular design further enhances the flexibility and applicability of the platform. Attached Figure Description

[0063] Figure 1 This is a flowchart illustrating a systematic, high-level, integrated, and automated processing method provided in this embodiment.

[0064] Figure 2 This is a schematic diagram illustrating the specific construction method of the large language model proxy system responsible for algorithm conversion provided in the embodiment.

[0065] Figure 3 This is a schematic diagram illustrating the specific construction method of the large language model agent system responsible for design and optimization provided in the embodiment.

[0066] Figure 4 This is a schematic diagram illustrating the specific construction method of the large language model agent system responsible for code correction provided in the embodiment.

[0067] Figure 5 This is a schematic diagram of another systematic, high-level integrated automated processing method provided in the embodiment.

[0068] Figure labeling: LLM1, Large Language Model Agent System responsible for algorithm transformation; LLM2, Large Language Model Agent System for design space exploration; LLM3, Large Language Model Agent System for code transformation; LLM4, Large Language Model Agent System for error analysis; LLM5, Large Language Model Agent System for code repair; LLM6, One of the large language models in the multi-terminal large language model complex; LLM7, Evaluation model. Detailed Implementation

[0069] The technical solution of the present invention will be described in detail below with reference to specific examples and accompanying drawings. Those skilled in the art can easily understand the advantages and effects of the present invention through the content disclosed in this specification. The present invention can also be implemented or applied through other different specific embodiments, and the details in this specification can also be modified or changed based on different viewpoints and applications without departing from the principles of the present invention.

[0070] It should be noted that the illustrations provided in this embodiment are merely examples to illustrate the basic principles, module structure, working process, and output results of the present invention. Therefore, the illustrations only show modules related to the present invention and do not represent the specific types of large language models used in actual implementation. Furthermore, this embodiment only provides some examples of algorithm conversion, design optimization, and code debugging. In actual applications, the types of large language models and prompt words can be changed, and the applicable algorithm types are also more diverse.

[0071] Example 1:

[0072] This embodiment introduces a systematic, high-level, integrated, and automated processing method, such as... Figure 1 As shown, it specifically includes:

[0073] S101 uses a large language model proxy system responsible for algorithm conversion to perform algorithm conversion on the software code, resulting in the initial HLS design.

[0074] S102, based on design metrics requirements, uses a large language model proxy system responsible for design optimization to iteratively optimize the initial HLS design, resulting in the target HLS design.

[0075] S103, during the generation of the target HLS design, if there is an error in the intermediate HLS design generated during the generation process, the generation process is interrupted. The intermediate HLS design and the corresponding error information are input into the large language model agent system responsible for code correction for iterative error correction processing, and the generation process continues after the intermediate HLS design is correct. Among them, the error information of any HLS design is obtained by performing functional verification on the corresponding HLS design.

[0076] The software code can be code to be converted into hardware design. The software code can be written in a software programming language, such as C or C++. For ease of explanation, the software code will be referred to as the C algorithm in this application. Alternatively, the software code can be user input.

[0077] For one example, please refer to Figure 2 The large language model proxy system responsible for algorithm conversion is LLM1. Specifically, the LLM1 proxy system performs algorithm conversion on the software code to obtain an initial HLS design. This can include: extracting loop and array parameter information from the software code and adding tagged comments to the corresponding code segments to generate refactored code; then, the LLM1 proxy system converts the refactored code to obtain the initial HLS design. Optionally, to further improve the quality of the generated HLS design, the LLM1 proxy system can also support the attachment of retrieval guidance information using enhanced retrieval techniques. The initial HLS design can also be obtained by converting the refactored code based on this guidance information, which includes HLS design specifications and / or specific code constraints.

[0078] One example of generating refactored code may include:

[0079] Based on the C algorithm (i.e., software code), the parser is called to parse the source code and extract the position information of loops and arrays from the software code, including line numbers, global indices, and array names.

[0080] For array processing, the array declaration line is parsed to obtain the number of array dimensions and the size expression for each dimension. A temporary source file containing software code (which can be a C++ source file) is generated. The array size expression is replaced with specific values ​​through macro definitions. The size of each dimension of each array is output in the main function. The temporary file is compiled and run, the output results are read and stored, and the size of each array dimension is reconstructed.

[0081] For loop processing, static analysis can be performed using the LLVM (Low Level Virtual Machine) compiler. By calling the LLVM optimization tool, statistical information such as the number of loop iterations can be obtained. The output of the LLVM compiler can be parsed to extract loop analysis information related to the current source file and store it in the loop statistics data structure.

[0082] Add comments to the corresponding locations in the source code to generate the refactored code, marking the positions of loops and arrays for easier subsequent processing.

[0083] Optionally, the extracted array and loop parameter information can be written to a kernel information file in a specific format. Optionally, for array parameters, the information can include its identifier, name, number of dimensions, and size of each dimension; for loop parameters, the information can include its identifier, name, and iteration boundaries. This parameter information can be used in subsequent targeted code modifications and performance optimization processes.

[0084] One example illustrates a search enhancement generation technique.

[0085] In terms of vector database construction: the original text data can be obtained; the original text data can be divided into blocks to obtain text blocks; the text blocks can be vectorized to obtain embedding vectors; the embedding vectors and the corresponding text blocks can be stored together to build a vectorized database; the constructed vector database can support fast similarity retrieval.

[0086] The original text data can include domain-related text data, such as, but not limited to, official documents, technical manuals, expert guidance, and relevant forum information. Segmenting the original text data can improve the efficiency and accuracy of text processing. Specifically, the original text data can be segmented according to a specified character length for each segment. Optionally, the segmentation can be based on a specified character length while maintaining a preset character overlap between adjacent text segments. The specified character length and the preset character length can be set according to requirements; for example, the specified character length can be 1000 characters, 1500 characters, etc., and the preset character length can be 200 characters, 300 characters, etc. This segmentation strategy ensures the integrity of the text semantics while preserving contextual information, avoiding the loss of important information due to text segmentation. Specifically, a recursive character segmentation method can be used to implement the segmentation of the original text data. Vectorizing text blocks can effectively represent text data. Specifically, a pre-trained text embedding model can be used to vectorize text blocks to obtain embedding vectors. The text embedding model is responsible for converting each text block into a high-dimensional vector representation and normalizing the vector representation during the encoding process to obtain the embedding vector, thereby ensuring the accuracy of similarity calculation in the vector space.

[0087] In terms of prompt word retrieval and design generation: Algorithm conversion requirements can be obtained; the conversion requirements and reconstructed code are input into a preset prompt word template, and the initial prompt words are converted into embedding vectors using a text embedding model. A retrieval operation is performed in the vector database. Based on semantic similarity calculation, one or more text blocks in the vectorized database that are most similar to the embedded vectors are selected as contextual information (i.e., guidance information). This fast similarity retrieval method based on semantic similarity can quickly find the most relevant content to the query in a large amount of text data, improving the accuracy and efficiency of the retrieval.

[0088] The retrieved contextual information is fused with the initial prompt words to form complete prompt words, generating a standard input format that conforms to the understanding of the large language model. LLM1 is then called to process the standard input format, generating an initial answer. The initial answer is then parsed to obtain the initial HLS design. The algorithm's transformation requirements can be user-inputted, for example, extracted from the user's query question; the contextual information can include HLS design specifications and / or specific code constraints. This initial HLS design satisfies these constraints, ensuring the quality of the generated results.

[0089] In one feasible implementation, during the generation of the initial HLS design, algorithm transformation requirements can also be obtained. These requirements and the refactored code are then input into a preset prompt word template to form initial prompt words, generating a standard input format that conforms to the understanding of a large language model. LLM1 is then called to process the standard input format, generating an initial response. The initial response is then parsed to obtain the initial HLS design.

[0090] In one embodiment, the large language model agent system responsible for design optimization can be implemented by two large language model agents. Specifically, the large language model agent system responsible for design optimization can include: a large language model agent system for design space exploration and a large language model agent system for code warping. The large language model agent system for design space exploration can be used to generate optimized instruction allocation strategies, and the large language model agent system for code warping can be used to generate optimized HLS designs. Please refer to [link to relevant documentation]. Figure 3The large language model agent system used for design space exploration is LLM2, and the large language model agent system used for code transformation is LLM3. Specifically, based on design performance requirements, the initial HLS design is iteratively optimized using the large language model agent system responsible for design optimization to obtain the target HLS design. This can include: generating an optimized instruction allocation strategy based on the initial HLS design and corresponding optimization metrics using the large language model agent system for design space exploration; generating an optimized HLS design based on the optimized instruction allocation strategy using the large language model agent system for code transformation; if the optimized HLS design meets the iteration stopping condition, it is used as the target HLS design; otherwise, the optimized HLS design and corresponding optimization metrics are input into the large language model agent system for design space exploration for iteration until the target HLS design is obtained. The iteration stopping condition includes that the optimization metrics meet the design performance requirements. The optimization metrics for any HLS design are obtained through comprehensive processing of the corresponding HLS design, and the optimization metrics include performance metrics and / or resource utilization metrics.

[0091] In one embodiment, when generating an optimization instruction allocation strategy based on the current HLS design (e.g., the initial HLS design) and corresponding optimization metrics using a large language model agent system (LLM2) for design space exploration, the following steps can be taken: Analyze the current HLS design, combine the corresponding optimization metrics (including performance metrics and / or resource utilization metrics) and loop / array parameter information, and generate a detailed strategy (i.e., optimization instruction allocation strategy) for inserting optimization instructions to optimize the design, guided by prompts. This detailed strategy for inserting optimization instructions to optimize the design may include at least one of the following: the code segment to be optimized, the inserted optimization instructions, and the rationale for each optimization step and its expected impact on performance, power consumption, and area.

[0092] Specifically, in generating a detailed strategy for inserting optimization instructions to optimize the design, LLM2 can: accurately identify optimizable target locations using label information in the current HLS design; evaluate the potential design space using loop and array parameter information and the result quality indicators of the current HLS design (i.e., the corresponding optimization indicators of the current HLS design); and effectively allocate instruction combinations using the given optimization instruction descriptions to obtain a detailed strategy for inserting optimization instructions to optimize the design (i.e., optimization instruction allocation strategy).

[0093] Furthermore, through the Large Language Model Agent System (LLM3) for code warping, an optimized HLS design can be generated based on an optimization instruction allocation strategy. Specifically, LLM3 can perform optimization instruction insertion tasks based on the optimization instruction allocation strategy to achieve code warping and obtain the optimized HLS design. Optionally, to ensure the accuracy of code warping, the corresponding prompts in LLM3 indicate that when optimizing arrays or loops, the optimization instruction should be inserted immediately after the statement to be optimized.

[0094] Furthermore, if the optimized HLS design meets the iteration stopping condition, it is taken as the target HLS design; otherwise, the optimized HLS design and corresponding optimization indicators are input into the large language model agent system used for design space exploration for iteration until the target HLS design is obtained. That is, the optimized HLS design and its corresponding optimization indicators are input into the large language model agent system used for design space exploration to generate a new optimization instruction allocation strategy. Based on the new instruction allocation strategy, subsequent processing such as code transformation is performed on the optimized HLS design to achieve iterative processing. The iteration stopping condition includes reaching a preset maximum number of iterations or the optimization indicators meeting the design requirements (i.e., if the optimized HLS design meets the design requirements, it is taken as the target HLS design). Optimization indicators include performance indicators and / or resource utilization indicators. This automated iterative optimization method can effectively improve the quality of design optimization and reduce manual intervention.

[0095] The optimization index for any HLS design is obtained by synthesizing the corresponding HLS design. In other words, after obtaining the optimized HLS through LLM3, the optimized HLS design can be synthesized to obtain the optimization index. This synthesis process can be achieved using synthesis tools.

[0096] In one embodiment, during the generation of the target HLS design, if an error exists in the intermediate HLS design generated during the generation process, the generation process is interrupted. The intermediate HLS design and corresponding error information are input into the large language model agent system responsible for code correction for iterative error correction processing. The generation process continues after the intermediate HLS design is correct. Here, the error information for any HLS design is obtained by functionally verifying the corresponding HLS design. In other words, during the generation of the target HLS design, the intermediate HLS design generated during the generation process can be functionally verified to obtain verification results. If the verification results indicate that the intermediate HLS design contains an error, the generation process is interrupted and enters an automated debugging process. That is, the intermediate HLS design and corresponding error information are input into the large language model agent system responsible for code correction for iterative error correction processing to make the intermediate HLS design correct. The intermediate HLS generated during this generation process can include HLS designs obtained from the algorithm conversion process (i.e., the initial HLS design), HLS designs obtained from the automated optimization process (including HLS designs processed by LLM3, i.e., the optimized HLS design), and other HLS designs that require functional verification.

[0097] In one embodiment, functional verification of an HLS design may include a simulation phase and a synthesis phase; alternatively, functional verification of an HLS design can be performed using HLS tools; specifically, for any HLS design, the methods for functional verification of the corresponding HLS design include:

[0098] The HLS design is syntax-checked using simulation tools within the HLS suite, and its functional correctness is verified using test files, yielding compilation information for the simulation phase. The simulated HLS design is then synthesized using the synthesis tools within the HLS suite, generating compilation information for the synthesis phase. The compilation information generated by the HLS suite is read, and based on this extracted information, the success or failure of each phase is identified, with the corresponding execution results extracted as the functional verification results. If the synthesis phase succeeds, the execution results include performance metrics and resource utilization metrics; if any phase fails, the execution results include error messages. Extraction of verification results from the compilation information can be based on predefined rules and regular expressions; parsing the verification results from the compilation information can be achieved using parsing tools.

[0099] The simulation tools in HLS can also be called C simulation, and the synthesis tools can also be called C synthesis. Based on this, the C simulation in HLS tools can be used to perform syntax verification on the HLS design, and combined with test files, to verify the functional correctness of the HLS design. The simulated HLS design can be used to obtain the performance indicators and resource utilization indicators of the synthesized HLS design (assuming successful synthesis). During the data processing flow, problems such as syntax errors, functional errors, algorithm incompatibility, and optimization instruction violations may occur during simulation and synthesis. HLS tools will provide complete compilation information, including detailed errors and warnings. Based on this, the compilation information can be parsed (using parsing tools) to extract key error information for automated debugging and optimization. Optionally, the extracted error information can be summarized into a structured file, which is easy for large language models to understand and facilitates efficient subsequent automated debugging and optimization processes.

[0100] The compilation information can be provided in the form of a compilation log file. Based on this, the parsing tool can read the compilation log file generated by the HLS tool (i.e., read the compilation information) and extract the execution results of the simulation and synthesis tools from the log using predefined rules and regular expressions. For the simulation phase, the parsing tool checks whether the simulation was successful. If it fails, it records the reason for the failure, such as simulation timeout, compilation error, or runtime error, and collects detailed error information to obtain the corresponding execution result. For the synthesis phase, the parsing tool determines whether the synthesis was successful. If the synthesis fails, it extracts the reason for the failure, such as code synthesis timeout or unsupported code structure, collects relevant warnings and error information, and obtains the corresponding execution result. Optionally, predefined error categories can be defined according to key information. Through this systematic error information extraction and classification method, this design verification function can achieve efficient monitoring and error localization of the entire HLS design process, providing an accurate problem diagnosis basis for subsequent automated debugging. In one optional implementation, the information recorded during the simulation phase (e.g., the recorded reasons for failure) and the information collected (e.g., the collected error information) can both be recorded as error information in the simulation phase execution results for use in automated debugging (i.e., automated error correction) and optimization processes; the information recorded during the synthesis phase (e.g., the recorded reasons for failure) and the information collected (e.g., the collected warnings and error information) can both be recorded as error information in the synthesis phase execution results for use in automated debugging (i.e., automated error correction) and optimization processes.

[0101] In one embodiment, the large language model agent system responsible for code correction may include: a large language model agent system for error analysis (referred to as LLM4) and a large language model agent system for code repair (referred to as LLM5). For an HLS design with errors, the large language model agent system responsible for code correction performs iterative error correction processing as follows: the large language model agent system for error analysis reads the error code and corresponding error information of the erroneous HLS design, and generates a debugging strategy through a reasoning process of error location, cause analysis, and modification suggestion summary; the large language model agent system for code repair modifies the error code according to the debugging strategy to obtain a repaired HLS design; functional verification is performed on the repaired HLS design to obtain a verification result; if the verification result indicates that the repaired HLS design has an error, iterative processing is performed based on the repaired HLS design and the corresponding error information until a correct HLS design is obtained; wherein, the error information of any HLS design is extracted from the verification result obtained from the functional verification of the corresponding HLS design.

[0102] In one feasible implementation, if the verification result indicates an error in the repaired HLS design, the process iterates based on the repaired HLS design and corresponding error information until a correct HLS design is obtained. Specifically, this may include: if the verification result indicates an error in the repaired HLS design, the large language model agent system used for error analysis reads the error code and corresponding error information of the repaired HLS design and iterates until a correct HLS design is obtained. In other words, if the verification result indicates an error in the repaired HLS design, LLM4 can generate a new debugging strategy based on the error code and corresponding error information of the repaired HLS design, and LLM5 can modify the error code of the repaired HLS design according to the new debugging strategy to achieve iteration.

[0103] Please see Figure 4In another feasible implementation, if the verification result indicates an error in the repaired HLS design, the process iterates based on the repaired HLS design and corresponding error information until a correct HLS design is obtained. Specifically, this may include: if the verification result indicates an error in the repaired HLS design, inputting the repaired HLS design and corresponding error information into a large language model agent system that evaluates the optimal correction strategy. The included multi-terminal large language model synthesis system generates multiple debugging suggestions, which are then evaluated by an evaluation model to select the optimal solution for constructing a new round of debugging strategy. The evaluation dimensions for the multiple debugging suggestions include at least one of the following: simulation synthesis results, code logic integrity, and the extent of source code modification by the debugging suggestions. The new round of debugging strategy is then input into the large language model agent system used for code repair to modify the erroneous code in the repaired HLS design until a correct HLS design is obtained. This iterative process is a feedback-enhanced iterative process.

[0104] In other words, the automated debugging process consists of two parts. The first part is direct code repair, including an agent (LLM4) for analyzing the causes of code errors and providing modification suggestions, and an agent (LLM5) for performing code rewriting. The second part is feedback-enhanced iterative code repair, which can utilize multiple large language models from different sources (multiple LLM6s) to propose different solutions to the same problem. The evaluation agent (LLM7) selects the optimal modification strategy based on scoring criteria, thereby improving the quality of modification suggestions and increasing the accuracy of code repair. Based on this, LLM4 reads the error code and error information, and through a reasoning process of error location, cause analysis, and modification suggestion summary, generates a detailed debugging strategy. LLM5 strictly modifies the error code according to the debugging strategy to obtain the repaired HLS design. The repaired HLS design is then input into the HLS tool for functional verification. Optionally, after the repaired HLS design has been functionally verified, its optimization metrics can be evaluated to see if they meet expectations (i.e., whether the optimization metrics meet the design requirements). If the performance of the optimized design is not improved, it is considered a new error, and targeted optimization instructions are corrected, i.e., the optimization process continues.

[0105] Error codes and messages in HLS designs that fail design verification are detected and collected. These are then fed into multiple LLM6 modules to generate multiple debugging suggestions. LLM7 evaluates these suggestions based on simulation and synthesis results, code logic integrity, and the extent of source code modifications made according to the debugging suggestions, selecting the optimal solution to build a new round of code debugging strategy. LLM5 then corrects the error codes according to this new debugging strategy. The corrected code (i.e., the further corrected HLS design) is then input into the HLS tool for verification. If errors still exist, the process continues iteratively until the code passes verification, thus achieving automated debugging of the HLS design.

[0106] In one embodiment, the large language model agent system responsible for design optimization includes a large language model agent system (and LLM2) for design space exploration. This large language model agent system for design space exploration is fine-tuned based on a constructed dedicated dataset. Based on this, a genetic algorithm-based design space exploration, HLS optimization instruction insertion technology, and result quality index threshold filtering method can be used to collect code samples that meet optimization performance standards, along with their loop and array information. Combined with corresponding result quality indices, a dedicated dataset is constructed. Specifically, the construction of the dedicated dataset can include: obtaining multiple HLS designs to be optimized and their corresponding array and loop parameter information; using a genetic algorithm-based design space exploration and HLS optimization instruction insertion technology to optimize the multiple HLS designs to obtain corresponding candidate HLS designs; obtaining result quality indices for the multiple candidate HLS designs; filtering the multiple candidate HLS designs to obtain at least one optimized HLS design sample; ensuring that the result quality index of any optimized HLS design sample meets the result quality index requirements, including performance indicators and / or resource utilization indicators; and constructing the dedicated dataset based on the optimized HLS design sample, the corresponding HLS designs to be optimized, the corresponding result quality indices, and the corresponding array and loop parameter information.

[0107] The optimization phase, which employs a design space exploration based on genetic algorithms and HLS optimization instruction insertion techniques, can be specifically described as follows:

[0108] By defining the HLS design optimization problem, a multi-objective optimization problem class is constructed that combines source code paths, variable information, top-level functions, optimization instruction sets, etc., aiming to improve the performance and resource utilization of HLS design by adjusting the combination of optimization instructions and configuration parameters.

[0109] In the implementation of the genetic algorithm, a non-dominated sorting genetic algorithm is used as the multi-objective optimization strategy, with key parameters including population size, crossover method, mutation method, and selection method. After initializing the population, the non-dominated sorting genetic algorithm evolves generation by generation through genetic operations such as selection, crossover, and mutation, continuously searching for optimal solutions in the design space. During each generation of evolution, the code evaluates the instruction combination corresponding to each individual in the current population and generates corresponding HLS optimization instructions. These optimization instructions are inserted at appropriate locations in the source code to optimize loops and arrays.

[0110] During the optimization process, the code continuously monitors termination conditions, including the convergence of the objective function, the maximum number of algebras, and the number of evaluations. At the same time, the HLS design for each iteration is saved, and the algorithm stops evolving when the termination conditions are met.

[0111] Specifically, in the stages of result quality index threshold filtering and dataset construction, the following can be done: By setting specific thresholds for the Pareto optimal solution and the original design result quality index of different HLS designs after genetic algorithm iterations, intermediate designs that do not meet performance and resource utilization requirements are filtered out. Finally, multiple HLS design optimization samples are collected, and a large language model is used to reason about the optimized design and the quality index of its synthesis. This analyzes how the inserted optimization instruction combinations affect loops, arrays, and the overall design, thus forming a complete design space exploration reasoning chain. This chain is used to construct a rich dataset, and the fine-tuned LLM2 exhibits high design space exploration capabilities.

[0112] In one embodiment, the large language model agent system responsible for code correction includes a large language model agent system for error analysis (i.e., LLM4). The large language model agent system for error analysis can be obtained by fine-tuning the model based on the fine-tuning dataset, or it can be obtained by directly optimizing the fine-tuned model based on preferences.

[0113] For the fine-tuning dataset construction and model fine-tuning process, the following can be done: Error injection methods can be used to transform the original design's code. After filtering, the generated error codes and messages are used by a large language model in conjunction with the correct code before transformation to locate the error, analyze its causes, and provide specific modification suggestions, forming a reasoning chain for code correction. A broad dataset can be constructed, and error code samples can be compiled, covering different types of HLS designs and different types of errors. The dataset can then be used to fine-tune LLM4, enhancing its ability to generate appropriate debugging strategies for error-prone HLS designs.

[0114] Furthermore, Direct Preference Optimization (DPO) offers stability, high performance, and lightweight computation. Given the challenges of applying reinforcement learning to large-scale problems, DPO proposes a simple method for policy optimization that directly utilizes preferences. Unlike previous reinforcement learning methods, this technique skips the reward modeling step and directly optimizes large language models using preference data. Specifically, it involves decoupling the reasoning chain construction method during fine-tuning, directly correcting erroneous codes through reasoning, and constructing a preference dataset using the reasoning chain method. Applying this technique to the fine-tuned model further improves the error correction success rate.

[0115] Please see Figure 5This is a schematic diagram of another systematic high-level integrated automated processing method provided in the embodiments of this application; it can: input the C algorithm (i.e., software code) into a large language model proxy system that is equipped with retrieval enhancement generation technology and is responsible for algorithm conversion; the large language model proxy system responsible for algorithm conversion outputs the initial HLS design; input the initial HLS design and design index requirements into a large language model proxy system responsible for design optimization that has been fine-tuned; the HLS design output by the large language model proxy system responsible for design optimization is processed by the HLS tool and iterated a finite number of times to obtain the target HLS design; if there are errors in the intermediate HLS design generated during the generation process of the target HLS design, the generation process is interrupted, and the intermediate HLS design is input into a large language model proxy system responsible for code correction that has been fine-tuned and directly preferred optimized; through feedback enhancement iteration technology, the final design function is ensured to be correct and the optimization effect meets the standards; according to the verification requirements, the intermediate HLS design can be functionally verified by the HLS tool and parsing tool that includes simulation tools and synthesis tools.

[0116] Example 2:

[0117] Based on the above description, embodiments of this application also disclose a systematic high-level integrated automated processing device; the device may be a computer program running in a computer device, and the device may execute the various steps in the systematic high-level integrated automated processing method proposed in this application; the device may include an algorithm conversion module, a design optimization module, and a code error correction module; wherein:

[0118] The algorithm conversion module is used to perform algorithm conversion processing on the software code through the large language model proxy system responsible for algorithm conversion, so as to obtain the initial HLS design;

[0119] The design optimization module is used to iteratively optimize the initial HLS design based on design metrics requirements, through a large language model proxy system responsible for design optimization, to obtain the target HLS design.

[0120] The code correction module is used to interrupt the generation process of the target HLS design if there is an error in the intermediate HLS design generated during the generation process. The intermediate HLS design and the corresponding error information are input into the large language model agent system responsible for code correction for iterative error correction processing, and the generation process continues after the intermediate HLS design is correct. The error information of any HLS design is obtained by performing functional verification on the corresponding HLS design.

[0121] It is understood that the various modules in the aforementioned systematic high-level integrated automated processing device can be individually or entirely merged into one or more other modules, or some of the modules can be further divided into multiple functionally smaller modules. This achieves the same operation without affecting the technical effects of the embodiments of this application. For example, please refer to [link to example]. Figure 5 Another type of systematic, high-level integrated automated processing device may include an HLS design generation module and an HLS design debugging module. The HLS design generation module may include an algorithm conversion module for performing algorithm conversion-related processes and a design optimization module for performing design optimization-related processes. The HLS design debugging module may include a design verification module for performing functional verification-related processes and a code correction module for performing debugging-related processes.

[0122] Example 3:

[0123] This embodiment describes a computer-readable storage medium storing a computer program that, when executed by a processor, implements a systematic, high-level integrated automated processing method as described in any of Embodiment 1.

[0124] Example 4:

[0125] This embodiment describes a computer device, including:

[0126] Memory is used to store instructions.

[0127] A processor is configured to execute the instructions, causing the computer device to perform operations of a systematic high-level integrated automated processing method as described in any of Embodiment 1.

[0128] Example 5:

[0129] This embodiment describes a computer program product including a computer program stored in a computer-readable storage medium; the processor of a computer device reads the computer program from the computer-readable storage medium and executes the computer program, causing the computer device to perform a systematic high-level integrated automated processing method as described in any of Embodiment 1.

[0130] The above embodiments illustrate the basic principles, module structure, working process, and output results of the present invention by way of example, and are intended to explain rather than limit the application of the present invention. Any person skilled in the art can modify or alter the above embodiments without departing from the principles of the present invention. Therefore, all equivalent modifications or alterations made by those skilled in the art without departing from the principles and technical concepts disclosed in the present invention should be considered within the scope of protection of the present invention and are covered by the claims of the present invention.

[0131] The above description is only a preferred embodiment of the present invention. It should be noted that for those skilled in the art, several improvements and modifications can be made without departing from the principle of the present invention, and these improvements and modifications should also be considered within the scope of protection of the present invention.

Claims

1. A systematic, high-level, integrated, and automated processing method, characterized in that: Specifically, it includes: The software code is processed by a large language model proxy system responsible for algorithm conversion to obtain the initial HLS design. Based on the design metrics requirements, the initial HLS design is iteratively optimized through a large language model proxy system responsible for design optimization to obtain the target HLS design. During the generation of the target HLS design, if an error exists in the intermediate HLS design generated during the generation process, the generation process is interrupted. The intermediate HLS design and the corresponding error information are input into the large language model agent system responsible for code correction for iterative error correction processing, and the generation process continues after the intermediate HLS design is correct. The error information of any HLS design is obtained by performing functional verification on the corresponding HLS design.

2. The systematic high-level integrated automated processing method according to claim 1, characterized in that: The software code is processed through a large language model proxy system responsible for algorithm transformation to obtain the initial HLS design, which specifically includes: Extract loop and array parameter information from the software code, add tagged comments to the corresponding code segments, and generate refactored code; The refactored code is transformed by a large language model proxy system responsible for algorithm transformation to obtain the initial HLS design. Among them, the large language model agent system responsible for algorithm conversion supports the mounting of retrieval enhancement generation technology retrieval guidance information. The initial HLS design supports the conversion of the refactored code based on the guidance information, which includes HLS design specifications and / or specific code constraints.

3. The systematic high-level integrated automated processing method according to claim 1, characterized in that: The large language model proxy system responsible for design optimization includes: a large language model proxy system for design space exploration and a large language model proxy system for code transformation. Based on design metric requirements, the initial HLS design is iteratively optimized through the large language model proxy system responsible for design optimization to obtain the target HLS design, specifically including: An optimized instruction allocation strategy is generated based on the initial HLS design and corresponding optimization metrics by using a large language model agent system for space exploration. An optimized HLS design is generated based on an optimized instruction assignment strategy using a large language model proxy system for code warping. If the optimized HLS design meets the iteration stopping condition, the optimized HLS design is taken as the target HLS design; otherwise, the optimized HLS design and corresponding optimization indicators are input into the large language model agent system for design space exploration for iteration until the target HLS design is obtained. The iteration stopping condition includes that the optimization indicators meet the design indicator requirements. The corresponding optimization indicators of any HLS design are obtained by comprehensive processing of the corresponding HLS design. The optimization indicators include performance indicators and / or resource utilization indicators.

4. The systematic high-level integrated automated processing method according to claim 1, characterized in that: The large language model agent system responsible for code correction includes: a large language model agent system for error analysis and a large language model agent system for code repair. For HLS designs with errors, the large language model agent system responsible for code correction performs iterative error correction processing in the following ways: The large language model agent system used for error analysis reads the error codes and corresponding error information of the HLS design that has errors. After a reasoning process of error location, cause analysis and modification suggestions, it generates a debugging strategy. The large language model agent system used for code repair modifies the erroneous code according to the debugging strategy, resulting in the repaired HLS design; Functional verification was performed on the repaired HLS design, and the verification results were obtained. If the verification result indicates that there is an error in the repaired HLS design, the process is iterated based on the repaired HLS design and the corresponding error information until a correct HLS design is obtained. The error information of any HLS design is extracted from the verification result obtained by performing functional verification on the corresponding HLS design.

5. The systematic high-level integrated automated processing method according to claim 4, characterized in that: If the verification result indicates that there is an error in the repaired HLS design, then the process is iterated based on the repaired HLS design and the corresponding error information until a correct HLS design is obtained, specifically including: If the verification result indicates that there is an error in the repaired HLS design, the large language model agent system used for error analysis reads the error code and corresponding error information of the repaired HLS design and iterates until the correct HLS design is obtained. Alternatively, if the verification results indicate that there is an error in the repaired HLS design, the repaired HLS design and the corresponding error information are input into the large language model agent system that evaluates the optimal correction strategy. The multi-terminal large language model synthesis system generates multiple debugging suggestions, and the evaluation model evaluates the multiple debugging suggestions and selects the optimal solution to construct a new round of debugging strategy. The evaluation dimensions for evaluating the multiple debugging suggestions include at least one of the following: simulation synthesis results, code logic integrity, and the extent of modification to the source code by the debugging suggestions. A new round of debugging strategies is input into the large language model agent system used for code repair, so as to modify the erroneous code in the repaired HLS design until the correct HLS design is obtained.

6. The systematic high-level integrated automated processing method according to claim 1, characterized in that: For any HLS design, the methods for functional verification of the corresponding HLS design include: The simulation tools in the HLS tool suite are used to perform syntax verification on the HLS design, and the correctness of the HLS design functionality is verified by combining the test files, thereby obtaining the compilation information corresponding to the simulation stage. The HLS design, simulated, is then synthesized using the synthesis tools within the HLS suite to obtain compilation information for the synthesis phase. The compilation information generated by the HLS tool is read, and the success of the corresponding stage is identified based on the extracted compilation information. The corresponding execution results are then extracted as the verification results for functional verification. If the synthesis stage is successful, the corresponding execution results include performance indicators and resource utilization indicators. If any stage fails, the corresponding execution results include error information.

7. The systematic high-level integrated automated processing method according to claim 1, characterized in that: The large language model agent system responsible for design optimization includes a large language model agent system for design space exploration, which is fine-tuned based on a specially constructed dataset. Methods for constructing specialized datasets include: Obtain information on multiple HLS designs to be optimized and their corresponding array and loop parameters; By employing a design space exploration based on genetic algorithms and HLS optimization instruction insertion techniques, multiple HLS designs to be optimized are optimized to obtain corresponding candidate HLS designs. Obtain the quality metrics of results from multiple candidate HLS designs; Filter multiple candidate HLS designs to obtain at least one optimized HLS design sample; the result quality indicators of any optimized HLS design sample meet the result quality indicator requirements, including: performance indicators and / or resource utilization indicators. A dedicated dataset is constructed based on the optimized HLS design samples, the corresponding HLS designs to be optimized, the corresponding result quality indicators, and the corresponding array and loop parameter information.

8. The systematic high-level integrated automated processing method according to claim 1, characterized in that: The large language model agent system responsible for code correction includes a large language model agent system for error analysis. The large language model agent system for error analysis is obtained by directly optimizing the fine-tuned model based on the fine-tuned dataset after fine-tuning the model.

9. A systematic, high-level integrated automated processing device, characterized in that: Specifically, it includes: The algorithm conversion module is used to perform algorithm conversion processing on the software code through the large language model proxy system responsible for algorithm conversion, so as to obtain the initial HLS design; The design optimization module is used to iteratively optimize the initial HLS design based on design metrics requirements, through a large language model proxy system responsible for design optimization, to obtain the target HLS design. The code correction module is used to interrupt the generation process of the target HLS design if there is an error in the intermediate HLS design generated during the generation process. The intermediate HLS design and the corresponding error information are input into the large language model agent system responsible for code correction for iterative error correction processing, and the generation process continues after the intermediate HLS design is correct. The error information of any HLS design is obtained by performing functional verification on the corresponding HLS design.

10. A computer-readable storage medium, characterized in that: It stores a computer program, which, when executed by a processor, implements a systematic, high-level integrated automated processing method as described in any one of claims 1 to 8.

11. A computer device, characterized in that: include: Memory, used to store instructions; A processor for executing the instructions, causing the computer device to perform the operation of a systematic high-level integrated automated processing method as described in any one of claims 1 to 8.

12. A computer program product, characterized in that: Includes a computer program, said computer program being adapted to be loaded by a processor and executed as a systematic high-level integrated automated processing method as described in any one of claims 1 to 8.

Images