A distributed parallel volume calculation method and system for cost accounting

Abstract

The application discloses a distributed parallel rolling calculation method and system for cost accounting, acquires BOM level expansion data and material period cost data, constructs a rolling calculation task topology graph through path analysis and cost group boundary marking; generates a task fragmentation weight coefficient according to node frequency and cross-period load characteristics, splits the rolling calculation hierarchical range to form a dynamic rolling calculation scheduling domain; processes node matching and rolling calculation transaction division on the dynamic rolling calculation scheduling domain, acquires single-node rolling calculation time delay by using hierarchical cache and cross-period zero change identification reduction mapping path, evaluates node load level to generate multi-level node scheduling configuration; analyzes the time delay of the multi-level node scheduling configuration to determine a priority execution transaction, combines retry frequency sorting to form a rolling calculation transaction scheduling plan, and outputs a distributed cost rolling calculation scheduling instruction by summarizing rolling calculation results, so that the execution efficiency and resource utilization balance of distributed cost rolling calculation under a multi-level BOM structure are effectively improved.

Description

Technical Field

[0001] This invention relates to the field of distributed computing technology, and in particular to a distributed parallel computation method and system for cost accounting. Background Technology

[0002] In manufacturing cost accounting, Bill of Materials (BOM) structures typically feature multi-level nesting and cross-references of shared materials. Cost aggregation across different levels exhibits strict upstream and downstream dependencies, and the readiness of data at any node affects the overall recalculation progress. Traditional recalculation methods proceed sequentially layer by layer in a fixed hierarchical order, failing to identify independent cost groups that can be executed in parallel, and neglecting to merge repetitive calculation paths for shared materials. Recalculation time increases linearly with the depth of the BOM hierarchy and the number of material nodes, resulting in excessively long overall recalculation cycles in large-scale, multi-level BOM scenarios.

[0003] Furthermore, material reference relationships and cost data fluctuate across periods, with the cost of some material nodes remaining unchanged across different rollup periods. However, existing methods lack a mechanism to identify such nodes with zero changes, resulting in the re-execution of the complete rollup path for all nodes in each period, generating a large amount of invalid computation. Simultaneously, the lack of dynamic adaptation to load differences and task scheduling order among processing nodes in a distributed environment, coupled with mismatches between high-frequency retry transactions and low-load nodes, further exacerbates the waste of overall rollup resources. Summary of the Invention

[0004] This invention discloses a distributed parallel cost rollover calculation method and system. It constructs a rollover task topology by parsing BOM hierarchical dependencies and cost group boundaries, extracts task sharding weights by combining node reuse characteristics and load assessment, and forms a dynamic rollover scheduling domain. It utilizes hierarchical caching and inter-period zero-change identification to reduce effective rollover paths, and generates multi-level scheduling configurations based on node load levels. It determines transaction execution priorities through latency analysis and retry behavior statistics, and summarizes and outputs distributed cost rollover scheduling instructions based on the rollover results, thus realizing distributed parallel cost rollover calculation under a multi-level BOM structure.

[0005] The first aspect of this invention proposes a distributed parallel convolutional computation method for cost accounting, comprising the following steps: Obtain BOM hierarchical expansion data and material period cost data, and construct a rollup task topology map based on the BOM hierarchical expansion data and material period cost data; The scope of the calculation layer is defined according to the calculation task topology diagram. The BOM level expansion data and the material period cost data are used to perform node reuse and load feature extraction to generate task fragmentation weight coefficients. The calculation layer is then split into tasks to form a dynamic calculation scheduling domain. The dynamic convolution scheduling domain is processed to match nodes to form a node allocation mapping table. Based on the node allocation mapping table, convolution transactions are divided to determine cost acquisition transactions and cost inheritance transactions. Cross-level cost inheritance mapping is performed on the cost acquisition transactions and the cost inheritance transactions to obtain the single-node convolution latency. The node load level is evaluated based on the single-node convolution latency to generate a multi-level node scheduling configuration. The multi-level node scheduling configuration is analyzed for latency to determine priority transactions. The concurrency interval of the priority transactions is collected. Based on the concurrency interval, the transaction scheduling plan is formed by prioritizing the retry frequency from high to low. The results of the calculation are summarized and output as distributed cost calculation scheduling instructions by combining the node allocation mapping table and the calculation transaction scheduling plan.

[0006] A second aspect of this invention provides a distributed parallel convolutional computing system for cost accounting, comprising: The data acquisition module is used to acquire BOM-level expanded data and material period cost data, and to construct a topology map of the rollup task based on the BOM-level expanded data and material period cost data. The task splitting module is used to define the rollup layering range according to the rollup task topology diagram, perform node reuse and load feature extraction on the BOM level expanded data and the material period cost data to generate task fragmentation weight coefficients, and split the rollup layering range into a dynamic rollup scheduling domain through the task fragmentation weight coefficients. The node allocation module is used to process the dynamic convolution scheduling domain, match nodes to form a node allocation mapping table, divide convolution transactions based on the node allocation mapping table to determine cost acquisition transactions and cost inheritance transactions, perform cross-level cost inheritance mapping on the cost acquisition transactions and the cost inheritance transactions to obtain single-node convolution latency, and evaluate the node load level based on the single-node convolution latency to generate multi-level node scheduling configuration. The transaction scheduling module is used to perform latency analysis on the multi-level node scheduling configuration to determine the priority of transactions, collect the concurrency interval of the priority transactions, sort the retry frequencies from high to low based on the concurrency interval to form a volume calculation transaction scheduling plan, and combine the node allocation mapping table with the volume calculation transaction scheduling plan to summarize the volume calculation results and output the distributed cost volume calculation scheduling instruction.

[0007] The beneficial effects of this invention are reflected in the following aspects: First, by performing dependency path parsing and cost group boundary labeling on the BOM hierarchical expansion data, the set of cost groups that can be executed in parallel is identified and a topology graph of the rollover task is constructed. Task sharding weight coefficients are generated by combining node reference frequency and inter-period load characteristics, and the rollover layer range is divided into a dynamic rollover scheduling domain carrying trigger conditions. This solves the problem that traditional serial rollover methods cannot identify parallel execution space and the problem of repeated calculations on shared nodes, thus improving the overall rollover concurrency under a multi-level BOM structure. Second, by extracting costs to obtain the completed rollover results of transactions, a hierarchical cache table is constructed. The child-level results of cost inheritance transactions are matched upwards layer by layer, identifying nodes with zero cost changes across periods and removing them from the effective rollover path. Based on the single-node rollover latency assessment after skipping rollover nodes, the node load level is evaluated, and a multi-level node scheduling configuration is generated. This reduces the overhead of repeated rollover for nodes with no substantial changes and keeps the node scheduling strategy dynamically adapted to the real-time load status. Finally, by identifying cascading risky transactions across cost groups through a time-delay propagation chain diagram and matching them with schedulable windows to determine priority transactions, a set of hot transactions is generated by statistically analyzing retry behavior at concurrent intervals and forming a preemptive scheduling identifier. The three-level priority order is merged into a rollover transaction scheduling plan, which is then summarized with a node allocation mapping table and output as a distributed cost rollover scheduling instruction. This solves the problem of wasted scheduling resources caused by mismatch between high-frequency retry transactions and processing node load in a distributed environment, and improves the execution stability of multiple batches of continuous rollover operations. Attached Figure Description

[0008] Figure 1 This is a flowchart illustrating a distributed parallel computation method for cost accounting according to the present invention.

[0009] Figure 2 This is a structural block diagram of a distributed parallel computation system for cost accounting according to the present invention. Detailed Implementation

[0010] In the following description, specific details such as particular system architectures and techniques are set forth for illustrative purposes and not for limitation, in order to provide a thorough understanding of the embodiments of this application. However, those skilled in the art will understand that this application may also be implemented in other embodiments without these specific details. In other instances, detailed descriptions of well-known systems, apparatuses, circuits, and methods have been omitted so as not to obscure the description of this application with unnecessary detail.

[0011] References to "one embodiment" or "some embodiments" as described in this specification mean that one or more embodiments of this application include a specific feature, structure, or characteristic described in connection with that embodiment. Therefore, the phrases "in one embodiment," "in some embodiments," "in other embodiments," "in still other embodiments," etc., appearing in different parts of this specification do not necessarily refer to the same embodiment, but rather mean "one or more, but not all, embodiments," unless otherwise specifically emphasized. The terms "comprising," "including," "having," and variations thereof mean "including but not limited to," unless otherwise specifically emphasized.

[0012] The technical solutions of the embodiments of this application will be described below.

[0013] like Figure 1 As shown, this embodiment of the invention provides a distributed parallel convolutional computation method for cost accounting, including the following steps S110-S140: Step S110: Obtain BOM level expansion data and material period cost data, and construct the rollup task topology map based on dependency path parsing using the BOM level expansion data and material period cost data.

[0014] Specifically, BOM hierarchical expansion data and material period cost data are obtained. BOM hierarchical expansion data is exported from the manufacturing execution end by period batch, expanding layer by layer downwards from the current expected finished product as the root node, covering the entire parent-child material relationship from finished product to raw materials. Semi-finished products in machining processes and their subordinate standard parts and raw materials are included in the export scope as independent nodes. Each node carries three positioning attributes: material code, cost group, and hierarchical depth. The upper limit of the hierarchical depth of BOM hierarchical expansion data is set during the export stage. Expansion layers exceeding the upper limit are marked as circular references awaiting confirmation and do not participate in the current period's dependency path resolution. If a layer in a multi-layered nested assembly has the same material code as the upper layer during the expansion process, it indicates that the assembly path has a self-referencing loop, and the corresponding node is suspended and pushed to the manual verification queue. When the same material code appears repeatedly under different parents in the BOM hierarchical expansion data, each occurrence is independently retained without merging. Completely retaining the reference path is a prerequisite for identifying the reuse rate of shared materials; merging will result in the loss of reference path information. Material period cost data is linked to each node of the BOM-level expanded data based on both period code and material code. The period range strictly corresponds to the current rollup cycle. Nodes with missing period costs are filled with the most recent valid cost and marked with a fill-in flag. This includes cases where raw material prices have not yet been entered in the current period due to supplier price adjustments. Filled nodes participate in rollup, but the summary results are marked with a reliability downgrade. A data quality alarm is triggered when the fill-in ratio exceeds 5% of the total number of nodes in the current period. After the material period cost data is exported, it is aligned and validated with the BOM-level expanded data by material code. Material period cost data rows with failed code matching are isolated to an anomaly queue, which is not included in the current period's dependency path resolution.

[0015] In some embodiments, the step of constructing a rollover task topology graph by performing dependency path parsing based on the BOM hierarchical expansion data and the material period cost data includes: traversing the hierarchical nodes of the BOM hierarchical expansion data to obtain a set of material dependencies; identifying the multi-path convergence nodes of the material dependency set to generate a dependency path graph; marking cost group boundaries based on the material period cost data and the dependency path graph to obtain a rollover priority sequence; and arranging the hierarchical execution order using the rollover priority sequence to construct the rollover task topology graph.

[0016] The material dependency set is obtained by traversing the hierarchical nodes of the BOM (Bill of Materials) data. A breadth-first search strategy is used, processing all nodes at the same level before moving to the next level, ensuring that dependencies at the same level are fully extracted before dependencies across levels. Each parent-child relationship record in the BOM data is converted into a directed edge and written into the material dependency set during traversal. The directed edge points from the parent to the child. Multiple children under the same parent are represented by independent directed edges in the material dependency set. For example, a finished product with 6 sub-materials at level 2 generates 6 independent directed edges in the material dependency set, each carrying the code and level depth attribute of the corresponding sub-material. When traversing to leaf nodes, leaf nodes do not generate downward directed edges in the material dependency set. Raw materials and purchased standard parts are both leaf nodes, and their cost data directly comes from the purchase price in the material period cost data, without waiting for the results of the next level rollup. They can be executed independently at the beginning of the rollup. In the BOM-level expanded data, circular references to suspended nodes are skipped during traversal. No directed edges are generated at these locations in the material dependency set, and the rollover results for the corresponding cost groups require manual review. After all directed edges in the material dependency set are written, a connectivity check is performed. Non-connected components correspond to isolated subtrees in the BOM-level expanded data that are not associated with the main product tree. Isolated subtree components do not participate in multi-path convergence node identification. Only components connected to the main product tree in the material dependency set participate in multi-path convergence node identification.

[0017] Multi-path convergence nodes in the material dependency set are identified to generate a dependency path graph. A convergence node is defined as having an in-degree greater than 1, meaning it's a material node pointed to by two or more parent nodes in the material dependency set. A higher in-degree indicates more parent paths referenced by the material in the BOM structure, resulting in more complex parent dependencies to coordinate during rollover. The in-degree of each node in the material dependency set is calculated by traversing all directed edge endpoints. Nodes with an in-degree of 1 are single-path nodes, while nodes with an in-degree greater than 1 are marked as multi-path convergence nodes. For example, a common part pointed to by three different parent semi-finished products in the material dependency set is marked as a multi-path convergence node with an in-degree of 3. The hierarchical depth distribution of multi-path convergence nodes in the material dependency set reflects the hierarchical concentration pattern of common materials in the BOM structure. When convergence nodes are concentrated in the middle layer, it indicates that common connecting components or standard modules are shared across multiple product lines; when concentrated at the bottom layer, it indicates that basic raw materials such as steel plates and copper rods are directly referenced by a large number of parent semi-finished products. The rollover path merging strategies corresponding to these two distribution patterns are fundamentally different. The dependency path graph is generated by adding a convergence node annotation layer to the material dependency set. All directed edges in the material dependency set are retained in the dependency path graph. Multi-path convergence nodes are given an in-degree value in the dependency path graph, while non-convergence nodes retain their original directed edge structure without additional annotations. After the dependency path graph is constructed, a density check is performed on the ratio of the number of convergence nodes to the total number of nodes in the material dependency set. If the proportion of convergence nodes exceeds 30%, it indicates that the proportion of shared materials in the BOM structure is too high.

[0018] Cost group boundary labeling is performed based on material period cost data and dependency path diagrams to obtain the rollover priority sequence. The cost group boundary is defined by comparing the cost group identifier carried by each node in the BOM-level expanded data with the period cost group of the corresponding material code in the material period cost data. If the two identifiers match, the cost group affiliation is directly confirmed; if they do not match, the period cost group affiliation in the material period cost data takes precedence, and a conflict label is added. When there are cross-group dependency edges between different cost groups in the dependency path diagram, that edge is the location of the cost group boundary. Each directed edge in the dependency path diagram is compared according to the cost group identifiers of the nodes at both ends. When a welding component and its subordinate stamped parts belong to different cost groups, the directed edge connecting them is the cross-group edge. Edges connecting upper and lower level materials within the same stamping workshop are intra-group edges. The location of the cross-group edge is labeled as the cost group boundary, and the execution order dependency between subsequent cost groups is established accordingly. The number of material codes contained in each cost group in the material period cost data determines the node size of the corresponding cost group subgraph. Cost groups with larger node sizes have longer execution cycles in the rollover priority sequence. Nodes with missing cost group identifiers in the BOM-level expanded data are not included in the current cost group boundary labeling. A boundary labeling quality alarm is triggered when the number of missing identifier nodes exceeds 3% of the total number of nodes in the dependency path graph. The topology sorting of each cost group subgraph is determined based on the cross-group edge direction, with the dependent party preceding the dependent party. The volumetric priority sequence is composed of the execution order of each cost group according to the topology sorting result. Circularly dependent cost groups are not included in the current volumetric priority sequence and trigger an alarm. Cost groups at the same execution position in the volumetric priority sequence can be executed in parallel if there are no cross-group dependencies. The number of parallel layers in the volumetric priority sequence directly determines the maximum concurrent execution width of the volumetric task topology graph.

[0019] A topology graph for computation tasks is constructed by arranging the execution order of computation priority sequences. The position of each cost group in the computation priority sequence determines the hierarchical depth of the corresponding node set in the topology graph. Cost groups that are placed earlier are at lower levels in the topology graph, and higher levels indicate that the execution of that cost group depends more on the computation results of other cost groups. The topology graph for computation tasks consists of nodes and dependency paths. Figure 1However, the semantics of edges change from material parent-child dependencies to constraints before and after the execution of rollover tasks. The material parent-child edges between stamped parts and welded components are transformed into execution dependency arcs in the rollover task topology graph, stating that "the welding cost group can only be started after the stamping cost group rollover is completed." The direction of the arc is consistent with the direction of cross-group edges. Multiple cost groups without cross-group dependencies at the same position in the rollover priority sequence are at the same execution layer in the rollover task topology graph. Node sets at the same layer can be executed in parallel. If the third position of a rollover priority sequence contains two independent cost groups, the third layer of the rollover task topology graph corresponds to the parallel processing of these two cost groups. After the rollover task topology graph is constructed, reachability verification is performed. Nodes in the rollover priority sequence that are unreachable in the rollover task topology graph indicate broken edges in the dependency path graph. The nodes corresponding to the broken edges undergo data verification at the BOM level. If the verification is consistent, the cause of the break is attributed to incorrect cost group boundary labeling. After the corresponding nodes are relabeled, the rollover task topology graph is partially reconstructed. The number of topology layers in the rollup task strictly corresponds to the number of layers in the rollup priority sequence. If the two numbers are inconsistent, it indicates that there are missing layers in the rollup priority sequence. The missing layer corresponds to the cost group that is re-included in the boundary annotation process.

[0020] Step S120: Delineate the scope of the calculation layer according to the calculation task topology diagram, perform node reuse and load feature extraction on the BOM level expansion data and material period cost data to generate task fragmentation weight coefficients, and split the calculation layer scope into dynamic calculation scheduling domains through task fragmentation weight coefficients.

[0021] Specifically, the scope of convolutional layering is defined based on the convolutional task topology diagram. The node set in the convolutional task topology diagram, layered by execution layer, has already formed a preliminary structure during the construction phase. The convolutional layering scope further clarifies the node boundaries and inter-layer dependency constraints of each execution layer, providing clear operational objects for subsequent task splitting. The difference in the number of nodes in each execution layer of the convolutional task topology diagram reflects the uneven distribution of cost group sizes in the BOM structure. The execution layer with the most nodes is marked as a high-density layer in the convolutional layering scope. The node size information of the high-density layer is included in the basic weight calculation during the task fragmentation weight coefficient generation phase, automatically obtaining a finer splitting granularity for the corresponding layer segment. If there are same-layer dependency arcs within each execution layer of the convolutional task topology diagram, the nodes in that layer have local execution order constraints. The direction of the same-layer dependency arc determines the local order within the same layer, and not all nodes in that layer can be marked as parallelizable. When the number of execution layers does not exceed 20, each execution layer constitutes an independent segment. When the number of execution layers exceeds 20, the topology of the computation task is merged into a segment of 5 layers within the computation layering range. The original execution layer sequence constraints are retained within the segment. The start condition for the merger of adjacent segments is the completion of the aggregation of all computation results within the segment. The merging operation compresses the total amount of scheduling metadata to a manageable range. For complex assembly products with multiple nested layers, the node density is highest in the middle semi-finished product layer. The corresponding interval is merged into a high-density segment within the computation layering range and separately marked for priority processing. The product of the total number of nodes in each segment within the computation layering range and the number of execution layers is defined as the computation density index of that segment. The segment where the peak of the computation density index is located serves as the positioning basis for the basic weight floating during the task fragmentation weight coefficient generation stage. The computation density index of the convergent BOM structure reaches its peak in the middle segment and then drops rapidly.

[0022] In some embodiments, the step of reusing nodes and extracting load features from the BOM-level expanded data and the material period cost data to generate task fragmentation weight coefficients includes: performing node reference frequency statistics based on the BOM-level expanded data to obtain the shared material node reuse rate; identifying highly reused nodes through the shared material node reuse rate to generate aggregation allocation identifiers; performing inter-period reference change rate analysis based on the material period cost data to obtain load assessment parameters; and generating task fragmentation weight coefficients based on the aggregation allocation identifiers and load assessment parameters.

[0023] The reuse rate of shared material nodes is obtained by performing node reference frequency statistics based on BOM hierarchical data expansion. The statistical object of node reference frequency is the total number of times each material code appears as a child in all parent-child relationship records in the BOM hierarchical data expansion. When a sealing ring is referenced by both the hydraulic pump assembly and valve assembly assembly assembly lines, the frequency record is 2. A frequency exceeding 1 indicates that the material has a shared reference relationship in the BOM structure, and during rollup, this node corresponds to multiple waiting paths from higher levels. The BOM hierarchical data expansion is traversed by material code, and the count of child occurrence records for each code is the current reference frequency of that material code. The higher the frequency, the stronger the sharing degree of the material in the BOM structure, and the higher the in-degree of the node in the rollup task topology graph. The reuse rate of shared material nodes is measured by the ratio of the current reference frequency of each material code to the historical average for the same period. The historical average is the corresponding period of the three most recent complete reconciliation periods. When the current reference frequency is higher than the historical average, the reuse rate is greater than 1, indicating that the material is referenced more by higher-level paths in the current period. For example, a certain shared part appears 17 times in the BOM hierarchical expansion data in the current period, while the historical average for the same period is 12 times, resulting in a reuse rate of approximately 1.42. The number of in-degree arcs of the corresponding node increases accordingly. Leaf nodes in the BOM hierarchical expansion data, although referenced by higher levels as children, do not generate downward parent-child relationship records themselves. Their cost data comes directly from the purchase and warehousing unit price in the material's period cost data. Cost determination does not need to wait for the results of the lower-level reconciliation and is not included in the calculation of the reuse rate of shared material nodes. Material code sets with a reuse rate higher than 1.3 enter the high reuse node identification stage. The threshold of 1.3 is determined by the 75th quantile of the reuse rate distribution in the historical reconciliation period.

[0024] For example, the step of identifying high-reuse nodes and generating aggregation allocation identifiers through the reuse rate of shared material nodes includes: performing cross-period reuse rate change trend analysis on the reuse rate of shared material nodes to locate the reuse rate abrupt boundary point; delineating the dependency break node interval based on the reuse rate abrupt boundary point to generate a node classification table; performing cross-cost group association analysis based on the node classification table to obtain cross-group aggregation features; and extracting node aggregation boundaries based on the cross-group aggregation features to generate aggregation allocation identifiers.

[0025] This study analyzes the inter-period reuse rate trend of shared material nodes to pinpoint abrupt change points in reuse rate. The analysis focuses on the time series difference between shared material node reuse rate sequences in adjacent roll periods. A positive difference indicates an increase in reuse rate, meaning more parent paths referenced by the material. A negative difference indicates a decrease in reuse rate, meaning some parent references have been removed. The trend of the difference sequence reflects the stability of the reference relationships among shared materials across multiple roll periods. When the shared material node reuse rate exhibits a stable followed by a sharp drop in the inter-period difference sequence, the sharp drop typically corresponds to product discontinuation or modularization changes leading to some assembly lines no longer referencing the material. For example, if a standard connector is replaced due to product upgrades, its reuse rate will drop sharply in the corresponding roll period. The larger the drop, the more parent reference paths have been removed. The location of the reuse rate abrupt drop threshold is achieved through first-order difference extreme value detection of the difference sequence. A candidate drop threshold is identified when the absolute value of the difference exceeds twice the standard deviation of the historical difference sequence of reuse rates for shared material nodes. The direction of the candidate threshold is determined by the sign of the difference; only negative abrupt changes are included in the reuse rate abrupt drop threshold range. For example, if the reuse rate of a shared part remains between 1.3 and 1.5 for six consecutive calculation periods and then suddenly drops to 0.8, with an absolute difference of 0.62 exceeding twice the historical standard deviation, this moment is confirmed as the reuse rate abrupt drop threshold. When the number of material codes triggering the reuse rate abrupt drop threshold in all shared material nodes exceeds 20% of the total number, a batch reference relationship adjustment is indicated in the current BOM structure. The hierarchical segment of the reuse rate abrupt drop threshold concentration corresponds to the fracture concentration layer when subsequently delineating the dependent fracture node interval.

[0026] A node hierarchy table is generated by defining dependency breakpoint intervals based on reuse rate sudden thresholds. The definition of dependency breakpoint intervals is based on the hierarchical distribution of material codes marked by reuse rate sudden thresholds in the topology map of the rollup task. When sudden thresholds are concentrated in a certain level segment, the connectivity of the corresponding dependency paths in that segment has changed significantly in the current period, and the number of upper-level dependency paths of nodes within the breakpoint interval is significantly reduced compared to historical periods. Execution layers where the number of reuse rate sudden threshold material codes exceeds 25% of the total number of nodes in that layer are marked as break concentration layers. Adjacent break concentration layers are merged into a continuous dependency breakpoint interval, while non-adjacent break concentration layers each constitute independent intervals. In a certain rollup task topology map, layers 5 to 7 contain 11 reuse rate sudden threshold materials, accounting for 31% of the total number of nodes in that interval; layers 5 to 7 are merged into a break concentration area. The node classification table is based on a comprehensive classification of each node according to the type of interval it belongs to and the absolute value of the reuse rate of shared material nodes in the current period. Nodes in the break concentration area where the reference path of a product disappears in batches due to product discontinuation are marked as first-level nodes. Nodes with a slight decrease in reuse rate caused only by adjustments to individual assembly lines are marked as second-level nodes. Common parts with stable references over multiple periods are marked as third-level nodes. Ordinary nodes without shared references are not included in the node classification table. In the node classification table, the cross-group aggregation feature analysis of first-level nodes has the highest priority, followed by second-level nodes. Third-level nodes only enter the cross-group association analysis process when resources are sufficient. The hierarchical structure of the node classification table directly determines the processing order and resource allocation ratio of cross-group aggregation feature extraction.

[0027] Cross-cost group association analysis is performed based on the node hierarchy table to obtain cross-group aggregation characteristics. The analysis focuses on the changes in the distribution of cross-group edges among nodes at each level in the dependency path graph. A decrease in the number of cross-group edges connected to first-level nodes indicates that the dependencies between cost groups of these nodes are becoming sparser in the current period. Consequently, the dependency constraints of related cost groups in the convolution priority sequence are loosened, allowing for greater parallel execution space than in historical periods. After extracting the cost group affiliation of first-level nodes in the node hierarchy table, the number of cross-group edges between each first-level node and its superior node that belong to different cost groups is counted. For example, a semi-finished material's cross-group edges connecting the stamping cost group and the welding cost group decreased from 5 to 2 due to a reduction in the number of upstream assembly lines. This node is marked as a node with loosened cross-group dependencies, and the serial dependency between the stamping and welding cost groups can be considered for switching to conditional parallel scheduling in this period. Second-level nodes show relatively small changes in cross-group edges, and their corresponding cross-group aggregation characteristics are labeled as either slightly loosened or stable. Third-level nodes show no sudden decrease in cross-group edges, and their cross-group aggregation characteristics are labeled as stable. The loosening amount is defined as the absolute value of the difference between the number of cross-group edges in the current period and the historical average for the same period. For example, a semi-finished product in the intermediate layer of a certain finished product is coded as a first-level node. The number of cross-group edges connected to it has decreased from 5 in the historical period to 2, resulting in a loosening amount of 3. This indicates a significant reduction in scheduling coupling between cost group pairs in the current period. In the cross-group aggregation feature, this cost group pair is marked as strongly loosened, becoming a priority for subsequent aggregation boundary extraction. The number of all strongly loosened cost group pairs in the cross-group aggregation feature reflects the potential contribution of the current period's BOM structure adjustment to the improvement of volume computation parallelism. The more strongly loosened cost group pairs there are, the wider the layer segment covered by the strong aggregation identifier in the subsequent aggregation allocation identifier.

[0028] Aggregation assignment identifiers are generated by extracting node aggregation boundaries based on cross-group aggregation features. The extraction of node aggregation boundaries is based on the loosening degree of each cost group pair in the cross-group aggregation features. Cross-group edges corresponding to strongly loosened cost group pairs can be used as aggregation cut-off positions in this period. Cross-group edges of weakly loosened or stable cost group pairs maintain their original sequential dependency constraints and do not participate in aggregation boundary extraction. The aggregation boundary of strongly loosened cost group pairs is determined as the position of the edge with the largest loosening amount in the set of cross-group edges connecting the two cost groups. Using this edge as the boundary, the execution relationship between the two cost groups is adjusted from sequential dependency to conditional parallelism. Conditional parallelism requires that the independent computable nodes of the cost group on the loosened edge's child side start first, without waiting for the parent cost group to complete completely. The aggregation allocation identifier is determined by combining the cost group pair code and loosening amount in the cross-group aggregation feature. Cost group pairs with a loosening amount greater than 2 generate strong aggregation identifiers, while those with a loosening amount of 1 to 2 generate weak aggregation identifiers. The conditional parallel window corresponding to the weak aggregation identifier is narrower, allowing only the first two layers of nodes on the loosened edge child side to start early. The conditional parallel window corresponding to the strong aggregation identifier is wider, allowing all nodes on the child side without direct connections to the loosened cross-group edge to start early. For example, if a cost group pair with a loosening amount of 3 generates a strong aggregation identifier, the waiting constraint is lifted when the completion rate of the 7 nodes on the child side exceeds 60% on the parent side, without waiting for the parent side to complete all volume computations. After the aggregation allocation identifier is generated, it is bound to the corresponding node code in the node hierarchy table. The binding relationship serves as the basis for adjusting the task splitting boundary during the dynamic volume computation scheduling domain delineation stage. The larger the adjustment range of the current BOM structure, the more strongly loosened cost group pairs there are in the cross-group aggregation feature, and the higher the coverage of the strong aggregation identifier corresponding to the aggregation allocation identifier.

[0029] Load assessment parameters are obtained through inter-period reference change rate analysis based on material period cost data. This analysis combines two dimensions: the current period reference frequency of each material code in the BOM hierarchical expansion data and the cost amount of the corresponding code in the material period cost data. Reference frequency data is derived from the results obtained during the node reference frequency statistics phase, while cost amount is taken from the current and previous period cost records of each code in the material period cost data. The inter-period reference change rate is measured by dividing the difference between the current and previous period reference frequencies of each material code by the previous period reference frequency. A positive change rate indicates an increase in the number of paths the material is referenced by higher-level references, while a negative change rate indicates that some higher-level references have been removed. For example, a raw material code had a reference frequency of 8 in the previous period, which increased to 14 in the current period, resulting in an inter-period reference change rate of 0.75. The absolute value of the difference between the current and previous period cost amounts for the corresponding code in the material period cost data is used as the cost fluctuation. Material nodes with increased reference frequency and higher cost fluctuation contribute the most to the load in the current period rollover. The load assessment parameters are determined based on the statistical summary of the inter-period reference change rate of the entire code. The mean of the inter-period reference change rate in the material code dimension reflects the overall direction of reference change in the current period, while the variance reflects the dispersion of the change magnitude among materials. A large variance indicates that some materials change drastically while others remain stable, resulting in a significant uneven distribution of the computational load among processing nodes. A high-fluctuation load flag is triggered when the absolute value of the mean exceeds 0.2 or the variance exceeds 0.15. The load assessment parameters jointly characterize the current period's load characteristics using the mean, variance, and high-fluctuation flag. The stratification of the high-fluctuation flag is located during the task fragmentation weight coefficient generation stage as the basis for weight superposition correction.

[0030] Task sharding weight coefficients are generated based on aggregation allocation identifiers and load assessment parameters. The high-reuse node density in each layer of the aggregation allocation identifier and the high-fluctuation flag in the load assessment parameters jointly determine the task sharding weight coefficients of each layer. Layers with higher weight coefficients receive finer granularity of splitting and more processing resources, while layers with lower weight coefficients maintain coarser granularity of splitting to reduce scheduling overhead. The distribution of high-reuse node density covered by the aggregation allocation identifier within each layer determines the base weight of the corresponding layer. The base weight of the layer containing the strong aggregation identifier is higher than that of the layer containing the weak aggregation identifier. The higher the high-reuse node density, the greater the base weight of the layer. In the semi-finished product layer of the shared material concentration, processing nodes frequently wait for the rollup results of the same shared component to be written to the cache. Finer task sharding can allocate the resources of processing nodes during the waiting period to other executable shards, reducing idle waste. The hierarchical distribution of material codes corresponding to high-fluctuation load markers in the load assessment parameters within the roll-up stratification range determines the position of weight superposition. When high-fluctuation material codes are concentrated in a certain stratum, the basic weight of that stratum is adjusted by adding a correction amount to the mean and variance values. The correction amount is determined by the ratio of the number of high-fluctuation materials in the current period to the total number of nodes in the corresponding stratum. The final value of the task segment weight coefficient is normalized to the range of 0 to 1 by the sum of the basic weight and the load correction amount. Normalization ensures that the weights of each stratum can be directly compared within the entire batch. Stratums with weights below 0.15 are triggered to be merged into adjacent stratums. For example, if the final layer of a BOM structure contains only 3 nodes and has no high reuse marker, the corresponding task segment weight coefficient is 0.11, triggering merging. The task segment weight coefficients are arranged in stratum order. The stratum where the weight peak is located corresponds to the stratum with the highest complexity in the BOM structure. The stratum where the peak is located corresponds to the finest granularity of the task splitting stage.

[0031] The volumetric computing layered scope is divided into tasks using task sharding weight coefficients to form a dynamic volumetric computing scheduling domain. Task splitting uses each layer segment within the volumetric computing layered scope as the operation unit. Within each layer segment, the node set is divided into several task shards according to the splitting granularity determined by the task sharding weight coefficient. Layer segments with high task sharding weight coefficients have finer granularity and more shards, which can be independently scheduled to different processing nodes for parallel execution. Layer segments with low task sharding weight coefficients have coarser granularity, and layers within the volumetric computing layered scope that trigger merging due to excessively low weights exist as merged shards. During task splitting, the conditional parallel rules carried by the aggregation allocation identifier are embedded into the corresponding task shard's start trigger condition. The start condition for the task shard containing a node with a strong aggregation identifier is set to a parent-side completion rate exceeding 60%, and the start condition for the task shard containing a node with a weak aggregation identifier is set to a parent-side completion rate exceeding 90%. The first two layers of nodes on the loosened edge child side corresponding to the weak aggregation identifier are allowed to start early when this condition is met. In the dynamic convolution scheduling domain, directed edges between task shard nodes carry completion rate threshold attributes. The scheduling layer determines the start time of each shard by polling the trigger condition status of each directed edge. The effective parallel width of the dynamic convolution scheduling domain is determined by the number of shards whose trigger conditions are met at the same time. The trigger conditions for merging shards in the convolution layer range inherit the constraints of each layer segment before merging. Execution is only activated when all ordinary shards have been completed or entered a waiting state, ensuring that all nodes covered by the convolution layer range are included in the scheduling scope of the dynamic convolution scheduling domain.

[0032] Step S130: Process the dynamic convolution scheduling domain to match nodes and form a node allocation mapping table. Based on the node allocation mapping table, divide the convolution transactions to determine cost acquisition transactions and cost inheritance transactions. Perform cross-level cost inheritance mapping on the cost acquisition transactions and cost inheritance transactions to obtain the single-node convolution latency. Based on the single-node convolution latency, evaluate the node load level and generate a multi-level node scheduling configuration.

[0033] Specifically, a node allocation mapping table is formed by matching processing nodes within the dynamic consolidation scheduling domain. The core constraint of processing node matching is the bidirectional adaptation between the triggering conditions of each task fragment within the dynamic consolidation scheduling domain and the current capacity of each processing node. The fragment size of each task fragment in the dynamic consolidation scheduling domain is measured by the number of nodes. Task fragments with larger fragment sizes are preferentially matched with processing nodes with high capacity, while task fragments with smaller fragment sizes can be matched with processing nodes with medium capacity. Capacity is obtained by polling the current queue depth of each processing node. Nodes with a queue depth below 30% of their rated capacity are considered to have high capacity, those between 30% and 70% are considered to have medium capacity, and those above 70% are considered to have low capacity. Low capacity nodes do not receive new task fragments in the current matching round. Task fragments with strong aggregation triggering conditions in the dynamic consolidation scheduling domain are preferentially bound to fixed processing nodes during node matching. All task fragments under the same aggregation allocation identifier are assigned to the same processing node to avoid additional communication latency caused by the transmission of aggregation waiting signals between nodes. The node allocation mapping table uses the task shard code as the row index and the matching processing node code as the column value. The node allocation mapping table writes the correspondence between each task shard and the target processing node in the dynamic volume scheduling domain row by row. When the number of task shards undertaken by a certain processing node exceeds twice the average of all processing nodes, the node allocation mapping table triggers a load skew alarm. After the smallest shard in the corresponding task shard is rematched to the second-best spare node, the corresponding row of the node allocation mapping table is updated. Based on the node allocation mapping table, rollover transactions are divided into cost acquisition transactions and cost inheritance transactions. Each row of the node allocation mapping table corresponds to a material node within the task segment. Rollover transactions are divided one by one according to the different ways each node obtains current cost data. Nodes in each row of the node allocation mapping table where the material's periodic cost data has a valid record for the current period and does not need to wait for the sub-level rollover results are determined as cost acquisition transactions. Raw materials such as steel plates and standard fasteners that directly use the current period's purchase price belong to this category. Semi-finished products and assemblies whose cost composition includes the summary of lower-level materials must wait for the lower-level rollover to be completed before the cost can be determined, and are determined as cost inheritance transactions. Cost acquisition transactions and cost inheritance transactions can coexist within the same task segment. The execution of cost acquisition transactions is not constrained by the rollover task topology layer level and can be initiated independently after the processing node is confirmed in the node allocation mapping table. Cost inheritance transactions, on the other hand, must wait for all their dependent lower-level material transactions to be completed and for the sub-level rollover results to be written into the layer cache table before they can be started. The ratio of cost acquisition transactions to cost inheritance transactions undertaken by each processing node in the node allocation mapping table reflects the independent execution density of that processing node. For example, processing node P2 undertakes 18 cost acquisition transactions and 6 cost inheritance transactions, with a ratio of 3.0. P2 can operate at high load during the initial stage of volumetric computation. Processing nodes with a ratio below 0.5 experience significant waiting during the initial stage of volumetric computation, and the scheduling layer reduces the priority of subsequent task fragmentation allocation for such nodes in the node allocation mapping table. The division of cost acquisition transactions and cost inheritance transactions is written back to the corresponding row in the node allocation mapping table, serving as the basis for execution path planning for each node during the cross-level cost inheritance mapping phase.

[0034] In some embodiments, the step of performing cross-level cost inheritance mapping between the cost acquisition transaction and the cost inheritance transaction to obtain the single-node volume computation latency includes: extracting the completed volume computation results of the cost acquisition transaction to construct a hierarchical cache table; performing layer-by-layer upward matching of child-level results based on the hierarchical cache table and the cost inheritance transaction to obtain a hit rate; executing a zero-cost transaction based on the hit rate to obtain skippable volume computation nodes; and reducing the mapping path based on the skippable volume computation nodes to obtain the single-node volume computation latency.

[0035] A hierarchical cache table is constructed based on the completed rollover results of cost acquisition transactions. The timing of writes to the hierarchical cache table is strictly tied to the completion time of each cost acquisition transaction. Immediately after each cost acquisition transaction completes, the rollover result is written to the corresponding row in the hierarchical cache table. The write operation is atomic; the corresponding row is not visible to the outside world during the write process. After the write is completed, the row's visibility status is set, and it can only be read after the cost inheritance transaction for that entry has its visibility status set. The hierarchical cache table uses a composite key of the material code and the period code as row identifiers. This composite key ensures that cost data across periods does not overwrite each other in the hierarchical cache table. Rollover results for the same material in different periods are stored independently in different rows of the hierarchical cache table. Cost acquisition transactions are executed distributed across processing nodes as determined by the node allocation mapping table. Processing nodes handling the underlying raw material nodes typically complete their writes first, while those handling the upper-level semi-finished product nodes write later. The hierarchical cache table is shared across processing nodes in a distributed environment. Write operations on each processing node are guaranteed to be atomic at the row level through distributed locks, preventing data corruption when different processing nodes concurrently write to the same material code. If a processing node P1 completes 12 cost acquisition transactions first, the corresponding 12 rows in the hierarchical cache table become immediately visible. Cost inheritance transactions that were suspended awaiting these results are unblocked in batches after the visibility status is set. The coverage of the written rows in the hierarchical cache table dynamically expands as the cost acquisition transactions progress. The rate of coverage expansion is positively correlated with the throughput of each processing node executing cost acquisition transactions. Processing nodes with higher throughput complete cost acquisition transactions faster, resulting in a more rapid increase in the number of visible rows in the hierarchical cache table and a faster overall unblocking speed for cost inheritance transactions. The condition for the hierarchical cache table to be completed is that all cost acquisition transactions have been executed and the corresponding row visibility status has been set. If this condition is not met, the hierarchical cache table is in a partially visible state. In the partially visible state, the child results of the cost inheritance transaction are matched up layer by layer and are only valid for the rows that are already visible.

[0036] For example, the step of matching child results layer by layer upwards based on the hierarchical cache table and the cost inheritance transaction to obtain the hit rate includes: extracting valid cache entries through the hierarchical cache table to obtain the cache coverage; performing hierarchical depth-weighted matching on the cache coverage and the cost inheritance transaction to obtain a matching result set; performing hit and miss classification statistics on the matching result set to obtain a classification count; and calculating the hit ratio based on the classification count to determine the hit rate.

[0037] The cache coverage is determined by extracting valid cache entries from the hierarchical cache table. Valid cache entries are defined as rows in the hierarchical cache table whose visible status is set and whose period code matches the current volume calculation period. Rows whose visible status is not set are considered to be in the writing phase, and rows with inconsistent period codes are considered legacy entries from previous periods; neither type is included in the valid cache entry range. The hierarchical cache table is filtered based on both the visible status bit and the period code. The set of rows retained after filtering constitutes the current valid cache entry set. The ratio of the number of rows in the valid cache entry set to the total number of rows in the hierarchical cache table is defined as the cache effectiveness rate. The cache effectiveness rate monotonically increases with the completion progress of cost-acquisition transactions, reaching 1.0 when all cost-acquisition transactions are completed. The cache coverage is defined by the combined key of the material code and period code in each row of the effective cache entry set. These keys are arranged according to the hierarchical depth of the corresponding nodes in the volumetric task topology graph. The sequence of combined keys arranged from low to high hierarchical depth constitutes the hierarchical distribution description of the cache coverage. A low-level depth of effective cache entries indicates a high completion rate for lower-level cost acquisition transactions, while a high-level depth of sparse effective cache entries indicates a low completion rate for upper-level cost acquisition transactions. In the initial stage of a certain volumetric calculation, effective cache entries in levels 1 to 3 accounted for 82% of the total number of nodes in that level, while levels 4 and above accounted for only 23%, showing a dense distribution at the bottom and a sparse distribution at the top. The hierarchical distribution of the cache coverage determines the available range of cache queries at each level during subsequent depth-weighted matching. The deeper the cache coverage, the higher the proportion of deep hits in the matching result set.

[0038] A hierarchical depth-weighted matching process is used to obtain the matching result set for cache coverage and cost inheritance transactions. Cache coverage provides the available and valid cache entries at each level as the basis for hit queries, while cost inheritance transactions provide the parent dependency paths to be matched. The combination of these two factors, along with hierarchical depth-weighted matching, determines the cache readiness of each dependency path. Cache hits at different levels contribute differently to unblocking cost inheritance transactions. Closer-level hits indicate that the critical segments of the directly dependent path are ready, and their actual contribution to unblocking is higher than that of farther-level hits. Weighted matching distinguishes the differences in contribution between hits at different positions by assigning higher weights to closer-level hits. Each parent dependency path of the cost inheritance transaction is queried layer by layer within the cache coverage. The path query is retrieved layer by layer from the level where the cost inheritance transaction is located. The retrieval result of each layer is compared with the joint key of the valid cache entry of the corresponding level in the cache coverage. When the comparison is consistent, the layer is determined to be a level hit. The weighted score of the level l hit is S_l=h_l×d_l, where h_l is the level l hit flag (1 for hit, 0 for miss), d_l is the level depth weight with a value of 1−l / L_max, and L_max is the maximum level depth of the current convolution task topology graph. The sum of the weighted scores of all parent dependent paths constitutes the matching score of that path. The matching score is written into the corresponding path entry in the matching result set. A path with a score of 0 in the matching result set indicates that the entire path was not hit. A path with a score equal to the sum of the path level depth weights indicates that the entire path was hit. The matching scores of the three parent paths of a certain cost inheritance transaction are 0.72, 0.85 and 0.40, respectively. The matching result set consists of these three score values. The difference in scores reflects the uneven level coverage depth of the three paths within the cache coverage range.

[0039] The matching result set is categorized into hit and miss categories to obtain category counts. The scores of each path in the matching result set are divided into hit and miss categories based on a hit threshold. The hit threshold is set to 0.8 times the sum of the depth weights of each path level. A path score higher than the corresponding threshold is considered a hit, and a score lower than the threshold is considered a miss. The threshold is set to 0.8 times instead of 1.0 because it allows for a small number of high-level deep-level misses without affecting the overall hit determination. High-level deep-level nodes have lower weights in the weighting formula, so their misses have a limited impact on the matching score and a weaker obstruction to cost inheritance transaction unblocking. The classification statistics compare the score of each path in the matching result set with its corresponding threshold. The number of hit paths and the number of miss paths are summed separately. In a certain cost inheritance transaction matching result set, the scores of 0.72 and 0.85 are both higher than the corresponding threshold, while the score of 0.40 is lower than the threshold. The hit count is 2 and the miss count is 1. The classification count consists of two values: the hit count and the miss count. When summing the classification count at the cost inheritance transaction level, the sum of the hit counts and the sum of the miss counts for all cost inheritance transactions are summed independently. The summed hit count and miss count are then used as input parameters for calculating the hit rate in subsequent steps.

[0040] The hit rate is determined by calculating the hit percentage based on the category count. The hit percentage is calculated based on the summative hit count and summative miss count in the category count. The formula for the hit percentage is R = C_hit / (C_hit + C_miss), where C_hit is the summative hit count of all cost inheritance transactions in the category count, C_miss is the summative miss count in the category count, and R is the current hit rate, ranging from 0 to 1. The closer R is to 1, the more fully the visible rows in the hierarchical cache table cover the dependency paths of cost inheritance transactions. The hit rate changes dynamically during the rollover execution as the number of effective cache entries in the hierarchical cache table increases. The scheduling layer re-triggers the hit percentage calculation at a fixed polling interval. No intervention is needed when the hit rate is monotonically increasing. If the increase in the hit rate is less than 0.02 within three consecutive polling intervals, it is considered a stagnation. Stagnation is usually caused by abnormally high execution latency of some cost acquisition transactions, resulting in critical rows in the hierarchical cache table not being written for a long time. Hit rate stagnation typically occurs when a large number of cost acquisition transactions accumulate on some processing nodes, causing critical cache lines to remain unwritten for an extended period. The scheduling layer performs a priority increase operation on the cost acquisition transaction queue of the corresponding processing node. The priority increase is positively correlated with the stagnation duration. When the stagnation duration exceeds twice the average volume computation latency of a single node, a backup node is triggered to take over. The takeover execution scope only covers the incomplete cost acquisition transactions that caused the stagnation. The final stable hit rate is determined by the R value after all valid cache entries in the hierarchical cache table have been written. When the stable hit rate is below 0.75, it indicates that there are a large number of deep misses in the cost inheritance transaction dependency path. In this case, the hit rate result is only used as the output of the current volume computation quality label and does not affect the execution flow of subsequent sub-steps.

[0041] The hit rate is used to execute zero-cost transactions to identify skippable rollover nodes. The hit rate is a prerequisite for triggering the zero-cost transaction determination. When all child-level dependent paths of a single cost inheritance transaction are determined to be hit within the cache coverage, the zero-cost transaction determination is performed on that cost inheritance transaction. For general standard parts and their superior assembly paths with no purchase price changes for multiple consecutive periods, if the transaction results for all costs are consistent with the historical period, the corresponding total cost of semi-finished products does not need to be re-aggregated in the current period. The rollover results are directly copied from the historical period's hierarchical cache table. The reduction in execution paths is positively correlated with the number of skippable rollover nodes; the corresponding nodes are the skippable rollover nodes. For cost inheritance transactions with a full path hit, the hit results of each child level in the hierarchical cache table are read and compared value-by-value with the corresponding rows in the historical period's hierarchical cache table. The comparison range covers all hit rows at all levels along the cost inheritance path. When the absolute value of the difference between all comparison values ​​is less than the precision threshold of 0.001, it is determined to be a zero-cost transaction. The precision threshold is set based on the minimum pricing unit of the current period's material cost data. Cost inheritance transactions with missing child paths cannot complete the full path historical comparison due to incomplete path coverage. Therefore, they are not included in the current period's zero-cost change transaction determination and will wait for the corresponding cost acquisition transaction to complete before re-initiating the hit rate check. After all hierarchical cache tables in a certain batch became visible, there were 215 cost inheritance transactions with a hit rate of 1.0. Among them, 142 were confirmed as zero-cost change transactions through historical comparison, corresponding to 142 skippable rollover nodes, accounting for 66% of the total current period's cost inheritance transactions. The rollover results of skippable rollover nodes are directly copied from the historical hierarchical cache table without re-aggregation. The execution path reduction is positively correlated with the number of skippable rollover nodes.

[0042] The single-node volume computation latency is obtained by reducing the mapping path based on skippable volume computation nodes. Mapping path reduction is performed at the volume computation task topology graph level. The execution dependency arcs corresponding to skippable volume computation nodes are marked as invalid in the current mapping path. Skipable volume computation nodes do not trigger downstream waits for execution dependency arcs, and the parent dependency arcs of skippable volume computation nodes are marked as ready, thus removing skippable volume computation nodes from the critical execution paths of the volume computation task topology graph. The actual number of transactions that each processing node needs to execute after mapping path reduction is determined by subtracting the number of skippable volume computation nodes from the number of rows in the original node's allocated mapping table. The ratio of the actual number of executed transactions after reduction to the original number of transactions is defined as the path reduction rate. The lower the path reduction rate, the denser the skippable volume computation nodes are in the current period, and the shorter the actual execution latency of the processing nodes. Single-node rollover latency is measured by the average difference between the start times of adjacent transactions in the actual execution transaction sequence of each processing node. The statistical range of the average only covers transactions corresponding to non-skippable rollover nodes. The time corresponding to skippable rollover nodes is represented by zero latency in the latency statistics and does not increase the average. A certain processing node P2 was originally allocated 35 transactions, and after reduction, 22 were actually executed. The average single-node rollover latency decreased from the estimated 4.2 seconds before reduction to 2.8 seconds. The distribution difference of single-node rollover latency among processing nodes reflects the actual effect of load balancing within the current dynamic rollover scheduling domain. When the latency range exceeds 50% of the average single-node rollover latency of all processing nodes, it indicates uneven load distribution. The difference comes from two types of reasons: the task sharding size allocation deviation in the node allocation mapping table or the uneven distribution of skippable rollover nodes among processing nodes.

[0043] In some embodiments, the step of generating a multi-level node scheduling configuration based on the node load level assessment of the single-node convolutional latency includes: calculating the latency gradient between upstream and downstream nodes of the single-node convolutional latency to obtain the latency difference value between nodes; classifying the node load level by load grading the latency difference value between nodes; assigning level weights to the node load level to form a scheduling weight table; and generating a multi-level node scheduling configuration by mapping the node carrying capacity limit based on the scheduling weight table.

[0044] The latency gradient between upstream and downstream nodes is calculated to obtain the latency difference between nodes. Single-node convolution latency reflects the average single-step time of each processing node in the current task sequence. The latency gradient between upstream and downstream nodes measures the slope of the change in single-node convolution latency between adjacent layers in the convolution task topology graph. A steep slope indicates a significant difference in execution efficiency between adjacent layers, suggesting a structural imbalance in the allocation of scheduling resources between layers. The latency gradient calculation focuses on pairs of processing nodes connected by execution-dependent arcs in the convolution task topology graph. The difference between the single-node convolution latency of the arc head node (upstream) and the single-node convolution latency of the arc tail node (downstream) is defined as the latency gradient corresponding to that arc. When an upstream processing node undertakes a large number of shared convolution tasks, resulting in a significantly higher execution time than its downstream processing node, the latency gradient is positive, indicating a bottleneck upstream. The absolute value of the latency gradient is the latency difference between nodes. The latency difference values ​​between nodes corresponding to all execution dependency arcs are arranged according to the arc's hierarchical position in the convolution task topology diagram. The average latency difference value of arcs at the same level reflects the degree of latency dispersion between nodes within that execution level. A high average value indicates a large load difference between nodes at that level, while a low average value indicates a relatively uniform load between nodes at that level. In a certain convolution task topology diagram, there are 9 execution dependency arcs between levels 4 and 5, corresponding to 9 latency difference values ​​between nodes, with an average of 1.8 seconds and a maximum of 3.4 seconds. The upstream node corresponding to the arc with the largest latency difference value is the current load concentration point. The set of latency difference values ​​between nodes is composed of the latency difference values ​​of all dependency arcs. Arcs with high latency difference values ​​are given priority in load level upgrade marking in node load classification.

[0045] The load level of a node is determined by classifying the delay difference between nodes. Based on the distribution characteristics of the delay difference between nodes, the load level of each processing node is divided into three levels: high load, medium load, and low load. The classification boundary is determined by the ternary percentile of the entire set of delay difference values ​​between nodes. Processing nodes with a delay difference value higher than the 67th percentile are classified as high load, those between the 33rd and 67th percentiles are classified as medium load, and those below the 33rd percentile are classified as low load. The ternary percentile boundary is dynamically calculated with each batch and is not fixed to the absolute delay value. The determination of high load nodes also includes a persistence condition: if a single delay difference value is higher than the 67th percentile but does not continuously exceed the threshold within three consecutive polling intervals, the node load level is downgraded to medium load. This avoids misjudging a short-term delay peak as a sustained high load. For example, if the single-node convolution delay of a processing node P4 briefly rises to the high load range in the second polling interval and then returns to the medium load range in the third polling interval, the node load level is determined to be medium load. The identification of low-load nodes also includes a persistence condition: a node's load level is confirmed as low only if the drop value is below the 33rd percentile for more than two consecutive polling intervals. A single low drop value may be due to a temporary clearing of the node's current task queue rather than sufficient carrying capacity. Node load levels are labeled according to the processing node's encoding dimension. Each processing node holds a node load level label within the current calculation cycle. The node load level is dynamically updated within the polling interval, and the scheduling weight table row for the corresponding processing node is regenerated after the next poll when the level changes.

[0046] A scheduling weight table is formed by assigning weights to nodes based on their load levels. The results of the node load level classification are converted into a quantitative scheduling resource allocation ratio through weight allocation. Nodes with low load levels are assigned high scheduling weights to guide more new tasks to nodes with sufficient capacity, while nodes with high load levels are assigned low scheduling weights to reduce the influx of new tasks and alleviate congestion pressure. Nodes with medium load levels have intermediate weights. The grade weight value is determined by the formula W_n=1−φ×(G_n−G_avg) / G_avg, where W_n is the grade weight value of processing node n, n is the processing node number, G_n is the inter-node latency difference value of processing node n, G_avg is the average latency difference value of all processing nodes, and φ is an adjustment coefficient of 0.8. When the latency difference value of a processing node undertaking tasks in the semi-finished product intensive layer is higher than the average, W_n is less than 1, and the allocation of new tasks is limited to prevent further deterioration of the load. When a lightly loaded processing node undertaking tasks in the bottom leaf node layer has a W_n greater than 1, it undertakes more new tasks. The grade weight is truncated between 0.2 and 1.8 to prevent excessive concentration of weights caused by extreme latency differences. The scheduling weight table uses the processing node code as the row index and the grade weight as the column value, and also adds a node load level label column. The sum of the weights of all processing nodes in the scheduling weight table is normalized to 1. After normalization, the weight of each processing node directly corresponds to the allocation ratio in the total scheduling resources for the current period. The scheduling weight table is updated synchronously with the node load level during the polling interval, and the refresh cycle is consistent with the polling cycle of the single node's load calculation delay.

[0047] Multi-level node scheduling configurations are generated based on the node capacity limits mapped using the scheduling weight table. The weight value of each processing node in the scheduling weight table is the core basis for mapping the node capacity limits. The capacity limit is determined by multiplying the corresponding processing node weight in the scheduling weight table by the total number of task fragments in the current dynamic convolution scheduling domain. The product is rounded down and then incremented by 1 to obtain the initial value of the capacity limit for that processing node. Processing nodes with higher capacity limits can receive more concurrent tasks. Low-load nodes in the scheduling weight table have higher weights and correspondingly larger initial capacity limits to accommodate more new tasks. High-load nodes in the scheduling weight table have lower weights and correspondingly smaller initial capacity limits to limit the inflow of new tasks. The initial capacity limit of high-load nodes is further tightened by multiplying the product calculation result by a buffer coefficient of 0.8 to prevent the congestion from worsening. The multi-level node scheduling configuration is based on node load levels. High-load, medium-load, and low-load node sets correspond to three levels of scheduling strategies. The high-load level strategy dynamically updates the node capacity limit based on changes in the scheduling weight table. The medium-load level strategy updates the capacity limit every two polling intervals based on the scheduling weight table refresh results. The low-load level strategy keeps the capacity limit fixed at an initial value and does not dynamically adjust with polling. This difference in update frequency reduces scheduling metadata refresh overhead. After the multi-level node scheduling configuration is written, the scheduling layer determines the allocation direction of new task fragments based on the difference between the current queue depth and the corresponding capacity limit of each processing node. In the multi-level node scheduling configuration, a positive difference allows the processing node to accept new fragments; a zero or negative difference results in the processing node rejecting new fragments and transferring the task to be allocated to the processing node with the largest difference. The transfer operation refers to the binding constraints of the aggregation allocation identifier in the node allocation mapping table. Task fragments bound to strong aggregation identifiers do not participate in cross-node transfers to ensure node consistency for aggregation triggering conditions.

[0048] Step S140: Perform latency analysis on the multi-level node scheduling configuration to determine the priority transactions to be executed, collect the concurrent interval time of the priority transactions, sort them by retry frequency from high to low based on the concurrent interval time to form a rollover transaction scheduling plan, and combine the node allocation mapping table with the rollover transaction scheduling plan to summarize the rollover results and output the distributed cost rollover scheduling instruction.

[0049] In some embodiments, the step of performing latency analysis on the multi-level node scheduling configuration to determine the priority execution transactions includes: extracting historical latency records of each transaction through the multi-level node scheduling configuration to obtain a latency propagation chain graph; identifying cross-cost group dependent transactions based on the latency propagation chain graph to generate a cascaded risk transaction set; performing node idleness matching based on the cascaded risk transaction set to obtain a schedulable window; and selecting the optimal execution slot through the schedulable window to determine the priority execution transactions.

[0050] A latency propagation chain diagram is obtained by extracting historical latency records of each transaction through multi-level node scheduling configuration. The scheduling status and historical execution records of each processing node in the multi-level node scheduling configuration are the data sources for historical latency extraction. The extraction scope of historical latency records covers the measured transaction-by-transaction time of each processing node's task sequence within the most recent three complete volumetric computation periods. The load level label and scheduling weight table of each processing node in the multi-level node scheduling configuration jointly determine the reading priority of historical latency records. The historical latency records of high-load nodes are read completely first, while the historical latency records of low-load nodes are supplemented after the high-load nodes have finished reading. The historical latency records of each transaction are located and written to the latency propagation chain diagram according to the joint key of the transaction code and the processing node code. When there are execution dependency arcs connecting transactions, the sum of the average historical latency of the transactions at both ends of the dependency arc is defined as the propagation latency of that arc path. Each arc in the latency propagation chain diagram is assigned a propagation latency attribute. Arcs with high propagation latency correspond to critical execution bottleneck segments in the volumetric computation tasks covered by the multi-level node scheduling configuration. The nodes of the delay propagation chain graph correspond one-to-one with the nodes of the rollup task topology graph. Each node is assigned a historical average delay attribute. After the delay propagation chain graph is constructed, critical path analysis is performed on the longest path of the entire graph. The process traces back from the root node finished product along the longest rollup path to the underlying raw materials. The cumulative value of the historical average delay of each node on the path is defined as the theoretical lower limit of the current rollup delay. The theoretical lower limit of delay reflects that even if all rollup is executed in parallel, the overall rollup cannot be completed below this value.

[0051] Based on the latency propagation chain graph, cross-cost group dependent transactions are identified to generate a cascading risk transaction set. Each arc in the latency propagation chain graph is compared one by one according to the cost group identifiers of the two endpoints. Arcs whose endpoints belong to different cost groups are identified as cross-cost group arcs. The latency propagation of the transaction pairs corresponding to these arcs is affected not only by the execution efficiency of a single node but also by the data exchange mechanism at the cross-cost group boundary. The additional communication latency of cross-group data exchange is implicit in historical latency records but is not separately marked. Only after identifying cross-cost group dependent transactions can their cascading risks be assessed in a targeted manner. After the cross-cost group arcs are screened out, the transaction at the arc head node is used as the identification object. If the historical average latency of the arc head node transaction exceeds 1.5 times the historical average latency of all nodes in the latency propagation chain graph, it is judged as a high-risk cross-cost group dependent transaction. The path through which latency fluctuations of high-risk cross-group dependent transactions propagate to downstream cost groups is enumerated using directed reachable paths in the latency propagation chain graph. All node transactions covered by reachable paths are included in the cascading impact of the current high-risk transaction. For example, if the average latency of a certain cross-group dependent transaction is 1.8 times the average latency of the entire graph, and its reachable paths cover 11 nodes across 3 downstream cost groups, all 11 node transactions are included in the cascading impact. The cascading risk transaction set consists of the union of all high-risk cross-group dependent transactions and the node transactions covered by their reachable paths. The size of the cascading risk transaction set is positively correlated with the number of cross-cost group arcs and the proportion of high-risk arcs in the latency propagation chain graph. When the size of the cascading risk transaction set exceeds 40% of the total number of nodes in the latency propagation chain graph, it indicates that the current cross-cost group dependency structure is too complex.

[0052] The schedulable window is obtained by matching node idleness based on the cascaded risk transaction set. Each transaction in the cascaded risk transaction set is matched with the current idleness of each processing node in turn. The matching goal is to allocate high-priority transactions in the cascaded risk transaction set to processing nodes with sufficient execution capacity, so as to reduce the probability of cascading latency amplification due to node congestion. Node idleness prediction is based on the difference between the current queue depth and the capacity limit of each processing node in the multi-level node scheduling configuration. Nodes with larger differences have high current idleness, and nodes with smaller differences have low current idleness. When predicting future idleness, the estimated average single-step completion rate of the corresponding processing node in the historical latency record is added to the current difference. The estimated time window is twice the average single-node volumetric latency. Each transaction in the cascaded risk transaction set is traversed in the order of its cost group. Each transaction is matched with the processing node with the highest predicted node idleness value. After matching, the predicted idleness value of the processing node is reduced by the estimated time of the transaction. The reduced idleness value participates in the matching decision of the next transaction. The greedy matching strategy ensures that the processing node with high idleness prioritizes to undertake high-priority transactions in the cascaded risk transaction set. The schedulable window starts at the estimated completion time of all assigned tasks in the current queue for each processing node, and ends at the estimated completion time plus the available duration corresponding to the idle time prediction. The time interval between the start and end points constitutes the schedulable window of the processing node. In the cascading risk transaction set, each transaction is written into the schedulable window of the corresponding processing node according to the matching result. For example, the estimated completion time of the current queue of a certain processing node P3 is t+18 seconds, the available duration is about 32 seconds, and the schedulable window is [t+18, t+50].

[0053] The optimal execution slot is selected through schedulable windows to determine priority transactions. The goal of selecting the optimal execution slot is to find the slot allocation scheme within the schedulable windows of each processing node that results in the earliest overall completion time for the cascading risk transaction set. The overall completion time is determined by the estimated completion time of the transactions at the end of the critical path in the cascading risk transaction set. The schedulable windows are arranged from earliest to latest starting time, with the earliest starting schedulable window corresponding to the processing node that can immediately receive tasks. Transactions in the cascading risk transaction set located on the critical path of the latency propagation chain are prioritized for allocation to the earliest starting schedulable window. Cascading risk transactions on non-critical paths are matched with the remaining schedulable windows in descending order of average latency. After matching, the estimated execution times of the transaction sequences within the schedulable windows of each processing node are accumulated by the average latency. Transaction sequences whose accumulated result exceeds the end point of the schedulable window trigger overflow processing. Overflowing transactions are transferred to the next idle schedulable window for rematching. Transactions with more than 3 overflows are marked as difficult to execute and are not included in the current optimal execution slot allocation, but are downgraded to basic priority processing. After the optimal execution time slot is determined, the cascaded risk transaction set and non-cascaded risk transaction set transactions allocated to each schedulable window are arranged according to their starting position within the time slot. Priority execution transactions consist of the set of transactions with the earliest starting position within the time slot and the longest historical execution time. The common characteristic of priority execution transactions is that they are located on the critical execution path and have cross-cost group cascading propagation risks themselves or downstream. Once such transactions are delayed, they will directly prolong the completion time of the final cost summary of the finished product. In a certain period of roll calculation, the roll calculation transaction of the welding cost group assembly component and the roll calculation transaction of the hydraulic pump cost group pump body assembly are located at the top of the two critical paths, respectively. Both are determined as priority execution transactions and allocated to the earliest schedulable window to start in parallel, ensuring that the two critical paths advance synchronously rather than waiting sequentially.

[0054] The concurrent interval time of priority execution transactions is collected. During the execution of the rollover transaction scheduling plan, the scheduling layer continuously monitors enqueue events for priority execution transactions. When the same priority execution transaction is enqueued two or more times in the current rollover execution, the concurrent interval time collection is triggered. The difference between the current enqueue time and the previous dequeue time is the concurrent interval time. Priority execution transactions that are successfully executed only once do not generate collection records. Each time the same transaction code is repeatedly enqueued, the concurrent interval time value from the previous dequeue time is immediately recorded. The interval value is marked with the corresponding transaction code. Priority execution transactions that are repeatedly enqueued generate multiple concurrent interval time collection records in the current period. The distribution of concurrent intervals reflects the stability of the readyness of dependencies in priority transactions. A concentrated and short interval indicates that dependencies are repeatedly not met within a short period, while a dispersed interval suggests complex retry trigger sources. For example, a priority transaction might have 5 duplicate enqueues in the current period, corresponding to 5 concurrent interval collection records with interval values ​​of 8 seconds, 11 seconds, 9 seconds, 7 seconds, and 10 seconds. The concentrated distribution suggests that the readyness of the parent dependency of this transaction is continuously unstable. The concurrent interval collection only covers priority transactions; duplicate enqueues from non-priority transactions are not included in the current collection. After collection, the concurrent interval record set is summarized by transaction code, and the entire interval value sequence for each transaction serves as the input for retry behavior statistics analysis.

[0055] In some embodiments, the step of forming a volume computing transaction scheduling plan by prioritizing retry frequencies from high to low based on the concurrency interval includes: obtaining a transaction retry frequency distribution based on statistics of retry behavior performed based on the concurrency interval; identifying the last-level material transactions within the cost group based on the transaction retry frequency distribution to generate a hot transaction set; pre-allocating idle nodes to the hot transaction set to form a preemption scheduling identifier; and arranging the transaction execution priority according to the preemption scheduling identifier to form a volume computing transaction scheduling plan.

[0056] The retry frequency distribution of transactions is obtained by statistically analyzing retry behavior based on the concurrency interval. The concurrency interval is the difference between the current enqueue time and the previous dequeue time for the same transaction. A shorter concurrency interval indicates that the transaction was re-enqueued shortly after being dequeued due to unready dependencies, while a longer concurrency interval indicates that the retry trigger conditions for the transaction are lenient or the dependency wait time is stable. The concurrency interval of priority transactions is collected by the scheduling layer during the rollover execution. Each time a transaction is re-enqueued, the concurrency interval value from the previous dequeue time is recorded. All collected interval values ​​for the same transaction within the current rollover cycle constitute the interval time sequence of that transaction. The retry behavior statistics count the collected values ​​in the interval time series that are below the lower threshold. The lower threshold is determined by 0.5 times the historical average latency of each transaction. Intervals below the lower threshold indicate that the retry was initiated before the normal execution time of the transaction has ended. This is an early retry triggered by unmet dependency conditions. The early retry count is divided by the number of records in the interval time series to obtain the retry frequency of the transaction. The higher the retry frequency, the more likely that the dependency conditions of the transaction have repeatedly failed to be ready in time during the current rollup. The transaction retry frequency distribution is arranged with the codes of each priority execution transaction on the horizontal axis and the retry frequency value on the vertical axis. The shape of the transaction retry frequency distribution presents a long-tail structure with a few transactions having extremely high retry frequencies and most transactions having retry frequencies close to zero. The long-tail structure reflects that the unstable dependency readiness time of a few key nodes in the consolidation task topology graph is the main source of retry behavior in the current period. The retry frequency of a certain priority execution transaction is 0.73, which means that in the current consolidation, on average, one out of every 1.4 execution attempts of this transaction is an early retry due to unmet dependency conditions. The result of the transaction retry frequency distribution is fed into the last-level material transaction identification stage in the cost group as the input basis for generating the hot transaction set.

[0057] Based on the transaction retry frequency distribution, a hot transaction set is generated by identifying the last-level material transactions within a cost group. In the transaction retry frequency distribution, each transaction is jointly located according to its cost group and the layer depth of the rollup task topology. Transactions within a cost group whose layer depth equals the maximum layer depth of that cost group and have no child-level dependencies are marked as candidates for last-level material transactions. The cost of last-level materials comes directly from the material's period cost data and does not depend on the results of child-level rollup calculations; theoretically, they should not have a high retry frequency. If the rollup transaction retry frequency for raw materials such as steel plates or copper bars is high, it is usually because the period cost data table is locked by the financial system during the month-end closing period, causing a write delay. The cause can be confirmed by the corresponding material's period cost data write timestamp being later than the transaction's first execution time. Candidate transactions with a retry frequency exceeding the median of the transaction retry frequency distribution are included in the hot transaction set. The high retry frequency of last-level material transactions was identified by comparing the write timestamp of the material's period cost data with the transaction retry initiation time. Transactions with write timestamps later than the transaction's initial execution time were considered to have delayed data writes. Last-level material transactions with write timestamps later than the average concurrency interval were prioritized. Within a certain cost group, the retry frequencies of three last-level material transactions were 0.68, 0.71, and 0.55, respectively, corresponding to material period cost data write timestamps approximately 20 seconds later than the transaction's initial execution time. All three last-level material transactions were included in the hot transaction set. The high retry frequency of non-last-level material transactions in the hot transaction set stemmed from parent dependency readiness delays. These hot transactions and last-level material hot transactions were labeled with different cause types in the hot transaction set. The difference in cause types determined the different processing strategies for subsequent idle node pre-allocation.

[0058] Idle nodes are pre-allocated to form preemptive scheduling flags for hot transaction sets. The purpose of idle node pre-allocation is to pre-lock the execution slots of target processing nodes before the dependency conditions of each transaction in the hot transaction set are met. In the multi-level node scheduling configuration, processing nodes with remaining time slots after the priority execution transaction allocation participate in the idle node pre-allocation candidate. The last-level material cause type transactions in the hot transaction set are sorted according to the estimated completion time of the material period cost data. The last-level material hot transactions whose completion time falls before the start of the remaining time slot can be immediately pre-allocated to the corresponding processing node. The last-level material hot transactions whose completion time falls after the end of the remaining time slot do not participate in the current idle node pre-allocation and are still executed according to the original matching processing node in the node allocation mapping table. If the estimated completion time of the parent of the parent dependency delay cause type transaction in the hot transaction set is earlier than the start of the schedulable window, the pre-allocation is successful. If it is later than the start of the window, it is delayed to the next available processing node. The preemption scheduling identifier consists of three elements: hotspot transaction code, pre-allocated processing node code, and pre-allocated activation time. After the material period cost data is written to completion time and the remaining time slot of the processing node is aligned, the corresponding activation time is generated. When the activation time arrives, the scheduling layer pushes the corresponding hotspot transaction to the head of the target processing node queue and inserts it into the front of the current queue for execution. After the preemption scheduling identifier is generated, it is bound to the corresponding transaction code in the hotspot transaction set. The binding relationship serves as the basis for the highest priority layer in the rollup transaction scheduling plan arrangement stage.

[0059] The volume computation transaction scheduling plan is formed by prioritizing transactions based on preemption scheduling flags. The order of transaction execution priorities is based on the highest priority level: the set of hot transactions covered by the preemption scheduling flags. Next are the priority transactions, and the remaining non-hot and non-priority transactions are arranged in ascending order of volume computation task topology layer depth. These three priority levels together constitute the basis for the entire volume computation transaction scheduling plan. Hot transactions with different preemption scheduling flag activation times are arranged in ascending order of activation time within the highest priority level. Hot transactions with the same activation time are sorted by retry frequency from high to low as the secondary sorting key. Within the priority transaction layer, priority is given to transactions along the critical path in the latency propagation chain diagram. Non-critical path priority transactions are arranged in descending order of historical average latency. Transactions at the same level within the basic priority are arranged in ascending order of retry frequency. Transactions with high retry frequencies but not included in the hot transaction set are placed later and do not participate in the current highest priority level scheduling. The rollup transaction scheduling plan merges the three-level priority into a full transaction execution sequence. Each transaction in the rollup transaction scheduling plan is labeled with its priority level and the target processing node code. The target processing node code is jointly determined by the node allocation mapping table and the preemption scheduling flag. Hot transactions covered by the preemption scheduling flag are based on the pre-allocated processing nodes within the flag, while other transactions are based on the matching results of the node allocation mapping table. When there is a conflict between the two sources, the preemption scheduling flag has a higher priority than the node allocation mapping table. After the rollup transaction scheduling plan is generated, it is passed to the rollup result summary stage as the basis for execution.

[0060] The distributed cost calculation scheduling instruction is output by summarizing the calculation results and outputting the calculation result summary table and the calculation transaction scheduling plan. After the calculation transaction scheduling plan is executed, each processing node submits its local calculation result according to the execution hierarchy of the cost group corresponding to each task segment in the node allocation mapping table, based on the completion status of the transaction sequence assigned to it in the calculation transaction scheduling plan. The steel plate blanking cost of the stamping cost group is submitted first, and the welding cost group submits the welding component cost only after receiving all stamping part results. The dependency relationship is satisfied when the summary layer splices the results across cost groups. When the processing node carrying the aggregation allocation identifier submits the result, it attaches an aggregation trigger confirmation flag. After receiving the confirmation flag, the summary layer checks whether all task segment results are complete according to the binding relationship of the corresponding aggregation allocation identifier in the node allocation mapping table. If not, it suspends and waits. After all are complete, the component cost values ​​of the same material code in each segment are added together to obtain the complete calculation cost. After the aggregation is completed, an integrity check is performed on the total number of nodes in each cost group and the number of nodes that have received results. The check passes when all transactions covered by the rollover transaction scheduling plan have been completed. If the number of nodes is inconsistent, the missing node code and corresponding processing node are located according to the node allocation mapping table, and the execution is retried according to the priority label of the transaction in the rollover transaction scheduling plan. The processing node code of the corresponding row in the node allocation mapping table is updated synchronously with the retried result. The distributed cost rollover scheduling instruction uses the verified full rollover results as the content and is arranged and output according to the dual dimensions of cost group and material code. The material code of the rollover path containing the supplementary node is marked with a confidence downgrade label. If a raw material is supplemented with the previous period's price because the supplier has not yet entered the current period's price, the corresponding finished product cost is marked with a confidence downgrade in the instruction. After the distributed cost rollover scheduling instruction is output, the current period's dynamic rollover scheduling domain releases resources.

[0061] To implement the cost accounting distributed parallel convolution method corresponding to the above method embodiments, in order to achieve the corresponding functions and technical effects. See also Figure 2 , Figure 2 This paper illustrates a structural block diagram of a distributed parallel computation system 200 for cost accounting provided in an embodiment of this application, including: Data acquisition module 201 is used to acquire BOM level expansion data and material period cost data, and to construct a rollup task topology map based on the BOM level expansion data and the material period cost data by performing dependency path parsing. The task splitting module 202 is used to delineate the rollup layering range according to the rollup task topology diagram, perform node reuse and load feature extraction on the BOM level expanded data and the material period cost data to generate task fragmentation weight coefficients, and split the rollup layering range into a dynamic rollup scheduling domain through the task fragmentation weight coefficients. The node allocation module 203 is used to process the dynamic convolution scheduling domain, match nodes to form a node allocation mapping table, divide convolution transactions based on the node allocation mapping table to determine cost acquisition transactions and cost inheritance transactions, perform cross-level cost inheritance mapping on the cost acquisition transactions and the cost inheritance transactions to obtain single-node convolution latency, and evaluate the node load level based on the single-node convolution latency to generate multi-level node scheduling configuration. The transaction scheduling module 204 is used to perform latency analysis on the multi-level node scheduling configuration to determine the priority of execution transactions, collect the concurrency interval time of the priority execution transactions, sort the retry frequency from high to low based on the concurrency interval time to form a volume calculation transaction scheduling plan, and combine the node allocation mapping table with the volume calculation transaction scheduling plan to summarize the volume calculation results and output the distributed cost volume calculation scheduling instruction.

[0062] The aforementioned cost-accounting distributed parallel convolutional computing system 200 can implement a cost-accounting distributed parallel convolutional computing method according to the above method embodiments. The options in the above method embodiments are also applicable to this embodiment, and will not be detailed here. The remaining content of this application's embodiments can be referred to the content of the above method embodiments, and will not be repeated in this embodiment.

[0063] The above embodiments are not an exhaustive list based on the present invention, and there may be many other embodiments not listed. Any substitutions and improvements made without departing from the concept of the present invention are within the protection scope of the present invention.

Claims

1. A distributed parallel convolutional computation method for cost accounting, characterized in that, include: Obtain BOM hierarchical expansion data and material period cost data, and construct a rollup task topology map based on the BOM hierarchical expansion data and material period cost data; The scope of the calculation layer is defined according to the calculation task topology diagram. The BOM level expansion data and the material period cost data are used to perform node reuse and load feature extraction to generate task fragmentation weight coefficients. The calculation layer is then split into tasks to form a dynamic calculation scheduling domain. The dynamic convolution scheduling domain is processed to match nodes to form a node allocation mapping table. Based on the node allocation mapping table, convolution transactions are divided to determine cost acquisition transactions and cost inheritance transactions. Cross-level cost inheritance mapping is performed on the cost acquisition transactions and the cost inheritance transactions to obtain the single-node convolution latency. The node load level is evaluated based on the single-node convolution latency to generate a multi-level node scheduling configuration. The multi-level node scheduling configuration is analyzed for latency to determine priority transactions. The concurrency interval of the priority transactions is collected. Based on the concurrency interval, the transaction scheduling plan is formed by prioritizing the retry frequency from high to low. The results of the calculation are summarized and output as distributed cost calculation scheduling instructions by combining the node allocation mapping table and the calculation transaction scheduling plan.

2. The method according to claim 1, characterized in that, The process of constructing a topology graph for the roll-off task based on dependency path parsing of the BOM-level expanded data and the material period cost data includes: The material dependency set is obtained by traversing the hierarchical nodes of the BOM hierarchical expansion data. Identify the multi-path convergence nodes of the material dependency set to generate a dependency path graph; Based on the material period cost data and the dependency path diagram, cost group boundary labeling is performed to obtain the rollup priority sequence; The execution order of the execution hierarchy is arranged by the execution priority sequence to construct the execution task topology graph.

3. The method according to claim 1, characterized in that, The step of reusing nodes and extracting load features from the BOM-level expanded data and the material period cost data to generate task fragmentation weight coefficients includes: Based on the BOM hierarchy data, the frequency of node references is statistically analyzed to obtain the reuse rate of shared material nodes. The high reuse rate of the shared material nodes is used to identify high reuse nodes and generate aggregation allocation identifiers. Based on the material period cost data, perform inter-period reference change rate analysis to obtain load assessment parameters; The task sharding weight coefficient is generated based on the aggregation allocation identifier and the load evaluation parameters.

4. The method according to claim 1, characterized in that, The step of performing cross-level cost inheritance mapping between the cost acquisition transaction and the cost inheritance transaction to obtain the single-node volume computation latency includes: Extract the cost to obtain the completed calculation results of the transaction and construct a hierarchical cache table; Based on the hierarchical cache table and the cost inheritance transaction, the hit rate is obtained by matching the child results layer by layer upwards; Obtain skippable computation nodes by executing transactions with zero cost change based on the hit rate; The single-node computation latency is obtained based on the reduced mapping path that can skip computation nodes.

5. The method according to claim 1, characterized in that, The step of generating multi-level node scheduling configurations based on the single-node load level assessment of convolutional latency includes: Calculate the latency gradient between upstream and downstream nodes of the single-node convolution latency to obtain the latency difference value between nodes; The load level of a node is obtained by classifying the time delay difference between the nodes according to the load classification. The node load levels are weighted and assigned to form a scheduling weight table; Multi-level node scheduling configurations are generated based on the node carrying capacity limit mapped by the scheduling weight table.

6. The method according to claim 1, characterized in that, The step of performing latency analysis on the multi-level node scheduling configuration to determine the priority of transactions includes: The latency propagation chain diagram is obtained by extracting historical latency records of each transaction through the multi-level node scheduling configuration. Based on the aforementioned delay propagation chain graph, a cascaded risk transaction set is generated by identifying cross-cost group dependent transactions. Based on the cascaded risk transaction set, node idleness is matched to obtain a schedulable window; The optimal execution slot is selected through the schedulable window to determine the priority of the transaction.

7. The method according to claim 1, characterized in that, The process of forming a volume computation transaction scheduling plan based on the concurrency interval and prioritizing retry frequencies from high to low includes: The retry frequency distribution of transactions is obtained by statistically analyzing the retry behavior based on the concurrency interval. Based on the transaction retry frequency distribution, identify the last-level material transactions within the cost group and generate a hotspot transaction set. The hot transaction set is pre-allocated to idle nodes to form a preemptive scheduling identifier; The transaction execution priority is arranged according to the preemption scheduling identifier to form a volumetric transaction scheduling plan.

8. The method according to claim 3, characterized in that, The step of identifying high-reuse nodes and generating aggregation allocation identifiers based on the reuse rate of shared material nodes includes: Analyze the inter-period reuse rate trend of the shared material nodes to pinpoint the critical point of sudden decrease in reuse rate; Based on the aforementioned reuse rate sudden threshold, a node classification table is generated by defining the interval of dependent fracture nodes. Cross-cost group association analysis is performed based on the node hierarchy table to obtain cross-group aggregation features; Based on the cross-group aggregation features, the node aggregation boundary is extracted to generate an aggregation assignment identifier.

9. The method according to claim 4, characterized in that, The step of matching child results upwards layer by layer based on the hierarchical cache table and the cost inheritance transaction to obtain the hit rate includes: The cache coverage is obtained by retrieving valid cache entries from the hierarchical cache table. Perform a hierarchical depth-weighted matching of the cache coverage and the cost inheritance transaction to obtain a matching result set; The matching result set is classified into hit and miss categories to obtain the category count; The hit rate is determined by calculating the hit percentage based on the classification count.

10. A distributed parallel computation system for cost accounting, characterized in that, include: The data acquisition module is used to acquire BOM-level expanded data and material period cost data, and to construct a topology map of the rollup task based on the BOM-level expanded data and material period cost data. The task splitting module is used to define the rollup layering range according to the rollup task topology diagram, perform node reuse and load feature extraction on the BOM level expanded data and the material period cost data to generate task fragmentation weight coefficients, and split the rollup layering range into a dynamic rollup scheduling domain through the task fragmentation weight coefficients. The node allocation module is used to process the dynamic convolution scheduling domain, match nodes to form a node allocation mapping table, divide convolution transactions based on the node allocation mapping table to determine cost acquisition transactions and cost inheritance transactions, perform cross-level cost inheritance mapping on the cost acquisition transactions and the cost inheritance transactions to obtain single-node convolution latency, and evaluate the node load level based on the single-node convolution latency to generate multi-level node scheduling configuration. The transaction scheduling module is used to perform latency analysis on the multi-level node scheduling configuration to determine the priority of transactions, collect the concurrency interval of the priority transactions, sort the retry frequencies from high to low based on the concurrency interval to form a volume calculation transaction scheduling plan, and combine the node allocation mapping table with the volume calculation transaction scheduling plan to summarize the volume calculation results and output the distributed cost volume calculation scheduling instruction.

Images