A domain rule driven embedded code iterative generation engine method

By using a domain-rule-driven embedded code iterative generation engine, the problems of iterative correction and constraint ignoring of large language models in embedded systems are solved, achieving efficient and reliable embedded code generation that meets the real-time and resource requirements of embedded systems.

CN122861748BActive Publication Date: 2026-11-10NANJING RES INST OF ELECTRONICS TECH
View PDF 2 Cites 0 Cited by

Patent Information

Application Number
CN202611364443.8
Authority / Receiving Office
CN · China
Patent Type
Patents(China)
Current Assignee / Owner
Filing Date
2026-09-04
Publication Date
2026-11-10
Estimated Expiration
2046-09-04

AI Technical Summary

Technical Problem

Existing large-scale language models cannot be iteratively modified in embedded systems, ignoring domain-specific constraints. This results in the generated code requiring extensive manual post-optimization, making it difficult to meet the real-time and resource constraints required for embedded development.

Method used

The design domain rule-driven embedded code iteration generation engine, through an iteration evaluation module and an iteration scheduler, combined with a domain rule knowledge base and a hardware resource abstraction module, forms a closed-loop feedback mechanism to achieve autonomous optimization and multi-dimensional evaluation, ensuring that the generated code meets the performance and resource constraints of the embedded system.

Benefits of technology

It significantly improves the adaptability, reliability, and maintainability of embedded code, reduces manual debugging costs, and supports agile development of modern embedded systems.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN122861748B_ABST
    Figure CN122861748B_ABST
Patent Text Reader

Abstract

The application discloses a field rule driven embedded code iterative generation engine method. A field iteration engine composed of an iterative evaluation module, an iterative scheduler, a hardware resource abstraction module, a field rule knowledge base, a standardized output module and a multi-modal interaction module is constructed, and a configurable code generation, heterogeneous compilation and examination and verification module is matched. The iterative evaluation module analyzes the iteration target and generates a running plan according to the knowledge base; the iterative scheduler schedules the code generation, compilation and test verification; the evaluation module receives the compilation, test and hardware state feedback, quantitatively evaluates according to a comprehensive index S containing a compilation, quality and performance sub-index, checks the compilation, interruption response, memory occupation and other hard constraints, and maximizes S in the limited number of iterations to autonomously decide the incremental optimization or overall reconstruction, so that the standard C code meeting the embedded real-time performance and resource constraints is output, the one-time generation is changed into dynamic iterative optimization, and the generated code adaptation rate and maintainability are improved.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This invention belongs to the field of embedded software development technology, specifically relating to a domain rule-driven embedded code iterative generation engine method. Background Technology

[0002] Embedded systems are widely used in safety-critical fields such as industrial control and automotive electronics. Their software development faces unique challenges: high coupling with hardware, extremely limited computing and storage resources, and stringent requirements for real-time performance and determinism. These factors collectively lead to severe challenges for embedded code in terms of performance, security, and reliability. Furthermore, with the exponential growth of system complexity, traditional manual development methods relying on engineer experience are increasingly unable to meet the development needs of modern embedded systems in terms of both development efficiency and code quality.

[0003] In recent years, generative artificial intelligence, represented by large language models (LLMs), has brought a new paradigm to automated code generation. LLMs can understand natural language or formalized instructions and generate functional code snippets, significantly improving initial development efficiency. However, when existing large model code generation technologies are directly applied to the embedded systems field, their inherent limitations are dramatically amplified, mainly in the following two aspects:

[0004] (1) Lack of iterative correction capability: The model tends to be "generated at once" and cannot be locally adjusted based on the correction intention. Instead, it regenerates the code, destroys the existing structure, and has low interaction efficiency.

[0005] (2) Ignoring domain-specific constraints: The generated code only satisfies the functional logic and ignores the hard constraints such as real-time performance and memory usage in embedded development. As a result, its output results often cannot be deployed directly and require a lot of manual work for later reconstruction and performance optimization, thus offsetting its efficiency advantage.

[0006] Therefore, how to overcome the above-mentioned shortcomings of existing technologies and make automated code generation truly meet the stringent requirements of the embedded field has become a technical problem that urgently needs to be solved in this field. Summary of the Invention

[0007] The purpose of this invention is to design a domain rule-driven embedded code iteration generation engine method to address the aforementioned deficiencies in the existing technology, specifically including:

[0008] First, by constructing a closed-loop feedback iterative mechanism, the embedded code generation process can make autonomous decisions based on compilation, testing, and domain rule feedback, realizing the transformation from "one-time generation" to "dynamic iterative optimization," thereby solving the shortcomings of existing technologies that cannot perform effective local corrections and have low interaction efficiency.

[0009] Second, a domain-rule-driven constraint system is introduced to internalize the performance, resource, and security specifications of the embedded domain into the code generation process. This ensures that the generated code not only meets the functional logic but also fully complies with the stringent requirements of the specific domain, thereby solving the problem that existing technology outputs require extensive manual post-optimization.

[0010] Ultimately, this enables high-quality, high-efficiency automated development of embedded code, significantly improving the adaptability, reliability, and maintainability of the generated code, and supporting the agile development needs of modern embedded system software.

[0011] To achieve the above objectives, this invention provides a domain rule-driven embedded code iteration generation engine method, comprising the following steps:

[0012] a) The iterative evaluation module receives the iterative target input by the user and generates an initial execution plan that includes code generation, compilation and evaluation tasks based on the business logic, constraints and optimization strategies in the embedded domain rule knowledge base;

[0013] b) The iterative scheduler generates and schedules instructions to the configurable code generation module, the embedded heterogeneous compilation module, and the multi-dimensional assessment and verification module according to the running plan, driving the generation, compilation, and testing and verification of the code;

[0014] c) The iterative evaluation module receives the code generation status fed back by the configurable code generation module, the compilation status fed back by the embedded heterogeneous compilation module, the test data fed back by the multi-dimensional assessment and verification module, and the hardware status information fed back by the embedded hardware resource abstraction module.

[0015] d) The iterative evaluation module quantifies and evaluates the feedback information according to the predefined iterative control criteria, generates evaluation results, and decides whether to start the iteration or output code based on the evaluation results, thus forming a closed-loop control.

[0016] The iterative control criteria include:

[0017] i) Define a comprehensive performance index S, which includes compilation sub-index, quality sub-index, and performance sub-index, and its mathematical expression is:

[0018] S = F_compile ⋅ [ w_qual ( w_pass ⋅ P_pass + w_correct ( 1 / (1 + e^(-k1 ⋅ (F_correct - F_threshold))) ) ) + w_perf ( 1 / T_int + k2 ⋅ C_usage ⋅M_usage + k3 ⋅ Factor) ]

[0019] In the formula: F_compile is the criterion for whether the code successfully compiles; w_qual is the weight of the quality sub-metric, used to adjust the importance of the entire quality component in the final S-value; w_pass is the weight of the dynamic test pass rate; P_pass is the dynamic test pass rate, i.e., the proportion of test cases that pass dynamic tests; w_correct is the weight of the code static analysis score; F_correct is the code static analysis score, i.e., the code quality score evaluated by static analysis tools; F_threshold is the static analysis score threshold; when F_correct is below this threshold, the score for this item will be very low; k1 is the steepness coefficient of the Sigmoid function, controlling the score curve near the threshold. The steepness of the slope (k1) is determined by the number of points; a larger k1 indicates a more rapid increase in score when the score changes from below to above the threshold. w_perf represents the weight of the performance sub-metric, a dynamic weight used to adjust the overall importance of the performance component in the final S-value. T_int is the interrupt response time, the time required for the system to respond to an interrupt request; a smaller value is better, so its reciprocal 1 / T_int is used to convert it into a positive contribution (a larger value indicates better performance). k2 is the resource cross-penalty coefficient, an adjustable parameter used to control the intensity of the penalty when CPU and memory are simultaneously high. C_usage is the CPU utilization rate; M_usage is the memory utilization rate; k3 is the extension factor weight coefficient; and Factor represents other factors that can be considered for expansion. The coefficients in the S-expression are weight coefficients dynamically adjusted according to user needs, defined in the domain rule knowledge base.

[0020] ii) Check hard constraints, including whether the code compilation status F_compile is 1, and whether the interrupt response time T_int and the peak memory usage M_usage are lower than the preset safety threshold of the rule base. If not, prioritize generating a corrective scheduling instruction.

[0021] iii) Under the premise of satisfying the hard constraints, with the goal of maximizing the comprehensive performance index S, the code generation result with the highest S score is selected as the final output in a finite number of iterations.

[0022] Compared with the prior art, the present invention has the following beneficial effects:

[0023] 1. This invention introduces a domain rule-driven closed-loop feedback mechanism, enabling the code generation process to autonomously optimize under constraints such as embedded resources and real-time performance, thus overcoming the shortcomings of existing technologies that generate code only once and are uncontrollable.

[0024] 2. This invention significantly improves the functional correctness, performance, and resource utilization of code through multi-dimensional automated evaluation and correction, reduces the cost of manual debugging and refactoring, and enables the generated code to meet the requirements of industrial applications.

[0025] 3. This invention shields the underlying hardware differences by uniformly abstracting heterogeneous hardware resources, ensuring that the iterative solution is highly compatible with various target platforms such as X86, DSP, Phytium, and Kunpeng, and is highly feasible.

[0026] 4. This invention has good scalability: code evaluation dimensions, domain rules and optimization strategies can all be quickly integrated through standardized interfaces, enabling the engine to continue to evolve with technological development. Attached Figure Description

[0027] Figure 1 A schematic diagram illustrating the components of a domain-rule-driven embedded code iterative generation engine method;

[0028] Figure 2 A flowchart for a domain-rule-driven embedded code iteration generation engine. Detailed Implementation

[0029] The invention will now be described in further detail with reference to the accompanying drawings. Figure 1 As shown, this invention establishes a domain rule-driven embedded code iterative generation engine method, which mainly includes: an iterative scheduler, an iterative evaluation module, an embedded hardware resource abstraction module, a standardized output module, a domain rule knowledge base, and a multimodal interaction module, as well as supporting components such as configurable code generation, embedded heterogeneous compilation, and multi-dimensional assessment and verification. The domain iterative engine is the core module set, which receives external user input, output results and information feedback from three types of code processing modules, and heterogeneous hardware platform status information. After internal iterative evaluation, it generates a standard embedded C code file output that meets user requirements through multiple on-demand scheduling iterations.

[0030] Example 1

[0031] This embodiment provides a detailed description of each component module of the domain iteration engine, which consists of an iteration scheduler, an iteration evaluation module, an embedded hardware resource abstraction module, a standardized output module, a domain rule knowledge base, and a multimodal interaction module.

[0032] The Iteration Evaluation Module is the cognitive core and closed-loop control center of the entire engine. Its core responsibility is to parse the user's iteration goals and decompose them into a series of executable, atomic task sequences that include generation, compilation, and evaluation. As an information hub, this module is deeply coupled with the multimodal interaction module, the iteration scheduler, the embedded hardware resource abstraction module, and the domain rule knowledge base to achieve data-driven intelligent decision-making. During runtime, this module first obtains user instructions or iteration requests from the multimodal interaction module. Then, based on predefined business logic, constraints, and optimization strategies in the domain rule knowledge base, and with real-time reference to hardware status and available resource information provided by the embedded hardware resource abstraction module, it generates the optimal execution plan and issues it to the iteration scheduler for execution. During execution, the module continuously receives feedback from external execution units and quantifies the evaluation results based on a comprehensive evaluation index S, thereby driving the generation of the next iteration plan, forming a precise, self-optimizing closed-loop control flow.

[0033] The iterative strategy is as follows: Define a comprehensive performance index S, whose mathematical expression is:

[0034] S = F_compile ⋅ [ w_qual ( w_pass ⋅ P_pass + w_correct ( 1 / (1 + e^(-k1⋅ (F_correct - F_threshold))) ) ) + w_perf ( 1 / T_int + k2 ⋅ C_usage ⋅M_usage + k3 ⋅ Factor) ]

[0035] The S-value is composed of quality sub-indicators and performance sub-indicators, where: F_compile determines whether the code successfully compiles; w_qual is the weight of the quality sub-indicator, used to adjust the importance of the overall quality component in the final S-value; w_pass is the weight of the dynamic test pass rate; P_pass is the dynamic test pass rate, i.e., the proportion of test cases that pass dynamic tests; w_correct is the weight of the static analysis score; F_correct is the static analysis score, i.e., the code quality score evaluated by static analysis tools; F_threshold is the static analysis score threshold; when F_correct is below this threshold, the score for this item will be very low; k1 is the steepness coefficient of the Sigmoid function, controlling... The "steepness" of the score curve near the threshold is determined by k1; the larger k1 is, the more rapid the score increase when it moves from below the threshold to above it. w_perf is the weight of the performance sub-metric, a dynamic weight used to adjust the importance of the overall performance component in the final S-value. T_int is the interrupt response time, the time required for the system to respond to an interrupt request; a smaller value is better, so its reciprocal 1 / T_int is used to convert it into a positive contribution (a larger value indicates better performance). k2 is the resource cross-penalty coefficient, an adjustable parameter used to control the penalty intensity when CPU and memory are simultaneously high. C_usage is the CPU utilization rate; M_usage is the memory utilization rate; k3 is the extension factor weight coefficient; Factor represents other factors that can be considered for expansion. The coefficients in the S-expression are weight coefficients dynamically adjusted according to user needs based on the domain rule knowledge base.

[0036] First, it checks if F_compile is 1. If not, the iterative scheduler must prioritize generating corrective instructions. Under the premise of satisfying compilation constraints, the iterative scheduler aims to maximize the overall performance index S. In a finite number of iterations, it selects the code generation result with the highest S score for output.

[0037] Iteration Scheduler: This is the instruction execution center of the entire engine. It receives the plan from the iteration evaluation module, transforms it into specific scheduling instructions for external modules such as code generation, compilation, and verification, and coordinates the data flow between them.

[0038] Embedded Hardware Resource Abstraction Module: Responsible for unified modeling and virtualization of underlying heterogeneous hardware (such as x86, DSP, Phytium, etc.), providing standardized resource status query interfaces (such as memory, CPU core count, interrupt latency) and operation support interfaces to the upper layer, and shielding hardware differences.

[0039] Domain rule knowledge base: Stores professional knowledge in the embedded field, including but not limited to: business processes, industry standards, code design patterns, optimization strategies (such as memory optimization and real-time performance assurance), and experience threshold values ​​for key parameters, providing a basis for the decision-making of the iterative evaluation module.

[0040] a) Key parameter threshold control: Provides empirical values ​​such as maximum memory usage (M_max) and interrupt response deadline (T_deadline) for hard constraint checks.

[0041] b) Experience enhancement and self-learning: Systematically collect problem reports during code generation, compilation, and testing, itemize and structure them, and use them as experience items to feed back into the knowledge base to achieve iterative optimization.

[0042] c) Preset Optimization Modes: Includes multiple built-in optimization modes categorized by typical application scenarios, such as high real-time performance (emphasizing T_int), high pass rate (emphasizing P_pass), and lightweight resource management (emphasizing C_usage and M_usage). Users can switch between these modes with a single click, and the knowledge base will automatically adjust the weights and coefficients in the S formula to achieve rapid and accurate optimization for specific objectives.

[0043] Standardized output module: The interface between the system and the user, responsible for receiving and parsing user instructions, configuration parameters and iteration targets, and presenting the final results to the user.

[0044] Multimodal interaction module: responsible for encapsulating and outputting the final approved code files, test reports, performance analysis reports, etc., in a standardized format.

[0045] The configurable code generation module, the embedded heterogeneous compilation module, and the multi-dimensional assessment and verification module are all supporting modules of this method. They are responsible for receiving engine scheduling instructions, executing corresponding code generation, compilation, and dynamic and static testing and verification, and feeding back corresponding status information to the engine. After evaluation, they are iterated.

[0046] Example 2

[0047] To further illustrate the specific implementation of this invention, an example of a domain rule-driven embedded code iteration generation engine method is provided. In this example, the design of a domain iteration engine, a configurable code generation module, an embedded heterogeneous compilation module, and a multi-dimensional assessment and verification module were first completed. An LLM (Tsinghua Zhipu GLM4.5) was linked and deployed on a Linux server. The embedded hardware resource abstraction module accesses a hybrid embedded resource pool consisting of an X86 E5 platform, a DSP Huarui platform, and an ARM Phytium platform. The engine can receive hardware resource status information in real time and support operations such as compilation and dynamic testing. The specific processing flow is as follows: Figure 2 As shown:

[0048] Step 1: Task Receiving and Initialization. The multimodal interaction module receives the user-inputted development task, which includes a functional requirement description (e.g., "a pulse compression processing code running on the Phytium platform"), target platform information, and optional reference algorithms (e.g., a MATLAB prototype). The iterative evaluation module parses the task and establishes the initial iterative objectives and constraints.

[0049] Step 2: Generate a preliminary iteration plan. Based on the user's task, the iteration evaluation module combines general rules from the domain rule knowledge base with platform resource information provided by the embedded hardware resource abstraction module to generate a preliminary iteration plan. This plan contains a sequence of tasks such as "code generation," "compilation," and "verification," and is sent to the iteration scheduler.

[0050] Step 3: Execution Scheduling and Closed-Loop Feedback. The iterative scheduler, based on the iteration plan, sequentially issues scheduling instructions to the configurable code generation module, the embedded heterogeneous compilation module, and the multi-dimensional assessment and verification module. After each module performs its corresponding operation, it feeds back the execution results (such as generated code, compilation logs, and test reports) to the iterative evaluation module, forming a closed loop.

[0051] Step 4: Multi-dimensional Comprehensive Evaluation. During execution, iterative control is implemented. The evaluation module comprehensively assesses key embedded metrics such as the code generation status feedback, code compilation status feedback, static and dynamic test feedback, and the number of cores, memory usage, interrupt response time, and pass rate of the code running on the Phytium platform during dynamic testing. This assessment is conducted in stages to adjust the subsequent iterative scheduling instruction list. Compared to general criteria, signal processing requires the inclusion of data pass rate measurement. The criteria are generalized as follows:

[0052] S = F_compile ⋅ [ w_qual ( w_pass ⋅ P_pass + w_correct ( 1 / (1 + e^(-k1⋅ (F_correct - F_threshold))) ) ) + w_perf ( 1 / T_int + k2 ⋅ C_usage ⋅M_usage + k3 ⋅ R_thr) ]

[0053] Where R_thr represents the pass rate, which is the k3 ⋅ Factor item in the general criteria replaced with the k3 ⋅ R_thr item. The definitions of the other indicators are the same as before. The weight coefficients are dynamically allocated by the embedded domain rule library according to the current iteration stage and application scenario. The coefficients configured for the scenario with real-time requirements are selected. Under the fixed iteration limit (default setting 10 times), the code with the highest S score is generated and output.

[0054] Step 5: Determine the iteration termination condition. The iteration evaluation module determines whether the current code meets all constraints (such as correct functionality and performance) or whether it has reached the preset iteration limit (such as 10 iterations). If yes, proceed to step 6; if no, based on the score of the comprehensive performance index S in this round, dynamically adjust the optimization strategy for the next iteration (for example, if M_usage is too high, trigger the memory optimization strategy), and return to step 2 to generate a new iteration plan.

[0055] Step 6: Output the final result. When the iteration termination condition is met, the iteration evaluation module will send the final evaluation code and related reports (such as test reports and performance analysis reports) to the standardized output module, which will output the results to the user in a predetermined format.

Claims

1. A domain-rule-driven embedded code iterative generation engine method, characterized in that, Includes the following steps: a) The iterative evaluation module receives the iterative target input by the user and generates an initial execution plan that includes code generation, compilation and evaluation tasks based on the business logic, constraints and optimization strategies in the embedded domain rule knowledge base; b) The iterative scheduler issues scheduling instructions to the configurable code generation module, the embedded heterogeneous compilation module, and the multi-dimensional assessment and verification module according to the running plan, driving the generation, compilation, and testing and verification of code; c) The iterative evaluation module receives the code generation status fed back by the configurable code generation module, the compilation status fed back by the embedded heterogeneous compilation module, the test data fed back by the multi-dimensional assessment and verification module, and the hardware status information fed back by the embedded hardware resource abstraction module. d) The iterative evaluation module quantifies and evaluates the feedback information according to the iterative control criteria, and decides whether to continue iterating or output code based on the evaluation results, thus forming a closed-loop control. The iterative control criteria include: i) Define a comprehensive performance index S, which consists of a compilation sub-index, a quality sub-index, and a performance sub-index, and its mathematical expression is: S = F_compile ⋅ [ w_qual ( w_pass ⋅ P_pass + w_correct ( 1 / (1 + e^(-k1⋅ (F_correct - F_threshold))) ) ) + w_perf ( 1 / T_int + k2 ⋅ C_usage ⋅ M_usage + k3 ⋅ Factor) ] Where F_compile is the compilation pass judgment value, w_qual is the quality sub-index weight, w_pass is the dynamic test pass rate weight, P_pass is the dynamic test pass rate, w_correct is the static analysis score weight, F_correct is the static analysis score, F_threshold is the static analysis score threshold, k1 is the sigmoid function steepness coefficient, w_perf is the performance sub-index weight, T_int is the interrupt response time, k2 is the resource crossover penalty coefficient, C_usage is the CPU utilization, M_usage is the memory utilization, k3 is the expansion factor weight coefficient, and Factor is the scalable evaluation factor; ii) Check hard constraints, including: the compilation pass judgment value F_compile is 1; the interrupt response time T_int is lower than the preset safety threshold of the embedded domain rule knowledge base; the memory usage rate M_usage is lower than the preset safety threshold of the embedded domain rule knowledge base; when any of the hard constraints is not met, a corrective scheduling instruction is generated first. iii) Under the premise of satisfying the hard constraints, with the goal of maximizing the comprehensive performance index S, within a preset finite number of iterations, select the code generation result with the highest comprehensive performance index S score as the final output.

2. The method according to claim 1, characterized in that, The iterative evaluation module parses the iterative goal, decomposes the iterative goal into an atomic task sequence that includes code generation, compilation and evaluation, and sends the atomic task sequence to the iterative scheduler; the iterative evaluation module is deeply coupled with the multimodal interaction module, the iterative scheduler, the embedded hardware resource abstraction module and the embedded domain rule knowledge base.

3. The method according to claim 1 or 2, characterized in that, The embedded hardware resource abstraction module performs unified modeling and virtualization of the underlying heterogeneous embedded hardware, and provides standardized resource status query interface and operation support interface to the upper layer; the resource status query interface is used to query the number of CPU cores, memory usage and interrupt response time.

4. The method according to claim 1, characterized in that, The embedded domain rule knowledge base stores business rules and experience threshold values; the business rules include rules for dynamically adjusting weight coefficients, rules for defining hard constraint safety thresholds, and code optimization strategies; the experience threshold values ​​include maximum memory usage M_max and interrupt response deadline T_deadline.

5. The method according to claim 4, characterized in that, The embedded domain rule knowledge base collects problem reports during code generation, compilation, and testing. After itemizing and structuring the problem reports, the reports are stored as experience items in the embedded domain rule knowledge base.

6. The method according to claim 4, characterized in that, The embedded domain rule knowledge base has built-in preset optimization modes, including a high real-time mode, a high pass rate mode, and a resource-lightweight mode. The high real-time mode focuses on optimizing the interrupt response time T_int, the high pass rate mode focuses on optimizing the dynamic test pass rate P_pass, and the resource-lightweight mode focuses on optimizing the CPU utilization C_usage and the memory utilization M_usage. When switching between the preset optimization modes according to user instructions, the embedded domain rule knowledge base automatically adjusts the weight coefficients in the comprehensive performance index S.

7. The method according to claim 1 or 2, characterized in that, The configurable code generation module generates code based on a large language model, the embedded heterogeneous compilation module performs compilation for the target platform, and the multi-dimensional assessment and verification module performs dynamic testing and static analysis on the generated code.

8. The method according to claim 1, characterized in that, When the method is applied to the field of signal processing, a pass rate sub-index R_thr is added to the comprehensive performance index S. The mathematical expression of the comprehensive performance index S is: S = F_compile ⋅ [ w_qual ( w_pass ⋅ P_pass + w_correct ( 1 / (1 + e^(-k1⋅(F_correct - F_threshold))) ) ) + w_perf ( 1 / T_int + k2 ⋅ C_usage ⋅ M_usage+ k3 ⋅ R_thr) ] Where R_thr is the data throughput.

9. The method according to claim 1, characterized in that, The iterative evaluation module determines whether the current code satisfies all constraints or reaches the preset iteration limit; when all constraints are satisfied or the iteration limit is reached, the iteration is terminated and the final code is output. When all constraints are not met and the maximum number of iterations has not been reached, the optimization strategy for the next iteration is adjusted based on the score of the comprehensive performance index S in this round, a new iteration plan is generated, and the process returns to step b). The optimization strategy includes: triggering a memory optimization strategy when the memory occupancy rate M_usage is higher than a preset threshold.

10. The method according to claim 1, characterized in that, The standardized output module receives and parses user instructions, configuration parameters, and iteration targets, and outputs the final code and related reports in a predetermined format; the multimodal interaction module encapsulates and outputs the final approved code file, test report, and performance analysis report in a standardized format.

Citation Information

Patent Citations

  • Code generation and evaluation method and system based on RAG and multilevel decision tree

    CN121478244A

  • Agent-based neuro-symbolic methodologies for scientific discoveries and workflow automation

    US20260212154A1