Code file compiling method based on code topology fractal tree and electronic equipment

Abstract

The invention relates to the technical field of compiling, and provides a code file compiling method based on a code topology fractal tree and electronic equipment. The method comprises the following steps: acquiring code files and code dependency relationship configuration files of a plurality of to-be-compiled service components; performing code topology fractal processing on the code files of the plurality of service components to obtain a code topology fractal tree; matrix modeling of standard field contact coefficients is carried out on the code dependency relationship configuration file; based on the code topology fractal tree and the standard field contact coefficient, obtaining a fiber bundle mapping relation between the code and the compiling resource; determining a global compiling distribution scheme according to the fiber bundle mapping relation; and compiling the code files of the plurality of service components based on the global compiling distribution scheme. Through the scheme, a compiling scheduling problem in a low-code scene is converted into a poplar-miles functional minimization problem in a non-Euclidean space, and accurate quantization of code structure complexity and global optimal resource allocation are realized.

Description

Technical Field

[0001] This application relates to the field of compilation technology, specifically to a compilation method and electronic device for code files based on a code topology fractal tree. Background Technology

[0002] As enterprises accelerate their digital transformation, low-code development platforms are widely used in industries such as finance, government, and manufacturing due to their visualization and rapid application building capabilities. However, as the complexity of business logic increases, the compilation performance bottleneck of low-code platforms becomes increasingly prominent, mainly manifested in low compilation efficiency. Traditional compilation methods cannot effectively quantify the complexity of code structure, leading to uneven task allocation and an exponential increase in compilation time with the growth of business logic.

[0003] Currently, mainstream cluster compilation solutions do not have specific optimizations for low-code business scenarios. They mainly adopt task splitting based on static rules, dividing compilation tasks according to simple rules such as file size and number of syntax units. However, the current compilation solutions have the following drawbacks: 1) Inability to quantify the topological features of low-code scenarios: Existing methods only consider surface-level metrics such as file size and number of lines, and cannot model structural features unique to low-code, such as nesting depth and data binding density, resulting in a mismatch between compilation task allocation and actual computing needs.

[0004] 2) Lack of global optimization in resource scheduling: Low-code scenarios are flexible, resulting in high computational overhead, and the inability to find the optimal solution in non-Euclidean space (such as code dependency graph) leads to low resource utilization.

[0005] 3) Dependency management is prone to interruption and deadlock: Traditional dependency resolution (such as Makefile) cannot dynamically respond to changes in cross-component communication and is prone to compilation deadlock due to circular dependencies. Summary of the Invention

[0006] In view of this, this application proposes a compilation method and electronic device for code file clusters based on code topology fractal trees. In this method, source code files are parsed and transformed into structural condensation dimension features using a self-developed code topology fractal tree, enabling holographic modeling of the code files. Simultaneously, code dependencies are dynamically modeled using canonical field connection coefficients. Thus, by leveraging the code topology fractal tree dimension and canonical field connection coefficients, the cluster code compilation process is transformed into a Yang-Mills functional minimization problem in a non-Euclidean space. Furthermore, this solves the problems of easy compilation dependency interruption and non-global resource allocation optimization inherent in traditional low-code compilation clusters.

[0007] Firstly, a method for compiling code files based on a code topology fractal tree is provided, comprising: obtaining code files and code dependency configuration files for multiple business components to be compiled; performing code topology fractal processing on the code files of the multiple business components to obtain a code topology fractal tree, wherein the code topology fractal tree includes tree nodes and connecting edges, the tree nodes indicating code modules in the code files, and the connecting edges indicating dependency or calling relationships between code modules; performing matrix modeling of the code dependency configuration file using canonical field connection coefficients; obtaining a fiber bundle mapping relationship between code and compilation resources based on the code topology fractal tree and the canonical field connection coefficients; determining a global compilation allocation scheme based on the fiber bundle mapping relationship; and compiling the code files of the multiple business components based on the global compilation allocation scheme.

[0008] This approach abstracts code structure and compilation resource scheduling into a non-Euclidean mapping problem in differential geometric space, enabling accurate modeling of complex nesting and highly dynamic dependency scenarios in low-code platforms. It solves the resource allocation mismatch problem caused by traditional static rule task splitting, significantly improving compilation efficiency and resource utilization.

[0009] In conjunction with the first aspect, in a possible implementation of the first aspect, performing code topology fractal processing on the code files of the multiple business components to obtain a code topology fractal tree includes: performing gridding preprocessing on the code files to obtain a syntax feature manifold, which is used to indicate one or more of the nesting depth of the business component, compilation computation cost, and degree of association with other business components; and constructing the code topology fractal tree based on the syntax feature manifold.

[0010] This approach uses a three-dimensional syntactic mesh analysis of the code to extract multi-dimensional structural features that reflect the actual computational load of the code, enabling subsequent topology modeling to have semantic-level awareness capabilities and improving the scientific nature and accuracy of task partitioning.

[0011] In conjunction with the first aspect, in a possible implementation of the first aspect, constructing the code topology fractal tree based on the grammatical feature manifold includes: determining the topological structure of the tree nodes of the code topology fractal tree based on the grammatical feature manifold, and determining the weighted connection edges between each tree node, so as to construct the code topology fractal tree.

[0012] This scheme enables automated mapping from syntactic features to topological structures, supports fine-grained characterization of the strength of relationships between modules, and lays the foundation for building high-fidelity code dependency graphs.

[0013] In conjunction with the first aspect, in possible implementations of the first aspect, determining the topological structure of the tree node of the code topology fractal tree includes: determining the business component type corresponding to the code topology fractal tree, wherein the business component type includes one or more of forms, workflows, and reports; determining the nesting depth of the tree branches of the code topology fractal tree based on the component hierarchy calculation of the multiple business components; determining the robustness of each tree node based on a preset business importance coefficient; and determining the topological structure of the tree node of the code topology fractal tree based on the business component type, the nesting depth of the tree branches, and the robustness of each tree node.

[0014] This approach, by comprehensively considering business semantics, structural complexity, and priority strategies, dynamically generates differentiated topology forms, enhancing the model's adaptability to different types of low-code applications.

[0015] In conjunction with the first aspect, in a possible implementation of the first aspect, determining the weighted connection edge between each tree node includes: connecting each tree node according to the dependency relationship between the multiple business components; determining the binding density between multiple tree branches of the code topology fractal tree according to the number of multiple business components and the number of custom events; determining the weight value of the structural edge between the multiple tree nodes according to the binding density between the multiple tree nodes; and / or, determining the weight value of the data flow edge for cross-component communication between the multiple tree nodes according to the amount of data transmitted and the real-time requirement level.

[0016] This scheme introduces a dual-dimensional quantification mechanism of binding density and data flow weight to accurately reflect the coupling strength and time constraints between modules, effectively identify critical paths and bottlenecks, and provide a basis for resource allocation.

[0017] In conjunction with the first aspect, in a possible implementation of the first aspect, performing code topology fractal processing on the code files of the multiple business components to obtain a code topology fractal tree further includes: determining the structural cohesion dimension of each of the multiple business components based on the code topology fractal tree and the syntax feature manifold. The structural cohesion dimension is used to indicate the topological complexity of the internal code structure of the multiple business components, so as to determine the global compilation allocation scheme.

[0018] This scheme proposes for the first time a structural cohesion dimension as a unified quantitative indicator, which integrates multi-dimensional features such as nesting depth and connection density, and realizes a scalar expression of code topological complexity, which facilitates mathematical modeling and comparison in global optimization.

[0019] In conjunction with the first aspect, in a possible implementation of the first aspect, obtaining the fiber bundle mapping relationship between code and compilation resources based on the code topology fractal tree and the canonical field connection coefficient includes: obtaining the node structure aggregation parameter of each node in each business component according to the code topology fractal tree and the syntax feature manifold; determining the structural aggregation dimension of each component in the multiple business components according to the node structure aggregation parameter of each node in each business component, the structural aggregation dimension being used to indicate the topological complexity of the internal code structure of the multiple business components; and performing tensor fusion of the structural aggregation dimension and the canonical field connection coefficient to obtain the fiber bundle mapping relationship.

[0020] This scheme utilizes tensor operations to achieve high-dimensional fusion of code topology features and resource scheduling parameters, establishing a precise mapping between code and resources in non-Euclidean space. This transforms the compiler scheduling problem into a solution based on the minimization of Yang-Mills functionals, greatly improving the balance and optimality of task allocation.

[0021] In conjunction with the first aspect, in a possible implementation of the first aspect, determining the global compilation allocation scheme based on the fiber bundle mapping relationship includes: obtaining N topological feature objects based on the fiber bundle mapping relationship and canonical group decomposition, wherein the topological feature objects include code fractal curvature and connection strength, where N is a positive integer; selecting K topological feature objects from the N topological feature objects, where K is a positive integer less than or equal to N; and obtaining the global compilation allocation scheme based on the K topological feature objects and the canonical fixed compiler transformation.

[0022] This scheme extracts key topological invariants, such as curvature, through normalized group decomposition, enabling feature dimensionality reduction and focus for large-scale compilation tasks. This avoids the performance overhead of full computation and improves decision-making efficiency.

[0023] In conjunction with the first aspect, in a possible implementation of the first aspect, selecting K topological feature objects from the N topological feature objects includes: applying Yang-Mills instantaneous conditions to the N topological feature objects to filter them, and retaining the K topological feature objects that satisfy the self-dual equation.

[0024] This scheme introduces the instanton condition as a physical heuristic screening criterion, retaining only the lowest-energy and most stable topological configurations, ensuring that the final allocation scheme has optimal convergence and robustness.

[0025] In conjunction with the first aspect, in a possible implementation of the first aspect, the global compilation allocation scheme obtained based on the K topological feature objects and the canonical fixed compiler transformation includes: calculating the instantaneous weight of each of the K topological feature objects through a variant Monte Carlo-string network hybrid calculation; arranging the instantaneous weights of the K topological feature objects in descending order to obtain the first X topological feature objects, where X is a positive integer less than or equal to K; performing cross-iterative optimization on the canonical connection parameters of the X topological feature objects to obtain the optimized canonical connection parameter matrix of the X topological feature objects; and transforming the optimized canonical connection parameter matrix using the canonical fixed compiler to obtain the global compilation allocation scheme.

[0026] This scheme employs a hybrid algorithm to efficiently solve for instantaneous weights and optimize parameters, generating high-quality compilation and scheduling instructions. This significantly improves the utilization of computing resources compared to traditional methods, and optimizes the balance of compilation tasks by several times.

[0027] In conjunction with the first aspect, in a possible implementation of the first aspect, compiling the code files of the multiple business components based on the global compilation allocation scheme includes: distributing the global compilation allocation scheme to compilation nodes to compile the code files of the multiple business components and obtain a set of intermediate compilation artifacts.

[0028] This scheme enables the effective transmission of the globally optimal strategy to the distributed execution units, ensuring the consistency between the theoretical model and actual operation.

[0029] In conjunction with the first aspect, in a possible implementation of the first aspect, distributing the global compilation allocation scheme to compilation nodes to obtain a set of intermediate compilation artifacts includes: sending the global compilation allocation scheme to the compilers of each central processing unit (CPU) computing node, which is used to perform dynamic fiber bundle deployment to establish a compilation subspace manifold on the node cluster based on the global compilation allocation scheme; establishing connections between each CPU computing node through a canonical parallel transport algorithm among all the compilers; performing task migration by calculating the value of the Wilson loop operator when at least one CPU computing node is detected as a failure; and completing the compilation and execution of the global compilation allocation scheme through each CPU computing node to output the set of intermediate compilation artifacts.

[0030] This scheme utilizes the Wilsonloop operator to monitor changes in the curvature of the gauge field in real time, which can trigger task migration and achieve millisecond-level fault-tolerant response, far exceeding traditional heartbeat detection mechanisms and significantly improving system availability.

[0031] In conjunction with the first aspect, in a possible implementation of the first aspect, the method further includes: performing topological-aware synthesis on the compilation intermediate product set to determine the quantum topological phase coherence of each object in the compilation intermediate product set; performing canonical redundancy elimination operation based on the quantum topological phase coherence of each object in the compilation intermediate product set to obtain an executable program binary stream under canonical flat connection; performing quantum verification on the executable program binary stream to obtain a fractal dimension-performance mapping database for updating the compilation cache; and determining the compilation parameters of a target business component based on the fractal dimension-performance mapping database, wherein the target business component has the same business scenario as at least one of the plurality of business components.

[0032] This approach constructs a closed-loop compilation-verification-learning system, which not only improves the current compilation quality but also continuously accumulates experience, enabling intelligent evolution that becomes better with use.

[0033] In conjunction with the first aspect, in a possible implementation of the first aspect, topologically-aware synthesis of the compilation intermediate product set includes: calculating the quantum topological phase coherence of each object in the compilation intermediate product set through compilation path integration.

[0034] This scheme employs the path integral method to accurately assess the phase consistency between modules, enabling CoherenceΩk quantum phase detection, effectively resolving nonlinear dependency conflicts, and ensuring the logical integrity of the synthesis results.

[0035] In conjunction with the first aspect, in a possible implementation of the first aspect, performing quantum verification on the executable binary stream to obtain an updated fractal dimension-performance mapping database for the compilation cache includes: verifying the correctness of the output of the executable binary stream by calculating the Hausdorff distance between the executable binary stream and the ideal compilation target; after the verification of the executable binary stream is successful, updating the compilation of the executable binary stream and caching it to the fractal dimension-performance mapping database.

[0036] This solution innovatively designs a Hausdorff distance verification system, which can capture more semantic-level errors compared to traditional verification, significantly improving the quality of software delivery.

[0037] In conjunction with the first aspect, in a possible implementation of the first aspect, determining the compilation parameters of the target business component based on the fractal dimension-performance mapping database includes: determining the target structural cohesion dimension of the target business component; retrieving the nearest neighbor record of the target structural cohesion dimension from the fractal dimension-performance mapping database; and, after retrieving the nearest neighbor record of the target structural cohesion dimension, generating the compilation parameters of the target business component based on the nearest neighbor record of the target structural cohesion dimension and the canonical connection algorithm.

[0038] This approach enables parameter recommendations based on historical best practices, significantly shortening the compilation and tuning cycle of new components and improving R&D efficiency.

[0039] In conjunction with the first aspect, in a possible implementation of the first aspect, the method further includes: configuring the compilation parameters of the target business component into the compilation pipeline to compile the code file of the target business component.

[0040] This solution enables the automated reuse of compilation strategies, reduces the cost of manual intervention, and promotes the intelligent upgrade of the CI / CD process.

[0041] In a second aspect, an electronic device is provided, including one or more processors; one or more memories; the one or more memories storing one or more computer programs, the one or more computer programs including instructions that, when executed by the one or more processors, cause a method as described in any of the possible implementations of the first aspect to be performed.

[0042] Thirdly, a computer-readable storage medium is provided that stores computer instructions that, when executed on a computer, cause a method as described in any of the first aspect to the foregoing possible implementations to be performed.

[0043] Fourthly, a chip is provided, the chip including a processor and a communication interface for receiving a signal and transmitting the signal to the processor, the processor processing the signal such that a method as described in any of the first aspect to the foregoing possible implementations is executed.

[0044] Fifthly, a computer program product is provided that, when run on a computer, causes the computer to perform a method as described in the first aspect to any of the aforementioned possible implementations. Attached Figure Description

[0045] Figure 1 A schematic flowchart of the compilation method for code file clusters based on code topology fractal tree provided in this application embodiment is shown; Figure 2 A schematic diagram illustrating the compilation and execution process of an embodiment of this application is shown; Figure 3 A schematic diagram of a code topology fractal tree, taking a procurement system as an example, is shown in an embodiment of this application. Figure 4 This is a structural schematic diagram of a device provided in an embodiment of this application; Figure 5This is a structural schematic diagram of a system on a chip (SoC) provided in an embodiment of this application. Detailed Implementation

[0046] The technical solution of this application is described below with reference to the accompanying drawings.

[0047] As mentioned in the background section, current compilation solutions suffer from problems such as the inability to quantify the topological characteristics of low-code scenarios, lack of global optimization in resource scheduling, and susceptibility to interruption and deadlock in dependency management.

[0048] To address the aforementioned issues, this application proposes a compilation method 100 for code file clusters based on code topology fractal trees. In this method 100, source code files are parsed and transformed into structural condensation dimension features using a self-developed code topology fractal tree, enabling holographic modeling of the code files. Simultaneously, code dependencies are dynamically modeled using canonical field connection coefficients. Thus, by leveraging the code topology fractal tree dimension and canonical field connection coefficients, the cluster code compilation process is transformed into a Yang-Mills functional minimization problem in a non-Euclidean space.

[0049] Figure 1 A schematic flowchart of method 100 provided in an embodiment of this application is shown. Figure 1 As shown, the method 100 includes steps S110 to S160.

[0050] Step S110: Obtain the code files and code dependency configuration files of the multiple business components to be compiled.

[0051] In this step S110, the system initializes and collects all the input sources required for this compilation process.

[0052] For example, a business component can refer to an independent functional unit that constitutes the target application system, such as a user authentication service, an order approval workflow, or a financial statement generator. Each component consists of a set of related code files. These code files can be text files containing program logic, in formats such as JavaScript, Java, or Python, or JSON / YAML description files generated by a low-code platform, recording the component's UI layout, data binding, event handling logic, etc. The code dependency configuration file is a structured file that explicitly declares the references, imports, or calls between various business components and internal modules.

[0053] Through this step S110, the system establishes a complete set of objects to be processed and their initial dependency views, laying the foundation for subsequent holographic modeling.

[0054] Step S120: Perform code topology fractal processing on the code files of the multiple business components to obtain a code topology fractal tree.

[0055] The code topology fractal tree includes tree nodes and connecting edges. The tree nodes are used to indicate code modules in the code file, and the connecting edges are used to indicate the dependency or calling relationship between code modules.

[0056] Optionally, in an embodiment of this application, performing code topology fractal processing on the code files of the multiple business components to obtain a code topology fractal tree includes: performing mesh preprocessing on the code files to obtain a syntax feature manifold, which is used to indicate one or more of the nesting depth of the business component, compilation computation cost, and degree of association with mutual calls with other business components; and constructing the code topology fractal tree based on the syntax feature manifold.

[0057] For example, gridded preprocessing can refer to dividing the original code file into fine-grained grid units according to its syntactic structure. For instance, the system can first parse the code using a lexical analyzer and a syntax analyzer to identify basic syntactic elements and an abstract syntax tree. Then, these syntactic elements are mapped onto a discretized multidimensional coordinate grid, forming a continuous syntactic feature manifold.

[0058] For example, in embodiments of this application, the grammatical feature manifold can be a set of differentiable function values ​​extracted based on the aforementioned grid, used to quantify key structural properties of the code. For instance, nesting depth can represent the maximum number of levels in the control structure, directly related to code complexity; compilation computation cost can estimate the CPU time and memory overhead required by the module during the compilation phase; and the correlation of mutual calls measures the frequency of calls between two components, the number of parameters passed, and the amount of data exchanged.

[0059] Optionally, in an embodiment of this application, constructing the code topology fractal tree based on the grammatical feature manifold includes: determining the topological structure of the tree nodes of the code topology fractal tree based on the grammatical feature manifold, and determining the weighted connection edges between each tree node to construct the code topology fractal tree.

[0060] It should be understood that tree nodes here correspond to code modules such as functions, classes, and components. Each node carries a multi-dimensional attribute vector from the syntactic feature manifold, such as [nesting depth=5, computational cost=80, associativity=0.7]. Connecting edges represent direct dependencies or calls between modules. These edges are assigned weight values ​​to quantify the strength of the dependencies. The goal of this step is to automatically construct a fractal tree that truly reflects the internal structure and behavioral patterns of the code, utilizing information from the syntactic feature manifold.

[0061] Optionally, in an embodiment of this application, determining the topological structure of the tree node of the code topology fractal tree includes: determining the business component type corresponding to the code topology fractal tree, wherein the business component type includes one or more of forms, workflows, and reports; calculating the nesting depth of the tree branches of the code topology fractal tree based on the component hierarchy of the multiple business components; determining the robustness of each tree node based on a preset business importance coefficient; and determining the topological structure of the tree node of the code topology fractal tree based on the business component type, the nesting depth of the tree branches, and the robustness of each tree node.

[0062] For example, the type of business component determines the basic structure of the topology. Form components typically exhibit shallow nesting and wide branches; workflow components present a deeply nested, multi-branched tree structure; and report components may have numerous parallel data processing child nodes. The nesting depth is determined by the deepest level of control structure within the component, directly affecting the vertical distribution of nodes in the tree. The robustness of the nodes reflects their importance. For example, nodes for the core authentication service would be marked as robust (high weight), while log output modules would be marked as thin (low weight). Weight values ​​can be set using a "business importance coefficient."

[0063] Optionally, in embodiments of this application, determining the weighted connection edge between each tree node includes: connecting each tree node according to the dependency relationship between the plurality of business components; determining the binding density between the plurality of tree branches of the code topology fractal tree according to the number of the plurality of business components and the number of custom events; determining the weight value of the structural edge between the plurality of tree nodes according to the binding density between the plurality of tree nodes; and / or determining the weight value of the data flow edge for cross-component communication between the plurality of tree nodes according to the amount of transmitted data and the real-time requirement level.

[0064] For example, binding density can refer to the frequency of inter-component interactions occurring per unit time or per unit code region. For instance, if a workflow component frequently triggers 10 different custom events, its binding density is higher than that of a similar component that only triggers 2 events. The weights of structural edges are derived linearly or non-linearly from the binding density and are used to represent the strength of structural coupling between modules. Data flow edges specifically refer to dependency paths that carry actual data transmission, and their weights comprehensively consider factors such as the amount of data transmitted and real-time requirements. For example, a communication link that transmits 1MB per second and requires millisecond-level response has a much higher weight than a link that synchronizes configuration files once a day. Furthermore, by distinguishing between structural edges and data flow edges, the model can more precisely characterize different types of dependencies, providing a differentiated basis for subsequent resource allocation.

[0065] Optionally, in embodiments of this application, the process of performing code topology fractal processing on the code files of the multiple business components to obtain a code topology fractal tree further includes: determining the structural cohesion dimension of each of the multiple business components based on the code topology fractal tree and the syntax feature manifold. The structural cohesion dimension is used to indicate the topological complexity of the internal code structure of the multiple business components, so as to determine the global compilation allocation scheme.

[0066] The structural cohesion dimension is a scalar value used to uniformly quantify the overall topological complexity of a business component. For example, a deeply nested, highly coupled workflow component will have a high structural cohesion dimension value, while a simple, independent utility function component will have a low structural cohesion dimension value.

[0067] Step S130: Perform matrix modeling of the canonical field connection coefficients for the code dependency configuration file.

[0068] In this step, the system transforms the dependency configuration file obtained in step S110 into a matrix form that can be used for mathematical operations, namely, canonical field connection coefficients. Canonical field connection coefficients are used here to describe the resource connectivity state in the compilation environment. It can be an n×n matrix (where n is the number of compilation nodes), whose elements represent the connection strength or communication cost from resource i to resource j at compile-time point x. This matrix reflects the dynamic attributes of the cluster network, such as connectivity, latency, bandwidth, and packet loss rate.

[0069] Step S140: Based on the code topology fractal tree and the canonical field connection coefficient, obtain the fiber bundle mapping relationship between the code and the compilation resources.

[0070] Optionally, in embodiments of this application, obtaining the fiber bundle mapping relationship between code and compilation resources based on the code topology fractal tree and the canonical field connection coefficient includes: obtaining the node structure aggregation parameter of each node in each business component according to the code topology fractal tree and the syntax feature manifold; determining the structure aggregation dimension of each component in the plurality of business components according to the node structure aggregation parameter of each node in each business component, wherein the structure aggregation dimension is used to indicate the topological complexity of the internal code structure of the plurality of business components; and performing tensor fusion of the structure aggregation dimension and the canonical field connection coefficient to obtain the fiber bundle mapping relationship.

[0071] The node structure cohesion parameter is the local value of the structure cohesion dimension at a single node, which can be calculated by weighting features such as the node's nesting depth, computational cost, and in-degree / out-degree. Tensor fusion refers to performing a high-order tensor product operation, such as an outer product or Hadamard product, on the structure cohesion dimension on the code side and the canonical field connection coefficients on the resource side to generate a joint tensor. This joint tensor defines a fiber bundle, such as a base space B being a code topological fractal tree, and fibers F being compilation resource clusters such as CPU / GPU node pools. This fiber bundle mapping establishes a precise mathematical correspondence between the code structure and the resource environment, allowing the compiler scheduling problem to be expressed as finding the minimum solution, i.e., an instantaneous solution, of the Yang-Mills functional on this bundle.

[0072] Step S150: Determine the global compilation allocation scheme based on the fiber bundle mapping relationship.

[0073] In this step, the system uses a mathematical algorithm to solve for the optimal compilation task allocation strategy based on the fiber bundle mapping relationship established in step S140.

[0074] Optionally, in an embodiment of this application, determining the global compilation allocation scheme based on the fiber bundle mapping relationship includes: obtaining N topological feature objects based on the fiber bundle mapping relationship and canonical group decomposition, wherein the topological feature objects include code fractal curvature and connection strength, where N is a positive integer; selecting K topological feature objects from the N topological feature objects, where K is a positive integer less than or equal to N; and obtaining the global compilation allocation scheme based on the K topological feature objects and the canonical fixed compiler transformation.

[0075] Specifically, the topological feature objects are invariants extracted by performing canonical group decomposition on the fiber bundle. Here, code fractal curvature characterizes local topological distortion, and connection strength represents the quality of connectivity between resources. Furthermore, canonical group decomposition breaks down the complex fiber bundle problem into N independently analyzable feature subproblems.

[0076] Optionally, in an embodiment of this application, selecting K topological feature objects from the N topological feature objects includes: applying Yang-Mills instantaneous conditions to the N topological feature objects to filter them, and retaining the K topological feature objects that satisfy the self-dual equation.

[0077] By using this condition, the system retains only the K most critical topological feature objects for subsequent optimization, significantly improving computational efficiency.

[0078] Optionally, in an embodiment of this application, obtaining the global compilation allocation scheme based on the K topological feature objects and the canonical fixed compiler conversion includes: calculating the instantaneous weight of each of the K topological feature objects using a variant Monte Carlo-string network hybrid calculation; arranging the instantaneous weights of the K topological feature objects in descending order to obtain the first X topological feature objects, where X is a positive integer less than or equal to K; performing cross-iteration optimization on the canonical connection parameters of the X topological feature objects to obtain the optimized canonical connection parameter matrix of the X topological feature objects; and converting the optimized canonical connection parameter matrix using the canonical fixed compiler conversion to obtain the global compilation allocation scheme.

[0079] Here, the instantaneous weight represents the contribution of the i-th instantaneous solution to the global optimality. Cross-iterative optimization employs methods such as gradient descent to fine-tune the connection parameters, continuously reducing the total action. The canonical fixed compiler transformation converts the final optimized mathematical solution, such as the connection matrix, into specific compiler instructions.

[0080] Step S160: Based on the global compilation allocation scheme, compile the code files of the multiple business components.

[0081] In this step, the system performs the final distributed compilation task.

[0082] Optionally, in embodiments of this application, distributing the global compilation allocation scheme to compilation nodes to obtain a set of intermediate compilation artifacts includes: sending the global compilation allocation scheme to the compilers of each CPU computing node, the compilers being used to perform dynamic fiber bundle deployment to establish a compilation subspace manifold on the node cluster based on the global compilation allocation scheme; establishing connections between each CPU computing node through a canonical parallel transport algorithm among all the compilers; performing task migration by calculating the value of the Wilson loop operator when at least one CPU computing node failure is detected; and completing the compilation execution of the global compilation allocation scheme through each CPU computing node to output the set of intermediate compilation artifacts.

[0083] The compiled subspace manifold is a local implementation of the global scheme at each node, maintaining overall topological consistency. The canonical parallel transport algorithm ensures that the states of each node are synchronized along a curvature-free path, maintaining the flatness of the canonical field. The Wilsonloop operator calculates the connection integral along the closed path C; a deviation from the identity matrix indicates a fault or curvature. Once a value exceeding a threshold is detected, task migration is immediately triggered to ensure compilation continuity.

[0084] Optionally, in embodiments of this application, the method further includes: performing topological sensing synthesis on the compilation intermediate product set to determine the quantum topological phase coherence of each object in the compilation intermediate product set; performing canonical redundancy elimination operation based on the quantum topological phase coherence of each object in the compilation intermediate product set to obtain an executable program binary stream under canonical flat connection; performing quantum verification on the executable program binary stream to obtain a fractal dimension-performance mapping database for updating the compilation cache; and determining the compilation parameters of a target business component based on the fractal dimension-performance mapping database, wherein the target business component has the same business scenario as at least one of the plurality of business components.

[0085] Quantum topological phase coherence can be calculated using path integrals to evaluate the topological compatibility of each intermediate product. The fractal dimension-performance mapping database stores historical compilation records, establishing a mapping between structural condensation dimensions and compilation time and resource consumption, supporting parameter recommendations for similar components in the future.

[0086] Optionally, in an embodiment of this application, the topological sensing synthesis of the compilation intermediate product set includes: calculating the quantum topological phase coherence of each object in the compilation intermediate product set through compilation path integration.

[0087] Specifically, the compiler path integral is used here to evaluate the logical and temporal consistency of intermediate products (such as object files and symbol tables) generated by multiple parallel compilations. Quantum topological phase coherence is a complex or scalar value used to quantify whether a set of intermediate products can be combined without conflict into a fully functional program. For example, if two components A and B reference each other and are not properly decoupled, the phases of their synthesis paths will cancel each other out, resulting in extremely low quantum topological phase coherence.

[0088] Optionally, in an embodiment of this application, performing quantum verification on the executable binary stream to obtain an updated fractal dimension-performance mapping database for compilation cache includes: verifying the correctness of the output of the executable binary stream by calculating the Hausdorff distance between the executable binary stream and the ideal compilation target; and after the verification of the executable binary stream is successful, updating the executable binary stream for compilation and caching it in the fractal dimension-performance mapping database.

[0089] The Hausdorff distance is a mathematical tool for measuring the maximum and minimum distance between two sets of points. Here, the system treats the generated executable binary stream as a set of points in a high-dimensional space (each bit or instruction block is a point) and compares it with a predefined ideal compilation target, such as a known correct benchmark program. The smaller the deviation value, the more similar the structures of the two programs are.

[0090] When the deviation is less than a preset threshold, the verification is considered successful. Subsequently, the system writes the final executable binary stream from this compilation as a new record into the fractal dimension-performance mapping database, thus forming a continuously learning knowledge base.

[0091] Optionally, in an embodiment of this application, determining the compilation parameters of the target business component based on the fractal dimension-performance mapping database includes: determining the target structural cohesion dimension of the target business component; retrieving the nearest neighbor record of the target structural cohesion dimension from the fractal dimension-performance mapping database; and generating the compilation parameters of the target business component based on the nearest neighbor record of the target structural cohesion dimension and the canonical connection algorithm after retrieving the nearest neighbor record of the target structural cohesion dimension.

[0092] Specifically, the target business component refers to a newly submitted business component that needs to be compiled. Its business scenario can be similar to that of historical components, such as both being approval workflows. The target structural cohesion dimension is the value calculated after performing the aforementioned S120 steps of analysis on the new component. The nearest neighbor record refers to the historical compilation record in the database whose structural cohesion dimension value is closest to the target structural cohesion dimension. The system uses the k-NN (k-nearest neighbor) algorithm for retrieval. Compilation parameters are specific configurations that guide the compiler's behavior, including but not limited to: optimal compilation node allocation strategy, recommended parallelism settings, specific optimization option switches, resource reservation, etc.

[0093] This approach enables intelligent parameter recommendations based on historical best practices, significantly shortening the compilation and tuning cycle of new components and avoiding repeated trial and error.

[0094] Optionally, in embodiments of this application, the method further includes: configuring the compilation parameters of the target business component into the compilation pipeline to compile the code file of the target business component.

[0095] In this context, a build pipeline refers to the standardized process responsible for code compilation, testing, and packaging within an automated build system (such as Jenkins or GitLab CI / CD). The compiler reads these parameters at startup and directly adopts a proven, high-performance compilation strategy, eliminating the need for lengthy exploratory scheduling. This approach enables automated reuse and closed-loop optimization of compilation strategies, significantly improving development efficiency and the intelligence level of the build system.

[0096] The following is combined Figure 2 and Figure 3 This application provides a detailed description of embodiments.

[0097] As mentioned earlier, given the low utilization rate of heterogeneous resources and the susceptibility to compilation dependencies in current low-code compilation clusters of R&D management platforms, traditional methods split and compile code files according to simple rules (such as file size and syntax units), which has the shortcomings of failing to quantify the complexity of code structure and the lag in dynamic response of dependencies. Therefore, this patent proposes to model the code compilation problem as a canonical field optimization mathematical problem on a fiber bundle. The source code file is transformed into structural condensation dimension features through a self-developed code topology fractal tree, and the code file is holographically modeled. At the same time, the code dependencies are dynamically modeled through the canonical field connection coefficient. Thus, by using the dimension of the code topology fractal tree and the canonical field connection coefficient, the cluster code compilation process is transformed into a Yang-Mills functional minimization problem in a non-Euclidean space. The instantaneous solution of this mathematical problem is calculated, which is equivalent to solving the problems of easy compilation dependency interruption and non-global optimization of resource allocation in traditional low-code compilation clusters.

[0098] Based on the above ideas, the traditional process of low-code cluster compilation will be restructured, changing from the traditional four stages of "static task splitting, heuristic scheduling, passive fault tolerance, and linear linking" to four new processing stages of "topology fractal-canonical joint modeling, dynamic fiber bundle scheduling, connection-preserving fault tolerance, and topology-aware synthesis". Each stage mainly focuses on the calculation and processing of code fractal dimension and canonical field connection coefficient.

[0099] The final output distribution of the compilation under the standard flat connection obtained in this proposal is the executable program that the low-code platform compilation finally needs. Through the innovative process of this patent, a brand-new code cluster compilation scheme that combines geometric intuition and mathematical rigor is obtained, thereby greatly improving the compilation speed of application code designed and arranged through the low-code visual interface and reducing the compilation exception interruption caused by the chaos of low-code business logic dependencies.

[0100] Figure 2 A schematic diagram illustrating the compilation and execution process of an embodiment of this application is shown. The embodiments of this application will be described below from steps one to six.

[0101] Step 1: Corresponding to steps S110 to S140, the low-code function of the R&D management platform generates a set of uncompiled code files based on the business logic arranged by the visual designer, and performs code topology fractal and canonical field connection coefficient modeling on the .vue / .jsx business component files to be compiled, transforming them into the code-resource fiber bundle mapping relationship necessary for solving the Yang-Mills functional minimization problem in non-Euclidean space. .

[0102] First, developers orchestrate business logic and submit code using the visual designer within the low-code functionality of the R&D management platform. The platform automatically triggers the compilation process, and the .vue / .jsx business component files undergo 3D syntax mesh preprocessing. The purpose of this preprocessing is to establish the geometric mapping between the underlying code of the visual components and the compilation computation resources. The mesh preprocessing calculation method is as follows: First, construct the syntactic feature manifold. :

[0103] in, Visualization components In the low-code canvas, nesting depth can be quantified as "the additional compilation time required for each additional level of form nesting"; The code compilation cost of a single visualization component u is preset according to business rules; Quantify the correlation between data calls of multiple visualization components and identify circular dependencies such as "linked validation of form fields"; Adjust the weights of each dimension to match the "high binding and low nesting" characteristics of low-code components. The synergistic change in depth and complexity. The interaction between complexity and dependencies.

[0104] Corresponding to step S120, in obtaining the preprocessed result syntax manifold Subsequently, taking advantage of the unique characteristics of low-code, such as "data binding expressions" and "event linkage configurations," a self-developed code topology fractal tree was constructed to analyze the structural cohesion dimension of each business component. .

[0105] The self-developed code topology fractal tree is characterized by the need to construct all tree nodes, design two types of weighted edge connection methods in the tree structure, apply a fractal expansion strategy to the tree, and finally calculate the node structure aggregation parameters of each business component based on the above numerical characteristics. . Figure 3 This illustration shows a schematic diagram of a fractal tree representing the code topology of a procurement system, as provided in an embodiment of this application.

[0106] The construction method of the code topology fractal tree is as follows: First, construct the component types in the tree, the nesting depth of the tree branches, the binding density between branches, and the robustness of the tree nodes represented by business weights, thus constructing all tree nodes. For example, the component types in the tree include three types of nodes: Form, Workflow, and Report; the nesting depth of the tree branches is calculated based on the component hierarchy in the visual designer, with the root component depth=1, and increasing by 1 for each nesting level; the binding density between branches... : Calculate the number of DOM components and the number of custom events, using the following formula:

[0107] The business weight represents the robustness of the tree node: a pre-set business importance coefficient (e.g., financial approval component weight = 0.9).

[0108] After constructing the tree nodes, the connecting edges in the tree structure are designed. This application defines two types of weighted connecting edges: one of which is the structural edge (solid line): connecting parent and child components, with weight... The formula is as follows:

[0109] For example: The edge weight of the approval form (binding=0.7) → attachment subform (binding=0.8) is 0.5×(1+0.2×0.8)=0.58.

[0110] Another type of connection edge is the data flow edge (dashed line): it captures cross-component communication, and the dynamic weight calculation process is shown in the following formula:

[0111] After determining the tree nodes and connecting edges, a fractal expansion strategy is designed for the tree structure. This strategy consists of three parts: a tree structure form component, a workflow component, and the weights and edges of all tree nodes traversed based on the generated fractal tree. Differentiated tree node growth rules are implemented according to the low-code component type: Tree structure form component: When binding > threshold (default 0.6), a validation logic subtree is automatically generated. The idea is to create child nodes according to the component's preset validation rules. The depth of the child node = parent node + 1, and the edge weight = 0.3 × rule complexity.

[0112] Workflow component: When encountering a parallel workflow, a mirror subtree is created, a clone subtree is generated for each branch, and the branch weight w_{branch}=1-1 branch number+1 is adjusted. When a conditional branch occurs, a conditional compilation node is generated, and the branch hit probability is marked.

[0113] Based on the generated fractal tree, traverse the weights and edges of all tree nodes to calculate the node structure cohesion parameters for each business component. The calculation process is shown in the following formula:

[0114] The node structure cohesion parameters are calculated by traversing all nodes v and edges e of the code's topological fractal tree T. The numerator is weighted by a power (exponents 1.3 and 0.7 reinforce key factors), while the denominator is weighted by the power of reuse(v) to suppress the weights of duplicate components. The workflow enhancement term is calculated by accumulating the flow(e) of all edges. Value, of which The fixed weight of 0.5 reflects the coupling strength between parent and child components. This formula requires the complete fractal tree structure to be constructed before performing tree traversal calculations.

[0115] in, Quantization components The sum of the weighted average weights in the fractal tree. Reflection Components The strength of data binding and event interaction between the node and its child nodes. Statistical components The number of times it is reused in a fractal tree. Quantify the strength of data edges or structural edges between components. Fixed weight This reflects the strong coupling between parent and child components. Dynamic weights measure the weight of visualization modules across pages.

[0116] After constructing the code topology fractal tree, the code obtained through the aforementioned three-dimensional syntax mesh preprocessing is then... Import the code into a code topology fractal tree to obtain the structural cohesion dimension of each business component. ,in The calculation method is as follows:

[0117] in, Metric syntax manifold The fractal complexity in three-dimensional feature space is estimated using the box counting method. ,in The required side length for covering the manifold is The number of cubes. Measure the degree of abrupt changes in data binding between adjacent visualization components, by... calculate. Location Business weight of the department . Syntax manifold Volume element of local space.

[0118] Then, corresponding to step S130, for Configuration file for standard field connection coefficients The matrix modeling is performed, and the two feature quantities are fused using tensor product processing to ultimately generate the code-resource fiber bundle mapping relationship. .

[0119] Among them, for The configuration file is modeled in a matrix format to obtain the gauge field connection coefficients. The calculation method is as follows:

[0120] in, Description of code unit quantized states in fiber bundles; Covariant derivative operator; Extract observable compilation topology features from the canonical field, such as the number of context-dependent files. code unit The probability of compilation failure.

[0121] Finally, corresponding to step S140, and Perform tensor product fusion to generate code-resource fiber bundle mapping relationships. :

[0122] Dynamic fusion structure dimension With the coefficient of communication The exponential term calculates the noncommutativity of the matrix. And use 0.8 to control the fusion decay rate, tensor product According to the rules When combining features, the compatibility of matrix dimensions needs to be verified at runtime, and intermediate results need to be cached.

[0123] The twisted tensor product Defined as:

[0124] Step Two: Corresponding to step S150, the R&D management platform, based on the high-frequency iteration characteristics of low-code business components, maps the fiber bundle relationships. The object is decomposed into N topological feature objects using canonical group decomposition. For each object, a Yang-Mills instantaneous conditional filter adapted to low-code platforms is applied, retaining those that satisfy the self-dual equation. For each candidate object, the top X high-weight objects are cross-iteratively optimized, and a global compilation allocation scheme is generated by transforming them into a standardized fixed compiler program. .

[0125] First, based on fiber bundle mapping relationship It is decomposed into its components by canonical group decomposition. Topological feature objects Each object Includes code fractal curvature (From the structural cohesion dimension of step one) (component) and connection strength (From the gauge field connection coefficient in step one) (Components):

[0126] The normalized group decomposition constructs features using two channels; channel A performs the Kronecker product. Normalized dimensions and Expand as Matrix, channel B generates a diagonal matrix using Scaling the identity matrix Finally, straight and The splicing result is Matrix, needs to be Perform L2 normalization preprocessing.

[0127] in, The binding density gradient comes from step one; A 3rd order identity matrix.

[0128] After that, for each Applying Yang-Mills instantaneous conditions adapted to low-code platforms Perform a screening process and retain those that satisfy the self-dual equation. One candidate .

[0129] The constructed self-dual equations are as follows:

[0130] By calculating the curvature of the gauge field Hodge duality, where the differential term Using the central difference approximation, Li brackets For matrix cases, Levi-Civita notation Determine the symbol and Determined by the manifold orientation, partial derivatives need to be calculated on the discrete grid and boundary conditions need to be handled during runtime.

[0131] in:

[0132] in, The canonical connection parameters (which describe a quantum field for allocating compiler computational resources) are represented by... calculate. This represents the low-code business priority factor.

[0133] Then, select those that satisfy the self-dual equation. One candidate That is, retaining the satisfaction Candidates.

[0134] Subsequently, a variant of the Monte Carlo-string network hybrid calculation was used to compute each candidate object. instantaneous weight The calculation process is as follows:

[0135] Through the exponential decay term Quantization of gauge field curvature The energy intensity, of which The parameters control curvature sensitivity, while simultaneously superimposing a 0.3x layer of topological features. (Requires calling a pre-generated topology database), calculations are required at runtime. Modulus square The data is then integrated using a gridded method and finally linearly combined with pre-stored StringNet features.

[0136] in, Indicates the compilation congestion coefficient, through Calculation. StringNet(k) represents the output of the StringNet model, calculated through... Calculate and quantify the pivotal role of components in the business flow.

[0137] Finally, the front High-weight objects Contact parameters Perform quantum annealing cross-iterative optimization when the following conditions are met: The calculation is terminated at the specified time, and the optimized communication parameter matrix is ​​finally transformed into a global compilation task allocation scheme through a standardized fixed procedure. The calculation formula for quantum annealing cross-iteration optimization is as follows:

[0138] Formula execution norm potential Gradient descent update: first term Through automatic differential calculation right The gradient (requires constructing a computational graph), the second term for the neighborhood Calculate the potential field difference penalty term for all nodes within the node. , Controlling the learning rate Adjusting the regularization strength requires maintaining the node adjacency graph and calculating gradients in parallel during runtime.

[0139] in, Represents the learning rate, through calculate. This represents the topology consistency coefficient.

[0140] The termination condition is as follows:

[0141] Optimized By standardizing fixed procedures into a global compilation task allocation scheme :

[0142] Will A normative potential After vectorization and corresponding weights Weighted summation, then normalization using the SoftMax function (ensuring...) Finally, with a fixed matrix Execute Kronecker When expanding feature dimensions, runtime attention must be paid to maintaining dimensionality consistency in vectorization operations and performing block processing for large matrix operations. Specifically, This represents the resource constraint matrix (CPU / MEM / IO quota).

[0143] Step 3: Corresponding to step S160, the R&D platform will assign tasks according to the plan. Distribute to low-code hybrid cloud build nodes, execute dynamic fiber bundle deployment, and establish a build subspace manifold on the node cluster. Perform quantum anomaly detection during compilation, and finally output a distributed collection of compilation intermediates. .

[0144] First, the task allocation scheme The compilers sent to each CPU compute node execute dynamic fiber bundle deployment within the compilers, establishing a compilation subspace manifold on the node cluster. The creation method is as follows:

[0145] A compilation resource manifold is constructed: the first part is for... Normalized features With task characteristics After performing tensor product and summing the results, the second part uses a diagonal matrix. Introducing node latency penalty ( (Control the decay rate) Adjusting the two weights requires dynamic monitoring and adjustment of node latency during runtime. value.

[0146] in, node Task allocation weights (from step two). The node compilation capability tensor is composed of... get. This is the network latency compensation coefficient. This is the delay sensitivity attenuation factor.

[0147] Subsequently, a parallel transport algorithm is used between all compilation nodes. Establish a connection to maintain consistency in communication between nodes and promptly detect compilation dependency interruptions.

[0148] By transforming the state synchronization problem of compilation nodes into the parallel transport problem of gauge fields in differential geometry, and utilizing covariant derivatives... To ensure that each node is allocated resources Under dynamic changes, the compilation state always satisfies the specification transformation invariance. A consensus parameter is generated:

[0149] Its discretization implementation is as follows:

[0150] in, Compilation status matrix. The communication parameters generated in step two. Noise compensation item, . Weighting coefficients.

[0151] When a node failure is detected, the Wilson loop operator is computed. Based on the operator result, closed path integration is performed to select homotopic equivalent nodes for task migration, ensuring that the compilation task is not interrupted. The operator judgment conditions are as follows:

[0152] in, Path sorting operator (guarantee compilation order); Differentiation of inter-node communication links; These are the communication parameters generated in step two.

[0153] When a node requiring immediate migration is identified, homotopy equivalence calculation is performed to select the node.

[0154] Failover nodes are selected by minimizing the objective function: the first term of the formula compares candidate nodes. Computational resources of faulty nodes The ratio difference (reflecting resource matching degree), the second term is weighted by a coefficient of 0.7 for node latency. , Traverse all candidate nodes; real-time data collection is required during runtime. And delay metrics and establish a priority queue to optimize the search.

[0155] in, The integrity of the compilation dependency loop of candidate node j is quantified (the closer the value is to 1, the more stable the topology). The WilsonLoop value of the faulty node. Candidate Nodes Network latency (milliseconds).

[0156] Finally, each node follows the task allocation scheme. After completing the compilation and execution, the final output is a set of distributed compilation intermediate artifacts. The calculation method is as follows:

[0157] The compilation unit fingerprint is generated through a hash-integral hybrid operation, firstly by analyzing the abstract syntax tree. Calculate the SHA-256 hash value, and simultaneously calculate its representation in the resource manifold. Points on and with random mask Multiply, and finally perform a bitwise XOR operation on the two results. The operation requires parallel processing of hash calculations and Monte Carlo integrations during runtime, and ensures the random mask. The unpredictability.

[0158] in, The cryptographic hash of the abstract syntax tree uniquely identifies intermediate compilation results, ensuring code integrity. Components Compiled-state functions, . Topological integrals over a compiled manifold. Resource correction factor.

[0159] Step 4: The R&D platform collects intermediate artifacts from low-code business modules. Performing topological sensing synthesis involves calculating the quantum topological phase coherence of each object in the set through compilation path integrals, eliminating gauge redundancy results, and ultimately generating gauge-flat connections. The executable binary stream below .

[0160] First, the platform sets up intermediate products. Perform topological sensing synthesis and calculate the quantum topological phase coherence of each module through compilation path integration. The calculation method is as follows:

[0161] The topological coherence of compilation units was evaluated by multiplying adjacent units. normalized inner product (Reflecting phase consistency) and applying weights The power of the result, multiplied by the manifold topological divergence. The exponential decay term requires a dependency graph to be constructed at runtime for calculation. Logarithmic transformation is used to avoid numerical underflow.

[0162] in, Weighting coefficients, through calculate. The k-th element of the intermediate product set. Topological divergence coefficient, through calculate.

[0163] Subsequently, based on the quantum topological phase coherence results... ,use Eliminate redundancy in specifications using the following methods: when When the value is less than 0.7, the system determines that there is code redundancy (i.e., code blocks with compilation dependency conflicts or deadlocks), and then performs the following elimination operation:

[0164] Perform Schmitt orthogonalization to remove redundancy from the target vector. Subtract its redundant basis All projected components The Gram matrix needs to be pre-calculated during runtime. A stable orthogonal decomposition algorithm is used to avoid the accumulation of numerical errors.

[0165] in, For quantum field basis vectors (used to identify redundant modes), through calculate.

[0166] Check if redundancy has been completely eliminated:

[0167] Where s is the redundancy operator, through Calculate. kers is the kernel space of the redundancy terms, and ims is the image space of the actual physical state. If the result is zero, it means that all redundancy has been removed. This is a Faddeev-Popov ghost field (marking redundant items). It is a structural constant (quantifying the coupling strength between redundant terms).

[0168] Finally, after completing the overall conflict resolution, the platform generates a standardized, flat communication interface. Low-code platform executable binary stream .

[0169]

[0170] First, the phase-modulated compiler unit (in Linking operations are performed based on the order of code compilation (depending on the compilation order). Then Base64 encoded, and then connected to the standard flat interface. Tensor product of CRC32 checksum The phase angle needs to be maintained synchronously during operation. The topological sorting relationship is determined and tensor products are calculated for large matrices in blocks.

[0171] in, For quantum phase calibration factor, through To calculate. Phase rotation factor, for Apply complex rotations to correct compilation deviations in distributed nodes. Convert binary streams into a text format that can be safely transmitted / stored. Generate a cyclic redundancy check code to verify whether runtime resource allocation conforms to the compile-time plan.

[0172] Step 5: The development platform will stream the low-code binary code. Perform quantum verification by calculating its Hausdorff distance to the ideal compilation target. Verify the correctness of the output; if the distance exceeds the fault tolerance threshold... The system will automatically roll back to step two to re-optimize the communication configuration. After successful verification, it will finally output an executable file that has passed topology verification and update the fractal dimension-performance mapping database of the compilation cache. .

[0173] First, the binary stream Perform quantum verification to confirm the correctness of its output and ensure that it does not exceed the fault tolerance threshold. The verification method is as follows:

[0174] Here, the Hausdorff distance is calculated, and the results are obtained separately. arrive and the inverse sup-inf distance (based on a custom quasi-norm). Finally, the maximum value of the two is taken as the topological difference measure. At runtime, a kd-tree is used to accelerate the nearest neighbor search, and an approximation algorithm is applied to high-dimensional vectors to reduce computational complexity.

[0175] in, The binary stream to be verified; The ideal compilation target is predefined by the business logic; Quantum norm, formula , It is the first The amplitude of each quantum bit, It is an observable operator matrix (to verify runtime behavior).

[0176] By comparison With fault tolerance threshold If the size is less than the fault tolerance threshold If the result is positive, the verification is successful; otherwise, roll back to step two and execute again.

[0177] After successful verification, the binary stream will be... Update the fractal dimension of the compile cache - performance mapping database This will be used as a subsequent cache hit.

[0178] The update rules are as follows:

[0179] This update includes changes to the performance database, specifically the triples (structural cohesion dimensions). Performance improvement ratio Standard potential check value Insert mapping table At runtime, a versioned storage strategy is adopted and a versioned storage system is established. It features a fast retrieval index and uses copy-on-write technology to ensure concurrency safety.

[0180] in, For structural cohesion dimension (from step one); The measured performance index function is obtained through... calculate; To standardize the verification code for communication (to prevent tampering).

[0181] Step Six: Dynamic Invocation at Low-Code Platform Runtime Database, when different users create similar business scenarios in a low-code visual interface.

[0182] In step six, based on the fractal characteristics of the current business component... Search Nearest neighbor records; after a database record is matched, compilation parameters are generated using a standardized communication algorithm. (See step one); pre-configure the optimized parameters into the compilation pipeline to achieve intelligent compilation optimization with "business scenario awareness", which will ultimately significantly reduce the compilation time of similar businesses and reduce the occurrence of compilation interruptions.

[0183] In summary, this application proposes a low-code compilation co-modeling method based on fiber bundle-gauge field theory. In steps one and two, the .vue / .jsx business component files to be compiled undergo three-dimensional syntax meshing preprocessing to construct a syntax feature manifold. To address the unique characteristics of low-code, such as "data-bound expressions" and "event-linked configurations," a self-developed code topology fractal tree is constructed. Differentiated tree node growth is implemented, and based on the generated fractal tree, the weights and edges of all tree nodes are traversed to calculate the node structure aggregation parameters for each business component. The result obtained after three-dimensional syntax mesh preprocessing Import the code into a code topology fractal tree to obtain the structural cohesion dimension of each business component. .right Configuration file for standard field connection coefficients Matrix modeling, and combining the two feature quantities and Tensor product fusion is performed to ultimately generate the code-resource fiber bundle mapping relationship. Map the fiber bundle relationship The object is decomposed into N topological feature objects by canonical group decomposition, and Yang-Mills instantaneous conditions adapted to low-code platforms are applied to each object. Filter and retain those that satisfy the self-dual equation. Each candidate object is calculated using a variant Montto Carlo-string network hybrid algorithm. instantaneous weight The top X high-weight objects are cross-iteratively optimized, and a global compilation allocation scheme is generated by transforming them into a standardized fixed compiler. .

[0184] This approach offers significant advantages over traditional methods: Traditional compilation task allocation typically uses static rules (such as file size and number of syntax units) for task splitting, failing to quantify the topological complexity of the code structure, leading to a mismatch between resource allocation and code characteristics. This innovative approach introduces differential geometry methods, using a code topology fractal tree to analyze the condensed dimension of the structure. (Including multi-dimensional features such as nesting depth and binding density), combined with gauge field connection coefficients By establishing a non-Euclidean space mapping, compiler scheduling is transformed into a Yang-Mills functional minimization problem. This method significantly improves computational resource utilization compared to traditional methods and enhances the balance of compilation tasks (through...). The metrics are optimized by several times, making it particularly suitable for handling high dynamic dependency scenarios unique to low-code platforms.

[0185] Furthermore, this application also designs a topologically-aware quantumized compilation, synthesis, and verification method. In steps three, four, and five of this scheme, the task allocation scheme is... The compilers sent to each CPU compute node execute dynamic fiber bundle deployment within the compilers, establishing a compilation subspace manifold on the node cluster. The parallel transport algorithm is used across all compilation nodes. A connection is established to maintain consistency in communication between nodes. When a node failure is detected, the Wilson loop operator is computed. Based on the operator results, closed path integrals are performed to select homotopic equivalent nodes for task migration. Each node then follows the task allocation scheme. Complete compilation and execution, and output a set of distributed compilation intermediate artifacts. It performs topological sensing synthesis and calculates the quantum topological phase coherence of each module through compilation path integration. ,use After eliminating redundancy in specifications and completing overall conflict resolution, the platform generates a standardized flat connection. Low-code platform executable binary stream By calculating its Hausdorff distance to the ideal compilation target. Verify the correctness of the output; if the distance exceeds the fault tolerance threshold... The system will automatically roll back and re-optimize the communication configuration. After successful verification, it will finally output an executable file that passes topology verification and update the fractal dimension-performance mapping database of the compilation cache. .

[0186] Compared to traditional solutions, this approach has significant advantages: First, traditional fault-tolerant methods rely on passive mechanisms such as heartbeat detection, while this approach utilizes the Wilsonloop operator. Real-time monitoring of standard field curvature (sensitivity up to) First, it can trigger homotopy equivalence transfer within 5ms; second, existing compilation result synthesis mostly uses linear linking, while this solution uses... Quantum phase coherence detection (precision) )and Thirdly, the orthogonalization process resolves nonlinear dependency conflicts; and fourthly, the innovatively designed Hausdorff distance verification system... It captures more semantic-level errors than traditional CRC checksums.

[0187] The hardware module of this application is described below, which can be used to implement the aforementioned method 100.

[0188] Now for reference Figure 4The diagram shows a block diagram of a device 400 according to one embodiment of this application. Device 400 may include one or more processors 401 coupled to a controller hub 403. In at least one embodiment, the controller hub 403 communicates with the processor 401 via a multi-branch bus such as a front side bus (FSB), a point-to-point interface such as a quickpath interconnect (QPI), or a similar connection 410. The processor 401 executes instructions controlling general types of data processing operations. In one embodiment, the controller hub 403 includes, but is not limited to, a graphics memory controller hub (GMCH) (not shown) and an input / output hub (IOH) (which may be on a separate chip) (not shown), wherein the GMCH includes memory and a graphics controller and is coupled to the IOH.

[0189] Device 400 may also include a coprocessor 402 and a memory 404 coupled to a controller hub 403. Alternatively, one or both of the memory and the GMCH may be integrated within the processor, with memory 404 and coprocessor 402 directly coupled to processor 401 and controller hub 403, which resides on a single chip with the IOH. Memory 404 may be, for example, dynamic random access memory (DRAM), phase change memory (PCM), or a combination of both. In one embodiment, coprocessor 402 is a dedicated processor, such as, for example, a high-throughput many integrated core (MIC) processor, a network or communication processor, a compression engine, a graphics processor, a general-purpose computing on GPU (GPGPU), or an embedded processor, etc. Optional properties of coprocessor 402 are indicated by dashed lines. Figure 4 middle.

[0190] Memory 404, as a computer-readable storage medium, may include one or more tangible, non-transitory computer-readable media for storing data and / or instructions. For example, memory 404 may include any suitable non-volatile memory such as flash memory and / or any suitable non-volatile storage device such as one or more hard-disk drives (HDD(s)), one or more compact disc (CD) drives, and / or one or more digital versatile disc (DVD) drives.

[0191] In one embodiment, device 400 may further include a network interface controller (NIC) 406. NIC 406 may include a transceiver for providing a radio interface to device 400, thereby enabling communication with any other suitable device, such as a front-end module, antenna, etc. In various embodiments, NIC 406 may be integrated with other components of device 400. NIC 406 can implement the functionality of the communication unit in the above embodiments.

[0192] Device 400 may further include input / output (I / O) device 405. I / O 405 may include: a user interface designed to enable a user to interact with device 400; a peripheral component interface designed to enable peripheral components to also interact with device 400; and / or sensors designed to determine environmental conditions and / or location information related to device 400.

[0193] It is worth noting that, Figure 4 This is merely an example. That is, although... Figure 4 The diagram shows that device 400 includes multiple devices such as processor 401, controller hub 403, and memory 404. However, in actual applications, devices using the methods of this application may include only a portion of the devices in device 400. For example, it may include only processor 401 and NIC 406. Figure 4 The properties of the optional devices are shown in dashed lines. According to some embodiments of this application, the memory 404, which is a computer-readable storage medium, stores instructions that, when executed on a computer, cause the device 400 to perform the methods according to the above embodiments. Specific details can be found in the methods of the above embodiments, and will not be repeated here.

[0194] Now for reference Figure 5 The diagram shown is a block diagram of a system-on-chip (SoC) 500 according to an embodiment of this application. Figure 5In the diagram, similar components share the same reference numerals. Additionally, dashed boxes are an optional feature for more advanced SoCs. Figure 5 In this SoC 500, the following are included: an interconnect unit 550 coupled to an application processor 510; a system proxy unit 580; a bus controller unit 590; an integrated memory controller unit 540; a group or one or more coprocessors 520, which may include integrated graphics logic, an image processor, an audio processor, and a video processor; a static random access memory (SRAM) unit 530; and a direct memory access (DMA) unit 560. In one embodiment, the coprocessor 520 includes a dedicated processor, such as, for example, a network or communication processor, a compression engine, a GPGPU, a high-throughput MIC processor, or an embedded processor.

[0195] The static random-access memory (SRAM) unit 530 may include one or more computer-readable media for storing data and / or instructions. The computer-readable storage medium may store instructions, specifically, temporary and permanent copies of those instructions. These instructions may include, when executed by at least one unit in the processor, causing the SoC 500 to perform the attention training method according to the above embodiments, as detailed in the methods described above, which will not be repeated here.

[0196] Various embodiments of the mechanisms disclosed in this application can be implemented in hardware, software, firmware, or combinations of these implementation methods. Embodiments of this application can be implemented as computer programs or program code executable on a programmable system, the programmable system including at least one processor, a storage system (including volatile and non-volatile memory and / or storage elements), at least one input device, and at least one output device.

[0197] Program code can be applied to input instructions to execute the functions described in this application and generate output information. The output information can be applied to one or more output devices in a known manner. For the purposes of this application, the processing system includes any system having a processor such as, for example, a digital signal processor (DSP), a microcontroller, an application-specific integrated circuit (ASIC), or a microprocessor.

[0198] The program code can be implemented using a high-level procedural language or an object-oriented programming language to communicate with the processing system. Assembly language or machine language can also be used when needed. In fact, the mechanisms described in this application are not limited to any particular programming language. In either case, the language can be a compiled language or an interpreted language.

[0199] In some cases, the disclosed embodiments may be implemented in hardware, firmware, software, or any combination thereof. The disclosed embodiments may also be implemented as instructions carried or stored thereon on one or more temporary or non-temporary machine-readable (e.g., computer-readable) storage media, which may be read and executed by one or more processors. For example, the instructions may be distributed via a network or through other computer-readable media. Therefore, machine-readable media may include any mechanism for storing or transmitting information in a machine-readable (e.g., computer-readable) form, including but not limited to floppy disks, optical disks, CD-ROMs, compact disc read-only memory (CD-ROMs), magneto-optical disks, read-only memory (ROM), random-access memory (RAM), erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), magnetic cards or optical cards, flash memory, or tangible machine-readable storage for transmitting information (e.g., carrier waves, infrared signals, digital signals, etc.) using the Internet in the form of electrical, optical, acoustic, or other forms of propagated signals. Therefore, machine-readable media includes any type of machine-readable medium suitable for storing or transmitting electronic instructions or information in a machine-readable (e.g., computer-readable) form.

[0200] In the accompanying drawings, some structural or methodological features may be shown in a specific arrangement and / or order. However, it should be understood that such a specific arrangement and / or order may not be necessary. Rather, in some embodiments, these features may be arranged in a manner and / or order different from that shown in the accompanying drawings. Furthermore, including structural or methodological features in a particular figure does not imply that such features are required in all embodiments, and in some embodiments, these features may be omitted or may be combined with other features.

[0201] This application provides a computer program product that, when run on an electronic device, causes the electronic device to execute the technical solutions described in the above embodiments. Its implementation principle and technical effects are similar to those of the related embodiments described above, and will not be repeated here.

[0202] This application provides a readable storage medium containing instructions that, when executed by an electronic device, cause the electronic device to perform the technical solution described in the above embodiments. The implementation principle and technical effects are similar and will not be repeated here.

[0203] This application provides a chip for executing instructions. When the chip is running, it executes the technical solutions described in the above embodiments. Its implementation principle and technical effects are similar and will not be repeated here.

[0204] It should be noted that all units / modules mentioned in the device embodiments of this application are logical units / modules. Physically, a logical unit / module can be a physical unit / module, a part of a physical unit / module, or a combination of multiple physical units / modules. The physical implementation of these logical units / modules themselves is not the most important factor; the combination of functions implemented by these logical units / modules is the key to solving the technical problems proposed in this application. Furthermore, to highlight the innovative aspects of this application, the above-described device embodiments of this application have not introduced units / modules that are not closely related to solving the technical problems proposed in this application. This does not mean that the above-described device embodiments do not contain other units / modules.

[0205] It should be noted that in the examples and description of this patent, relational terms such as "first" and "second" are used merely to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitations, an element defined by the phrase "comprising one" does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element.

[0206] Although this application has been illustrated and described with reference to certain preferred embodiments thereof, those skilled in the art should understand that various changes in form and detail may be made thereto without departing from the spirit and scope of this application.

Claims

1. A method for compiling code files based on a code topology fractal tree, characterized in that, include: Obtain the code files and code dependency configuration files for multiple business components to be compiled; The code files of the multiple business components are subjected to code topology fractal processing to obtain a code topology fractal tree, wherein the code topology fractal tree includes tree nodes and connecting edges, the tree nodes are used to indicate code modules in the code files, and the connecting edges are used to indicate the dependency or calling relationship between code modules; The code dependency configuration file is modeled using a matrix representation of the canonical field connection coefficients. Based on the code topology fractal tree and the canonical field connection coefficient, the fiber bundle mapping relationship between the code and the compilation resources is obtained; Based on the fiber bundle mapping relationship, a global compilation allocation scheme is determined; Based on the global compilation allocation scheme, the code files of the multiple business components are compiled.

2. The method according to claim 1, characterized in that, The step of performing code topology fractal processing on the code files of the multiple business components to obtain a code topology fractal tree includes: The code file is preprocessed into a grid to obtain a syntax feature manifold, which is used to indicate one or more of the following: the nesting depth of the business component, the compilation cost, and the degree of association with other business components. Based on the grammatical feature manifold, construct the code topology fractal tree.

3. The method according to claim 2, characterized in that, The step of constructing the code topology fractal tree based on the grammatical feature manifold includes: Based on the grammatical feature manifold, the topological structure of the tree nodes of the code topology fractal tree is determined, and the weighted connection edges between each tree node are determined, in order to construct the code topology fractal tree.

4. The method according to claim 3, characterized in that, The determination of the topological structure of the tree nodes of the code topology fractal tree includes: Determine the business component type corresponding to the code topology fractal tree, wherein the business component type includes one or more of forms, workflows, and reports; The nesting depth of the tree branches of the code topology fractal tree is determined based on the component hierarchy of the multiple business components. Based on the preset business importance coefficient, determine the robustness of each tree node. The topological structure of the tree nodes of the code topology fractal tree is determined based on the business component type, the nesting depth of the tree branches, and the robustness of each tree node.

5. The method according to claim 3, characterized in that, The determination of the weighted connection edges between the various tree nodes includes: Connect the various tree nodes according to the dependencies between the multiple business components; The binding density between the multiple tree branches of the code topology fractal tree is determined based on the number of the multiple business components and the number of custom events; Based on the binding density between multiple tree nodes, determine the weight values ​​of the structural edges between the multiple tree nodes; and / or, The weight values ​​of the data flow edges for cross-component communication between the multiple tree nodes are determined based on the amount of data transmitted and the level of real-time requirements.

6. The method according to any one of claims 2 to 5, characterized in that, The step of performing code topology fractal processing on the code files of the multiple business components to obtain a code topology fractal tree further includes: Based on the code topology fractal tree and the syntax feature manifold, the structural cohesion dimension of each of the multiple business components is determined. The structural cohesion dimension is used to indicate the topological complexity of the internal code structure of the multiple business components, in order to determine the global compilation allocation scheme.

7. The method according to any one of claims 2 to 5, characterized in that, The process of obtaining the fiber bundle mapping relationship between code and compiled resources based on the code topology fractal tree and the canonical field connection coefficients includes: Based on the code topology fractal tree and the syntax feature manifold, the node structure aggregation parameters of each node in each of the business components are obtained; Based on the node structure aggregation parameters of each node in each of the business components, the structure aggregation dimension of each of the multiple business components is determined, and the structure aggregation dimension is used to indicate the topological complexity of the internal code structure of the multiple business components. The fiber bundle mapping relationship is obtained by tensor fusion of the structure condensation dimension and the gauge field connection coefficient.

8. The method according to any one of claims 1 to 5, characterized in that, The step of determining the global compilation allocation scheme based on the fiber bundle mapping relationship includes: Based on the fiber bundle mapping relationship and canonical group decomposition, N topological feature objects are obtained, which include code fractal curvature and connection strength, where N is a positive integer. Select K topological feature objects from the N topological feature objects, where K is a positive integer less than or equal to N; Based on the K topological feature objects and the standardized fixed compiler transformation, a global compilation allocation scheme is obtained.

9. The method according to claim 8, characterized in that, The step of selecting K topological feature objects from the N topological feature objects includes: The N topological feature objects are filtered by applying Yang-Mills instantaneous conditions, and the K topological feature objects that satisfy the self-dual equation are retained.

10. The method according to claim 8, characterized in that, The process of obtaining a global compilation allocation scheme based on the K topological feature objects and the standardized fixed compiler includes: The instantaneous weights of each of the K topological feature objects are calculated using a variant Monte Carlo-string network hybrid method. Arrange the instantaneous weights of the K topological feature objects in descending order to obtain the first X topological feature objects, where X is a positive integer less than or equal to K; The canonical connection parameters of the X topological feature objects are cross-iteratively optimized to obtain the optimized canonical connection parameter matrix of the X topological feature objects; The optimized canonical contact parameter matrix is ​​transformed by a canonical fixed compiler to obtain the global compilation allocation scheme.

11. The method according to any one of claims 1 to 5, characterized in that, The compilation of the code files of the multiple business components based on the global compilation allocation scheme includes: The global compilation allocation scheme is distributed to compilation nodes to compile the code files of the multiple business components, resulting in a set of intermediate compilation artifacts.

12. The method according to claim 11, characterized in that, The step of distributing the global compilation allocation scheme to compilation nodes to obtain a set of intermediate compilation artifacts includes: The global compilation allocation scheme is sent to the compiler of each CPU computing node, which is used to perform dynamic fiber bundle deployment to establish a compilation subspace manifold on the node cluster based on the global compilation allocation scheme; A connection between each CPU computing node is established among all the compilers using a standardized parallel delivery algorithm. When at least one of the CPU computing nodes is detected to be faulty, task migration is performed by calculating the value of the Wilson loop operator; Each of the CPU computing nodes completes the compilation and execution of the global compilation allocation scheme, and outputs the set of intermediate compilation artifacts.

13. The method according to claim 11, characterized in that, The method further includes: Topological sensing synthesis is performed on the set of compilation intermediates to determine the quantum topological phase coherence of each object in the set of compilation intermediates. Based on the quantum topological phase coherence of each object in the set of compilation intermediates, a canonical redundancy elimination operation is performed to obtain an executable binary stream under canonical flat connection. Quantum verification is performed on the executable binary stream to obtain a fractal dimension-performance mapping database that updates the compiler cache; Based on the fractal dimension-performance mapping database, the compilation parameters of the target business component are determined, wherein the target business component has the same business scenario as at least one of the plurality of business components.

14. The method according to claim 13, characterized in that, The topology-aware synthesis of the compilation intermediate product set includes: The quantum topological phase coherence of each object in the set of compilation intermediates is calculated by compiling the compilation path integral.

15. The method according to claim 13, characterized in that, The step of performing quantum verification on the executable program binary stream to obtain an updated fractal dimension-performance mapping database for the compiler cache includes: The correctness of the output of the executable binary stream is verified by calculating the Hausdorff distance between the executable binary stream and the ideal compilation target. After the executable binary stream is successfully verified, the executable binary stream is updated, compiled, and cached in the fractal dimension-performance mapping database.

16. The method according to claim 13, characterized in that, The step of determining the compilation parameters of the target business component based on the fractal dimension-performance mapping database includes: Determine the target structural cohesion dimension of the target business component; Retrieve the nearest neighbor record of the target structure's condensation dimension from the fractal dimension-performance mapping database; After retrieving the nearest neighbor records of the target structure's cohesion dimension, the compilation parameters of the target business component are generated based on the nearest neighbor records of the target structure's cohesion dimension and the canonical connection algorithm.

17. The method according to claim 16, characterized in that, The method further includes: Configure the compilation parameters of the target business component into the compilation pipeline to compile the code files of the target business component.

18. An electronic device, characterized in that, It includes one or more processors; one or more memories; said one or more memories storing one or more computer programs, said one or more computer programs including instructions that, when executed by said one or more processors, cause the method of any one of claims 1 to 17 to be performed.

19. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer instructions that, when executed on a computer, cause the method as described in any one of claims 1 to 17 to be performed.

20. A chip, characterized in that, The chip includes a processor and a communication interface, the communication interface being used to receive signals and transmit the signals to the processor, the processor processing the signals such that the method as described in any one of claims 1 to 17 is executed.

21. A computer program product, characterized in that, When the computer program product is run on a computer, it causes the computer to perform the method as described in any one of claims 1 to 17.

Images