A PLM system BOM data distributed transaction processing method

Abstract

This invention provides a distributed transaction processing method for BOM data in a PLM system, belonging to the technical field of PLM systems. When initiating a BOM data modification transaction, this invention sends a preparation request to participating nodes and performs field-level lock acquisition. A majority vote determines whether the transaction should be committed or rolled back. Transaction logs are batch-aggregated into group commit log blocks according to time windows and copied to persistent memory via RDMA. A closure table is established for the BOM tree structure to store ancestor-descendant relationships. An artificial intelligence model is used to monitor node response latency and log write rate to dynamically adjust parameters. When a network partition is detected, nodes holding a majority lease continue processing the transaction. After partition recovery, data merging is performed using version vector conflict detection and a compensation transaction mode. This solves the problem of data consistency being difficult to guarantee due to network partitions when processing BOM data modification transactions in a distributed PLM system.

Description

Technical Field

[0001] This invention belongs to the field of PLM system technology, and more specifically, relates to a distributed transaction processing method for BOM data in a PLM system. Background Technology

[0002] In product lifecycle management systems (PLMs), distributed transaction processing of BOM data typically employs a two-phase commit protocol to ensure cross-node data consistency. The coordinator sends a prepare request to each participating node and waits for responses from all nodes before deciding whether to commit or rollback. Traditional solutions use row-level locking to avoid concurrent modification conflicts and synchronous log replication to ensure data persistence. However, in current distributed PLM systems, network partitioning failures can prevent the coordinator from receiving responses from all nodes. Traditional two-phase commit protocols cannot determine whether to commit or rollback transactions during network partitioning. Continuing to commit may lead to data inconsistency, while a forced rollback sacrifices system availability. Furthermore, the coarse-grained row-level locking can cause unnecessary lock conflicts when different transactions operate on different attributes of the same BOM node, and the delay in log replication impacts transaction throughput. In other words, existing technologies present a technical problem in distributed PLM systems where network partitioning makes it difficult to guarantee data consistency when processing BOM data modification transactions. Summary of the Invention

[0003] In view of this, the present invention provides a distributed transaction processing method for BOM data in a PLM system, which can solve the technical problem in the prior art where distributed PLM systems have difficulty in ensuring data consistency due to network partitioning when processing BOM data modification transactions.

[0004] This invention is implemented as follows: It provides a distributed transaction processing method for BOM data in a PLM system. A distributed transaction coordinator is deployed on each data center node of the PLM system, and a lease management module is established based on a majority arbitration mechanism to record the set of nodes holding leases and the lease expiration timestamps. When initiating a BOM data modification transaction, a transaction preparation request is sent to all participating nodes, and a field-level lock is executed to acquire and generate a local transaction log. The response status of each participating node is collected, and the number of nodes with a majority vote is obtained to determine whether to enter the transaction commit phase or execute the rollback process. The transaction logs to be committed are batch-aggregated according to time windows to form group commit log blocks, which are then transmitted and replicated via RDMA. In the persistent memory area of ​​the remote node, a closure table is established to store the ancestor-descendant relationship of the BOM tree structure. A transaction state drift detection model is used to monitor the node response latency distribution and log write rate distribution during the execution of distributed transactions. The field-level lock granularity parameters and group commit window duration parameters are adjusted according to the drift level. When a network partition failure is detected, the set of nodes holding a majority lease continues to process transaction requests, while the set of nodes without leases enters read-only mode and records the version vector. After the network partition is recovered, the version vectors of each node are extracted for conflict detection. For BOM data items with write-write conflicts, a reverse operation sequence is generated using the compensating transaction SAGA mode to perform data merging.

[0005] The majority arbitration mechanism refers to a voting protocol in a distributed system that requires more than half of the nodes to reach a consensus on a transaction before it can be submitted. The determination condition is that the number of nodes receiving positive responses is greater than half of the total number of nodes.

[0006] The lease management module is used to allocate time-limited exclusive write permission credentials to nodes holding majority votes. The lease includes a start timestamp, validity period, and a list of authorized nodes. The lease duration is dynamically calculated based on the statistical quantile of network round-trip latency.

[0007] The field-level lock refers to a locking mechanism that refines traditional row-level locks to the granularity of a single field in a data table. It locks only the fields that are actually modified by the transaction, rather than locking the entire row record. This is achieved by maintaining an independent lock flag bitmap for each field in memory.

[0008] The group commit log block merges the redo logs and undo logs of multiple transactions within a time window into a single contiguous storage block. The default value of the time window is 5 milliseconds. Batch writing is triggered when the number of transactions accumulated within the window reaches a threshold or the window times out.

[0009] The RDMA transmission refers to Remote Direct Memory Access technology, which allows one node to bypass the operating system kernel and directly read and write the memory area of ​​another node. The log replication latency is reduced to the microsecond level. It needs to be supported at the network interface card level and implemented through the verbs interface programming.

[0010] The persistent memory region refers to a storage region constructed using non-volatile memory media, which has access speeds close to DRAM and persistent characteristics that prevent data loss after power failure. The persistent memory is exposed to the application through a memory-mapped file interface.

[0011] The closure table is a flattened relational table used to store all ancestor-descendant pairs in a tree structure. Each record in the table contains a pair of nodes with an ancestor relationship and their hierarchical interval. To query all descendants of a node, a single range scan is required of all records in the table whose ancestor column is equal to the target node.

[0012] Each record in the closure table stores the node identifier, ancestor node identifier, level depth, and materialized path string. The materialized path string refers to the complete path from the root node to the current node recorded in each node of the BOM tree. The path is represented by a sequence of forward slashes separating the node identifiers.

[0013] The version vector is a logical clock mechanism used in the distributed system to track causal relationships and detect conflicts. Each node maintains a vector to record the operation counts of itself and other nodes. The order of operations or concurrent conflicts are determined by comparing the size relationship of the components of two version vectors.

[0014] The SAGA compensation transaction mode is a distributed transaction processing mode that breaks down long transactions into multiple short transaction sub-steps. Each sub-step has a corresponding compensation operation to roll back the executed modifications. When a conflict is detected, the compensation operation sequence is executed to restore data consistency.

[0015] The transaction state drift detection model's input layer receives the normalized feature vectors of the node response delay sequence and the log write rate sequence. It extracts temporal local features through a convolutional layer, downsamples the convolutional output to reduce the feature dimension through a pooling layer, maps the features to a drift level probability distribution through a fully connected layer, and generates probability values ​​for four categories—mild drift, moderate drift, severe drift, and normal state—through a Softmax function.

[0016] Among them, the transaction state drift detection model adopts a factor graph structure to model the correlation between nodes as edge connections of the graph. The marginal probability of drift state is transmitted between graph nodes through the belief propagation algorithm. The variational inference technique is used to approximate the hard-to-calculate true posterior distribution into a family of variational distributions that are easy to handle. The variational parameters are optimized by using the KL divergence minimization objective function. The joint probability distribution is sampled by the Gibbs sampling algorithm to generate drift level prediction results that conform to the node dependency relationship.

[0017] Specifically, the convolutional layers of the transaction state drift detection model are periodically drift detected, the mean energy deviation of the output feature maps of each channel is calculated, the cosine similarity of the weight update direction is calculated, and the drift level of the convolutional layer is determined as mild, moderate or severe based on the numerical range of the mean energy deviation and cosine similarity.

[0018] Specifically, when the drift level of the convolutional layer is mild, Gaussian white noise is added to the training samples input to the convolutional layer or uniformly distributed noise is added to the feature tensor output by the convolutional layer. When the drift level of the convolutional layer is moderate, the convolutional layer is replaced with sparse convolutional kernels and the other layers except the convolutional layer are frozen. The convolutional layer is then fine-tuned using a fine-tuned learning rate.

[0019] Specifically, when the drift level of the convolutional layer is severe, a depth-separable convolutional layer is used to replace the original convolutional layer, followed by a dimensionality reduction convolutional layer and a residual module. All other layers except the depth-separable convolutional layer are frozen for fine-tuning until the drift level is restored. The depth-separable convolutional layer decomposes the standard convolution into two steps: channel-wise convolution and point-wise convolution.

[0020] This invention deploys a distributed transaction coordinator based on a majority arbitration mechanism. When initiating a BOM data modification transaction, it sends a preparation request to all participating nodes, counts the number of nodes receiving a majority vote to determine whether the transaction should be committed or rolled back, applies field-level locking to the concurrent control of BOM data items, employs group commit technology to batch aggregate transaction logs within a time window and replicates them to persistent memory via RDMA, and establishes a transaction state drift detection model to monitor node response latency and log write rate to dynamically adjust lock granularity and group commit window parameters. When a network partition is detected, the set of nodes holding a majority lease continues to process the transaction, while nodes without leases enter read-only mode. After the network partition is recovered, conflict detection is performed using version vectors, and data merging is executed using a compensating transaction mode. This resolves the contradiction between data consistency and system availability that traditional two-phase commit protocols cannot guarantee during network partitions. In summary, this invention solves the technical problem mentioned in the background art where distributed PLM systems struggle to guarantee data consistency due to network partitions when processing BOM data modification transactions. Attached Figure Description

[0021] Figure 1 This is a flowchart of the method of the present invention.

[0022] Figure 2 This is a comparison chart of field-level lock conflict probabilities.

[0023] Figure 3 A comparison chart of the number of I / O operations submitted by the group.

[0024] Figure 4 This is a graph showing the accuracy of the drift detection model.

[0025] Figure 5 This is a graph showing the conflict detection results after network partition recovery. Detailed Implementation

[0026] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions in the embodiments of the present invention will be clearly and completely described below.

[0027] like Figure 1 The diagram shown is a flowchart of a distributed transaction processing method for BOM data in a PLM system provided by the present invention. This method includes the following steps: S1. Deploy a distributed transaction coordinator on each data center node of the PLM system. The distributed transaction coordinator establishes a lease management module based on a majority arbitration mechanism to record the set of nodes currently holding leases and the lease expiration timestamp. S2. When a BOM data modification transaction is initiated, the distributed transaction coordinator sends a transaction preparation request to all participating nodes. Each participating node performs field-level lock acquisition on the relevant BOM data items and generates a local transaction log. S3. Collect the response status of each participating node and count the number of nodes that have obtained a majority vote. If the majority condition is met, proceed to the transaction commit phase; otherwise, perform lease timeout detection and trigger the transaction rollback process. S4. Aggregate the transaction logs to be committed in batches according to the time window to form group commit log blocks, and copy the group commit log blocks to the persistent memory area of ​​the remote node through RDMA transmission. S5. Establish a closure table for the BOM tree structure to store ancestor-descendant relationships, and store the node identifier, ancestor node identifier, level depth and materialized path string for each record in the closure table; S6. Employ a transaction state drift detection model to monitor the node response latency distribution and log write rate distribution during the execution of distributed transactions, and adjust the field-level lock granularity parameters and group commit window duration parameters according to the drift level. S7. When a network partition failure is detected, the set of nodes holding a majority of leases continues to process transaction requests, while the set of nodes not holding leases enters read-only mode and records the version vector. S8. After network partition recovery, extract the version vector of each node for conflict detection. For BOM data items with write-write conflicts, use the compensation transaction SAGA mode to generate a reverse operation sequence and perform data merging.

[0028] The majority arbitration mechanism refers to a voting protocol in a distributed system that requires more than half of the nodes to reach a consensus on a transaction before it can be committed. This mechanism ensures that even if a network partition occurs, only one partition will have write permissions, thus avoiding data inconsistency caused by split-brain. The criterion for this is that the number of nodes receiving positive responses is greater than half of the total number of nodes.

[0029] The lease management module is used to allocate time-limited exclusive write permission credentials to nodes holding majority votes. The lease includes a start timestamp, validity period, and authorized node list. When the lease expires, the lock resources of the corresponding data item are automatically released to prevent permanent lock occupation due to node failure. The lease duration is dynamically calculated based on the statistical quantile of network round-trip latency.

[0030] The field-level lock refers to a locking mechanism that refines traditional row-level locks to the granularity of a single field in a data table. It locks only the fields that the transaction actually modifies, rather than locking the entire row record, which significantly reduces the probability of lock conflicts when different transactions operate on different attributes of the same BOM node. Field-level locks are implemented by maintaining an independent lock flag bitmap for each field in memory.

[0031] The group commit log block is a technique that merges the redo logs and undo logs of multiple transactions within a time window into a single contiguous storage block. By batch flushing the disk, multiple random disk write operations are transformed into a single sequential write operation. The default value of the time window is 5 milliseconds. When the number of transactions accumulated within the window reaches a threshold or the window times out, batch writing is triggered. This technique reduces the number of disk I / O operations to one-tenth of the original.

[0032] The RDMA transmission refers to Remote Direct Memory Access technology, which allows one node to bypass the operating system kernel and directly read and write the memory area of ​​another node, avoiding the data copying and context switching overhead in traditional network transmission. The log copying latency is reduced to the microsecond level. RDMA needs to be supported at the network interface card level and implemented through the verbs interface programming.

[0033] The persistent memory region refers to a storage region constructed using non-volatile memory media such as Intel Optane. It combines access speeds close to DRAM with persistent characteristics that prevent data loss after power failure. The write latency is in the hundreds of nanoseconds range, which is two orders of magnitude better than the tens of microseconds latency of traditional SSDs. The persistent memory is exposed to applications through a memory-mapped file interface.

[0034] The closure table is a flattened relational table used to store all ancestor-descendant pairs in a tree structure. Each record in the table contains a pair of nodes with an ancestor relationship and their hierarchical interval. To query all descendants of a node, only a single range scan is needed to scan all records in the table whose ancestor column is equal to the target node, avoiding multiple database round trips for recursive queries.

[0035] The materialized path string refers to the complete path from the root node to the current node recorded in each node of the BOM tree. The path is represented by a sequence of forward slashes separating the node identifiers. When querying the subtree, it is achieved by matching the path prefix. Updating the path string requires cascading modification of the path values ​​of all descendant nodes, which is suitable for BOM scenarios with more reads and fewer writes.

[0036] The version vector is a logical clock mechanism used in a distributed system to track causal relationships and detect conflicts. Each node maintains a vector to record the operation counts of itself and other nodes. The order of operations or concurrent conflicts are determined by comparing the size relationship of the components of two version vectors. If the two version vectors do not satisfy the partial order relationship and are not equal, it indicates that there is a conflict.

[0037] The SAGA compensation transaction mode is a distributed transaction processing mode that breaks down long transactions into multiple short transaction sub-steps. Each sub-step has a corresponding compensation operation to roll back the modifications that have been executed. When a conflict is detected, instead of rolling back directly, a sequence of compensation operations is executed to restore data consistency. The compensation operations include operations with opposite semantics, such as reversing value modification, deleting newly added records, or restoring deleted records.

[0038] The specific structure of the transaction state drift detection model is as follows: the input layer receives the feature vectors of the node response delay sequence and the log write rate sequence after normalization; the first convolutional layer uses a one-dimensional convolutional kernel to extract local temporal features and activates them using the ReLU function; the pooling layer downsamples the convolutional output to reduce the feature dimension; the second convolutional layer further extracts higher-order features; the fully connected layer maps the features to the drift level probability distribution; the output layer generates probability values ​​for four categories—mild drift, moderate drift, severe drift, and normal state—using the Softmax function; the model uses a factor graph structure to model the correlation between nodes as edge connections in the graph; the marginal probability of the drift state is transmitted between graph nodes through a belief propagation algorithm; variational inference technology is used to approximate the difficult-to-calculate true posterior distribution into a family of variational distributions that are easy to process; the variational parameters are optimized using the KL divergence minimization objective function; and finally, the joint probability distribution is sampled using the Gibbs sampling algorithm to generate drift level prediction results that conform to the node dependency relationship.

[0039] The steps for establishing the training dataset for the transaction state drift detection model specifically include recording 30 days of distributed transaction execution logs in a normally operating PLM system, extracting the node response latency sequence and the corresponding node log write rate sequence for each transaction from the logs as raw samples, manually labeling the drift level of each sample, generating mild drift samples by adding Gaussian noise to the latency sequence for normal state samples, generating moderate drift samples by scaling the write rate and introducing periodic fluctuations, and generating severe drift samples by simultaneously applying latency spikes and rate drops, and dividing the labeled samples into training set, validation set and test set in a ratio of 7:2:1.

[0040] The specific steps for training the transaction state drift detection model include: initializing the convolutional layer weights to Xavier distribution sampling values, setting the initial learning rate to 0.001 and using the Adam optimizer, inputting the training set samples into the model with a batch size of 32, calculating the cross-entropy loss between the output drift level probability distribution and the true label during forward propagation, adding a regularization term based on the factor graph structure to the loss function to penalize prediction results that violate node dependencies, calculating the gradient and updating the model parameters during backpropagation, evaluating the accuracy on the validation set every 10 epochs, and reducing the learning rate to one-tenth of the original when the validation set accuracy does not improve for 5 consecutive epochs. Training is repeated until the validation set accuracy converges or the maximum number of training epochs (200) is reached, and the model parameters with the highest validation set accuracy are selected as the final model.

[0041] The factor graph structure models the drift state of each node in the distributed system as random variable nodes. The correlation between nodes is represented by factor nodes, which encode the joint probability distribution of a certain combination of nodes. Probability information is iteratively transmitted between variable nodes and factor nodes through a sum-product message passing algorithm. Variable nodes receive messages from neighboring factor nodes, multiply them, and normalize them to obtain marginal probabilities. Factor nodes receive messages from neighboring variable nodes, sum and marginalize unobserved variables, and then transmit them. After several iterations, the marginal probabilities of each variable node converge to an approximation of the true posterior distribution. This framework enables the model to simultaneously consider the temporal characteristics of a single node and the spatial dependencies between multiple nodes, avoiding the inconsistency in predictions caused by treating each node as an independent sample. When a node is detected to be drifting, the monitoring sensitivity of its frequently communicating neighboring nodes is automatically increased. Soft constraint modeling of the drift propagation path is achieved through probabilistic inference rather than hard rules, improving the anomaly detection accuracy of the entire distributed system by 12 percentage points compared to the independent classification model and reducing the false alarm rate to one-quarter of the original. At the same time, the sparse connection structure of the factor graph ensures that the computational complexity of the inference algorithm is linearly related to the number of nodes rather than exponentially related.

[0042] The temperature parameter of the attention mechanism in the transaction state drift detection model is determined based on three parameters: the current system transaction concurrency, the frequency of network partitioning, and the average depth of the BOM tree. A concurrency fitness function is defined, which divides the transaction concurrency by the upper limit of the system's designed concurrency to obtain the normalized concurrency, divides the frequency of network partitioning by the historical average frequency to obtain the normalized partitioning frequency, and divides the average depth of the BOM tree by the designed maximum depth to obtain the normalized depth. The three normalized values ​​are multiplied by weight coefficients of 0.5, 0.3, and 0.2, respectively, and then summed to obtain the comprehensive fitness value. When the comprehensive fitness value is less than 0.3, the temperature parameter is set to 0.5 to enhance the focus of attention. When the comprehensive fitness value belongs to the interval [0.3, 0.7), the temperature parameter is set to 1.0 to maintain the standard attention distribution. When the comprehensive fitness value is greater than or equal to 0.7, the temperature parameter is set to 2.0 to smooth the attention distribution and improve the robustness of the model.

[0043] Periodically perform drift detection on the convolutional layers of the transaction state drift detection model, calculate the mean energy deviation of the output feature maps for each channel, where the mean energy deviation equals the current mean energy of the output feature maps for each channel minus the historical mean energy of the output feature maps for each channel, and calculate the cosine similarity of the weight update direction. When 0.02 ≤ mean energy deviation < 0.2 and 0.75 ≤ cosine similarity < 0.9, the drift level of the convolutional layer is mild; when 0.2 ≤ mean energy deviation < 1.0 and 0.9 ≤ cosine similarity < 0.97, the drift level of the convolutional layer is moderate; when the mean energy deviation is greater than or equal to 1.0 and the cosine similarity is greater than or equal to 0.97, the drift level of the convolutional layer is severe; when the mean energy deviation is greater than or equal to 1.0 and the cosine similarity is greater than or equal to 0.97, the drift level of the convolutional layer is severe. When the layer drift level is mild, Gaussian white noise is added to the training samples input to the convolutional layer or uniformly distributed noise is added to the feature tensor output by the convolutional layer during each training iteration. When the drift level of the convolutional layer is moderate, the convolutional layer is replaced with sparse convolutional kernels and the other layers are frozen. The convolutional layer is fine-tuned using a fine-tuned learning rate. Then, the activation map output by the convolutional layer is channel-compressed to obtain a compressed activation map. The compressed activation map is used as the input of the next layer. The convolutional layer is fine-tuned again and lightweight recovery training is performed. When the drift level of the convolutional layer is severe, the original convolutional layer is replaced with a depthwise separable convolutional layer and then connected to a dimensionality reduction convolutional layer and a residual module. The other layers are frozen and fine-tuned until the drift level is recovered.

[0044] The energy mean of the output feature map of each channel refers to the energy metric obtained by summing the squares of all elements in the feature map of each channel output by the convolutional layer and dividing by the total number of elements. The historical energy mean is maintained by the exponential moving average method to maintain the energy mean of several past batches. An increase in the energy mean deviation indicates that the feature distribution extracted by the convolutional layer has changed significantly, which may be due to data distribution drift or model forgetting.

[0045] The cosine similarity of the weight update direction refers to the cosine value of the angle between the weight change vectors in two consecutive gradient update steps. The current update vector is obtained by subtracting the previous weight from the current weight, and the historical update vector is obtained by subtracting the weight before the previous weight from the previous weight. The cosine similarity is obtained by dividing the dot product of the two vectors by their respective Euclidean norms. A value close to 1 indicates that the weight update direction remains stable, while a value significantly deviating from 1 indicates that the optimization trajectory has changed drastically and may have fallen into a local extremum or experienced gradient explosion.

[0046] The sparse convolution kernel replacement refers to setting the absolute value of the weights in the convolutional layer to zero to form a sparse connection mode. The threshold is determined according to the percentile of the weight distribution. After sparsification, the 30% of connections with the largest absolute weights are retained. This operation reduces the number of parameters, lowers the risk of overfitting, and accelerates convolution calculation.

[0047] The depthwise separable convolutional layer decomposes standard convolution into two steps: channel-wise convolution and pointwise convolution. Channel-wise convolution applies a spatial convolution kernel independently to each channel of the input, while pointwise convolution uses a 1×1 convolution kernel to linearly combine the output of channel-wise convolution. The number of parameters and computational cost are reduced to one-eighth to one-ninth of that of standard convolution. In drift scenarios, depthwise separable convolution can replace traditional convolution and enable rapid reconstruction of feature extraction capabilities.

[0048] Optionally, the present invention also provides a method for implementing a distributed transaction processing system for PLM system BOM data through a computer, wherein the computer is provided with a readable storage medium, the readable storage medium stores program instructions, and the program instructions execute the above-described method when running in the computer.

[0049] The specific implementation methods of the above steps are described in detail below.

[0050] The specific implementation of step S1 involves deploying a distributed transaction coordinator component on each data center node of the product lifecycle management system. This component embeds a lease management module based on a majority arbitration mechanism. First, during the system initialization phase, a node topology discovery mechanism is established through heartbeat messages between nodes. The network addresses and communication latency parameters of each node are collected and stored in a distributed configuration center. Then, the lease management module dynamically calculates the lease validity period based on the 95th percentile of the network round-trip latency, with a reference value of 150 milliseconds to 300 milliseconds. By broadcasting lease request messages to all nodes and waiting for responses, a lease is obtained when more than half of the nodes respond positively, and the list of authorized nodes is recorded. At the same time, the lease start timestamp and expiration timestamp are written to the distributed metadata storage. This mechanism uses majority voting to ensure that even if a network partition occurs, only one set of nodes holds write permissions, thereby avoiding the split-brain problem. The lease management module periodically checks whether the current time exceeds the lease expiration timestamp. If it does, it automatically releases the lock resources of the corresponding data item and triggers a re-election process. The purpose of this step is to establish a fault-tolerant transaction coordination infrastructure in a distributed environment.

[0051] The specific implementation of step S2 is as follows: When the client initiates a transaction to modify bill of materials data, the distributed transaction coordinator first parses the set of data item identifiers involved in the transaction, and then sends a preparation request message containing the transaction identifier and operation type to all data nodes participating in the transaction. After receiving the preparation request, each participating node sets the corresponding bit on the lock identifier bitmap maintained for each field in memory according to the specific field of the transaction operation, locking only the field actually modified and not the entire record. The atomicity of the bitmap operation ensures the concurrency safety of lock acquisition. Then, the participating nodes generate a local transaction log containing redo logs and rollback logs. The redo log records the new value after modification for application during commit, and the rollback log records the old value before modification for recovery during rollback. The local transaction log is written to the memory buffer and a ready response message is returned to the coordinator. This step adopts a field-level locking mechanism to significantly reduce the probability of lock conflicts when different transactions operate on different attributes of the same bill of materials node. The purpose is to improve the concurrent processing capability while ensuring the atomicity of the transaction.

[0052] The specific implementation of step S3 is as follows: The distributed transaction coordinator collects the response status messages returned by each participating node, counts the number of nodes returning positive responses using a counter, and compares this number with half of the total number of participating nodes to determine whether the majority condition is met. If the number of nodes returning positive responses is greater than 50% of the total number of nodes, the majority requirement is met and the transaction can proceed to the transaction commit phase; otherwise, a lease timeout detection mechanism is initiated. The current timestamp is compared with the lease expiration timestamp to determine whether the lease is still valid. If the lease has expired or the majority requirement has not been met, the transaction rollback process is triggered. The rollback process sends rollback instructions to all ready participating nodes. After receiving the rollback instructions, the participating nodes use the undo log in their local transaction log to restore the data to the state before the transaction started, and then release the acquired field-level locks and clear the transaction log in the memory buffer. This step ensures the consistency of distributed transaction decisions based on the majority arbitration protocol, with the aim of making correct commit or rollback decisions even in the event of network instability or node failure.

[0053] The specific implementation of step S4 is as follows: For distributed transactions that meet the commit conditions, the coordinator performs batch aggregation processing of the transaction logs to be committed according to a time window. The default time window is set to 5 milliseconds. During the window period, redo logs and rollback logs of multiple transactions are collected. When the number of transactions accumulated in the window reaches the threshold reference value of 32 or the window timer expires, a batch write operation is triggered. All collected log entries are merged into a single continuous group commit log block. This log block is organized in memory as a sequential storage structure to optimize the subsequent sequential write performance. Then, the group commit log block is directly copied to the persistent memory area of ​​the remote node by bypassing the operating system kernel through remote direct memory access technology. The hardware offloading capability of the network interface card is used to avoid the data copying and context switching overhead in traditional network transmission, reducing the log copying latency to the microsecond level. This step uses group commit technology to transform multiple random disk write operations into a single sequential write operation, reducing the number of disk input / output operations to one-tenth of the original, with the aim of significantly improving the throughput of transaction log persistence and reducing latency.

[0054] The specific implementation of step S5 involves establishing a closure table storage model for the tree structure of the bill of materials. This model records all ancestor-descendant node pairs in the tree through a flattened relation table. Each record in the closure table includes a current node identifier field, an ancestor node identifier field, a level depth field, and a materialized path string field. The level depth represents the number of edges traversed from the ancestor node to the current node. The materialized path string uses a sequence of node identifiers from the root node to the current node, separated by slashes. When an insertion operation occurs in the bill of materials tree, the system calculates the relation pairs from the new node to all ancestor nodes and inserts them into the closure table in batches. When a modification operation occurs in the bill of materials tree, the system updates the materialized path string of the affected node and cascades the path values ​​of all descendant nodes. When querying all descendant nodes of a certain node, only a single range scan operation needs to be performed in the closure table to filter all records where the ancestor node identifier is equal to the target node, avoiding the overhead of multiple database round trips caused by recursive queries. This step uses a space-for-time strategy to reduce the complexity of recursive queries in the tree structure from logarithmic to constant level, aiming to significantly improve the query performance of the bill of materials tree structure, especially in deep tree structure scenarios.

[0055] The specific implementation of step S6 involves using a transaction state drift detection model to monitor the distributed transaction execution process in real time. The input layer of this model receives the normalized feature vectors of the response latency sequence and log write rate sequence of each participating node. The normalization process uses a zero-mean unit variance standardization method to scale the features to the same order of magnitude. The first convolutional layer uses a one-dimensional convolutional kernel to slide along the temporal dimension to extract local temporal features and introduces nonlinearity by modifying the linear unit activation function. The kernel size is referenced to be 3 to 5. The pooling layer performs max pooling or average pooling operations on the convolutional output to downsample and reduce the feature dimension. The second convolutional layer further extracts higher-order abstract features from the pooling results. The connection layer maps convolutional features to a drift level probability distribution space. The output layer generates probability values ​​for four categories—mild drift, moderate drift, severe drift, and normal state—through a normalized exponential function. The drift level output by the model is used to dynamically adjust system parameters. When mild drift is detected, the field-level lock granularity parameter is fine-tuned by 5% to 10%. When moderate drift is detected, the group commit window duration is adjusted from 5 milliseconds to 3 milliseconds to reduce latency. When severe drift is detected, an alarm is triggered and an emergency response mechanism is activated. This step uses the temporal feature extraction capability of deep learning to achieve adaptive monitoring of transaction execution status. The purpose is to dynamically optimize performance parameters according to the system's operating status to cope with load changes and abnormal situations.

[0056] The specific implementation of step S7 is as follows: When the system detects a network partition failure, the lease management module determines whether each node set holds a majority lease. Node sets holding a majority lease continue to process transaction requests and maintain write permissions because they meet the majority condition. Node sets not holding leases automatically switch to read-only mode and stop accepting write transaction requests. Nodes in read-only mode route all read requests to their local replicas and record a version vector after each read operation. The version vector is a logical clock array maintained by each node, recording the operation counts of itself and other nodes. Local operations are marked by incrementing the vector component corresponding to the node. This mechanism uses majority leases to ensure that only one partition has write permissions during the network partition, thereby avoiding data inconsistency. The version vector recorded by the read-only node is used for conflict detection during subsequent partition recovery. This step achieves a trade-off between availability and consistency in the network partition scenario based on the combination of majority arbitration and version vectors, with the aim of maximizing system availability while ensuring data consistency.

[0057] The specific implementation of step S8 is as follows: After network partition recovery, the coordinator extracts the version vectors of records from each node and executes a conflict detection algorithm. For any two version vectors, a component-by-component comparison is used to determine whether a partial order relationship exists. If all components of one vector are not greater than the corresponding components of the other vector, there is no conflict in the order. If the two vectors neither satisfy the partial order relationship nor are equal, it indicates that there is a concurrent operation conflict. For the bill of materials data items where a write-write conflict is detected, a compensation transaction long transaction processing mode is started, which breaks down the conflict resolution process into multiple short transaction sub-steps. Each sub-step generates a corresponding compensation operation to roll back the executed modifications. The compensation operations include operations with opposite semantics, such as reversing field values, deleting records added during partitioning, or restoring deleted records. The compensation operation sequence is executed according to the dependency relationship until the data is restored to a consistent state. This step uses the causal relationship tracking capability of version vectors to detect concurrent conflicts during partitioning and uses the compensation transaction mode to achieve eventual consistency instead of direct rollback. The purpose is to efficiently merge the data modifications of each partition and resolve conflicts after network partition recovery.

[0058] It should be noted that the key technical ideas of this invention include fine-grained concurrency control based on field-level locking, high-performance log persistence based on group commit and remote direct memory access, and adaptive monitoring of transaction status based on deep learning. Compared to traditional row-level locking, the field-level locking mechanism refines the lock granularity to the individual field level, locking only the fields actually modified by the transaction instead of locking the entire row, significantly reducing the probability of lock conflicts when different transactions operate on different attributes of the same bill of materials node, thus improving the system's concurrent processing capabilities. The group commit technology, combined with remote direct memory access, aggregates the logs of multiple transactions within a time window into a single contiguous block and writes it directly to remote persistent memory. Compared to the traditional per-transaction log writing method, this significantly reduces the number of random disk writes and network transmission overhead, reducing log persistence latency from milliseconds to microseconds. The deep learning-based drift detection model extracts the temporal features of node response latency and log write rate through convolutional neural networks. Compared to traditional monitoring methods based on fixed thresholds, it can adaptively identify changes in system operating status and dynamically adjust key parameters such as lock granularity and group commit window, improving the system's adaptability to load fluctuations and abnormal situations. These three technical approaches work together to form a complete optimization chain from concurrency control to log persistence and parameter adaptation. The concurrency improved by field-level locking is efficiently persisted through group commit technology, while the drift detection model dynamically balances concurrency and consistency overhead based on real-time status. Compared with existing distributed transaction processing methods, this significantly improves throughput and reduces latency while ensuring strong consistency.

[0059] It should be noted that this invention also solves the following technical problem: the technical problem of lock contention leading to decreased concurrency performance during distributed transaction processing. Traditional row-level locking mechanisms still generate lock contention when different transactions operate on different attributes of the same BOM node. This invention refines the lock granularity to a single field in the data table through field-level locking, locking only the fields actually modified by the transaction instead of locking the entire row. An independent lock flag bitmap is maintained for each field in memory, significantly reducing the probability of lock contention and improving transaction concurrency. Simultaneously, this invention also solves the technical problem of log synchronization and replication latency affecting transaction throughput. Through group commit technology, the logs of multiple transactions within a time window are merged into a single contiguous storage block, transforming multiple random disk write operations into a single sequential write operation, reducing disk I / O operations. Combined with RDMA transfer technology, it bypasses the operating system kernel to directly read and write remote persistent memory areas, reducing log replication latency to the microsecond level and significantly improving transaction processing throughput.

[0060] Specifically, the principle of this invention is as follows: The majority arbitration mechanism ensures that even in the event of a network partition, only one partition containing more than half of the nodes holds write permissions, avoiding data inconsistency caused by split-brain. The lease management module assigns time-limited exclusive write permission credentials to nodes holding majority votes to prevent permanent lock occupation. Field-level locking refines the lock granularity to a single field, reducing the probability of conflicts when different transactions operate on different attributes of the same BOM node. Group commit technology merges multiple transaction logs into a single contiguous storage block, reducing disk I / O operations through batch flushing. RDMA transmission bypasses the operating system kernel to directly access remote memory, reducing log replication latency to the microsecond level. The transaction state drift detection model extracts temporal features of latency and rate through convolutional layers. The factor graph structure models the correlation between nodes, enabling the model to simultaneously consider the temporal features of a single node and the spatial dependencies of multiple nodes. Version vector tracking detects concurrent conflicts by tracking causal relationships, and the compensatory transaction mode restores data consistency by executing semantically opposite operation sequences instead of direct rollback.

[0061] The following provides a specific embodiment 1 of the present invention, and the specific implementation of each step in this embodiment 1 is described in detail below.

[0062] The specific implementation of step S1 involves deploying a distributed transaction coordinator on each data center node of the product lifecycle management system. This coordinator establishes a lease management module based on a majority arbitration mechanism. The lease management module records the set of nodes currently holding leases and the lease expiration timestamps. The majority arbitration mechanism requires a certain number of nodes to receive a positive response. Meet the conditions In the formula To confirm the number of responding nodes, The total number of system nodes and the lease duration. The calculation formula is expressed as follows:

[0063] In the formula, The lease term is in milliseconds. This represents the 95th percentile of network round-trip time, in milliseconds. The standard deviation of round-trip time, in milliseconds; This is the time delay coefficient, a dimensionless parameter, with an empirical value of 2.5; The fluctuation coefficient is a dimensionless parameter with an empirical value of 1.8.

[0064] The specific implementation of step S2 is as follows: when a bill of materials data modification transaction is initiated, the distributed transaction coordinator sends a transaction preparation request to all participating nodes. Each participating node performs field-level lock acquisition on the relevant bill of materials data items and generates a local transaction log. The field-level lock is implemented by maintaining an independent lock identifier bitmap for each field in memory, locking only the fields actually modified by the transaction rather than locking the entire record.

[0065] The specific implementation of step S3 involves collecting the response status of each participating node and counting the number of nodes that have obtained a majority vote. If the majority condition is met, the transaction commit phase is entered; otherwise, a lease timeout detection is performed and a transaction rollback process is triggered. The lease timeout detection criterion is the current timestamp. With lease start timestamp The difference exceeds the lease term ,Right now Timeout is triggered when, in the formula This is the current timestamp, in milliseconds. This is the lease start timestamp, in milliseconds.

[0066] The specific implementation of step S4 is to batch aggregate the transaction logs to be committed according to the time window to form group commit log blocks, and copy the group commit log blocks to the persistent memory area of ​​the remote node through remote direct memory access transmission. The default time window is 5 milliseconds. When the number of transactions accumulated within the window reaches the threshold or the window times out, batch writing is triggered. This technology reduces the number of disk input / output operations to one-tenth of the original. Remote direct memory access transmission allows a node to bypass the operating system kernel and directly read and write the memory area of ​​another node.

[0067] The specific implementation of step S5 is to establish a closure table to store ancestor-descendant relationships in the bill of materials tree structure. Each record in the closure table stores the node identifier, ancestor node identifier, level depth, and materialized path string. The materialized path string uses the slash-separated sequence of node identifiers to represent the complete path from the root node to the current node. To query all descendants of a node, it is only necessary to perform a single range scan of all records in the table whose ancestor column is equal to the target node.

[0068] The specific implementation of step S6 is as follows: a transaction state drift detection model is used to monitor the node response latency distribution and log write rate distribution during the execution of distributed transactions. The field-level lock granularity parameter and group commit window duration parameter are adjusted according to the drift level. The input layer of the model receives the feature vectors of the node response latency sequence and the log write rate sequence after normalization. The first convolutional layer uses a one-dimensional convolutional kernel to extract temporal local features and modifies the linear unit activation function. The pooling layer downsamples the convolution output to reduce the feature dimension. The second convolutional layer further extracts higher-order features. The fully connected layer maps the features to the drift level probability distribution. The output layer generates probability values ​​for four categories: mild drift, moderate drift, severe drift, and normal state through a soft maximization function. The model uses a factor graph structure to model the correlation between nodes as edge connections in the graph. The marginal probability of the drift state is transmitted between graph nodes through a belief propagation algorithm.

[0069] The specific implementation of step S7 is as follows: when a network partition failure is detected, the set of nodes holding a majority of leases continues to process transaction requests, while the set of nodes not holding leases enters read-only mode and records a version vector. Represented as In the formula For nodes version vector, For nodes Recorded nodes The operation count is a dimensionless integer value. This represents the total number of nodes in the system.

[0070] The specific implementation of step S8 is as follows: After network partition recovery, extract the version vector of each node for conflict detection; for bill of materials data items with write-write conflicts, use the compensated transaction master transaction processing mode to generate a reverse operation sequence and perform data merging; and then... (The sentence is incomplete and ends abruptly.) and The conflict determination condition is that there is no conflict. And it does not exist. and The partial order relation Defined as for all satisfy In the formula version vector Middle node The operation count is a dimensionless integer value. version vector Middle node The operation count is a dimensionless integer value. Compensation operations include operations with opposite meanings, such as reversing value modification, deleting newly added records, or restoring deleted records.

[0071] Temperature parameters of the attention mechanism in the transaction state drift detection model The calculation formula is expressed as follows:

[0072]

[0073] In the formula, This is a temperature parameter, a dimensionless value. This is a comprehensive adaptive value, a dimensionless value; The normalized concurrency level is a dimensionless value, calculated as follows: ,in For transaction concurrency, Design an upper limit for concurrency in the system; The normalized partition frequency is a dimensionless value, calculated as follows: ,in This refers to the frequency of network partitioning, measured in times per hour. This is the historical average frequency, measured in times per hour. The normalized depth is a dimensionless value, calculated as follows: ,in The average depth of the bill of materials tree, a dimensionless integer value. Dimensionless integer values ​​are used to design the maximum depth.

[0074] Energy mean deviation in convolutional layer drift detection The calculation formula is expressed as follows:

[0075] In the formula, This represents the mean deviation of energy, a dimensionless value. The current average energy of the output feature map for each channel is a dimensionless value, calculated as follows: ,in For the feature map, the first Each element is a dimensionless normalized value. The total number of elements; The historical energy mean of the output feature map for each channel is a dimensionless value, maintained by an exponential moving average method. The calculation formula is as follows: ,in For the first Historical average energy of the batch, dimensionless value. For the first Historical average energy of the batch, dimensionless value. For the first The current average energy of the batch, dimensionless. The smoothing coefficient is a dimensionless parameter with an empirical value of 0.9. The cosine similarity of the weight update direction. The calculation formula is expressed as follows:

[0076] In the formula, The cosine similarity is a dimensionless value. The current update vector is calculated as follows: ,in This is the current weight vector. This is the previous weight vector; The historical update vector is calculated as follows: ,in The weight vector of the previous two orders of magnitude; Operators for Euclidean norms; Represents vector dot product operation. Sparsification threshold in sparse convolution kernel replacement. The calculation formula is expressed as follows:

[0077] In the formula, The sparsity threshold, This is the weight matrix of the convolutional layer. Represents the set of absolute values ​​of weights. This indicates that the 70th percentile function is calculated, and connections with absolute weights less than this threshold are set to zero, while the top 30% of connections with the largest absolute weights are retained.

[0078] To better understand and implement this invention, the following is a specific application scenario of this invention, Example 2: To verify the effectiveness of this invention, technicians built a test environment and conducted practical tests by deploying a distributed transaction processing architecture in the PLM system of a large equipment manufacturing enterprise. This enterprise's PLM system manages over 150,000 BOM nodes distributed across five data center nodes. Each data center node is configured with a 64-core processor, 512GB of memory, and 256GB of Intel Optane persistent memory. During the test, high-concurrency transaction scenarios were simulated, with an average transaction concurrency of 320 and an average BOM tree depth of 8 levels, reaching a maximum depth of 13 levels.

[0079] The technicians first deployed a distributed transaction coordinator on each data center node and established a lease management module based on a majority arbitration mechanism. The lease duration is dynamically calculated based on the 95th percentile of the network round-trip time. In the test environment, the 95th percentile of the network round-trip time was measured to be 2.8ms, so the lease duration was set to 15ms. The system records the set of nodes currently holding leases as Node 1, Node 2, and Node 3, with a lease expiration timestamp of 1704124815000.

[0080] When a BOM data modification transaction is initiated, the distributed transaction coordinator sends a transaction preparation request to all five participating nodes. In the test scenario, an assembly BOM node of a complex product was selected for modification. This node contains 12 fields, including part number, quantity, material, and supplier. Each participating node performs field-level locking on the relevant BOM data items, locking only the actual modified fields, quantity and supplier, while keeping the other 10 fields accessible. Figure 2 As shown, the field-level locking mechanism allows multiple transactions to concurrently operate on different fields of the same BOM node at the same time, reducing the lock contention probability from 68% in traditional row-level locking to 19%. Each participating node generates a local transaction log, and the log entries include the transaction identifier, operation type, value before modification, and value after modification.

[0081] The system collects the response status of each participating node. Nodes 1, 2, 3, and 4 return a ready response within 1.2ms, while node 5, due to network fluctuations, returns a response after 4.5ms. The number of nodes receiving a majority vote is 4, satisfying the majority condition of more than half the nodes (3 nodes), thus entering the transaction commit phase. Distributed transaction execution logs were recorded for 30 days during the test, and the extracted node response latency data is shown in Table 1.

[0082] Table 1 Statistical data on response delay of each node

[0083] The system batch aggregates the transaction logs to be committed according to a time window set to 5ms. Within this window, redo and undo logs for 23 transactions are accumulated, forming a group commit log block. This log block is 1.8MB in size and is copied to the persistent memory area of ​​the remote node via RDMA. The measured RDMA transfer latency is 8.7μs, a reduction of two orders of magnitude compared to the 2.3ms latency of traditional TCP network transmission. The write latency to persistent memory is 420ns, a significant improvement compared to the 45μs latency of traditional SSDs. Figure 3 As shown, group commit technology reduces disk I / O operations from 1200 per second to 110 per second.

[0084] A closure table is built to store ancestor-descendant relationships in the BOM tree structure. The BOM tree of a product in the test scenario contains 237 nodes. Each record in the closure table stores the node identifier, ancestor node identifier, hierarchy depth, and materialized path string. For example, the materialized path string for node N45 is " / N1 / N12 / N28 / N45", representing the complete path from root node N1 through N12 and N28 to N45. Querying all descendant nodes of node N12 requires only a single range scan of all records in the closure table whose ancestor column equals N12, taking 0.8ms. In contrast, a traditional recursive query requires 5 database round trips, taking 12.3ms.

[0085] The system employs a transaction state drift detection model to monitor the distributed transaction execution process. The model's input layer receives node response latency sequences and log write rate sequences, resulting in a normalized feature vector with a dimension of 128. The first convolutional layer uses a 5-dimensional one-dimensional convolutional kernel with 32 kernels to extract temporal local features and activates them using the ReLU function. The pooling layer uses max pooling with a pooling window size of 2 to downsample the convolutional output. The second convolutional layer has 64 kernels to further extract higher-order features. The fully connected layer contains 256 neurons, mapping features to a drift level probability distribution. The output layer uses the Softmax function to generate probability values ​​for four categories: mild drift, moderate drift, severe drift, and normal state. Figure 4 As shown, the model achieved an accuracy of 94.7% on the test set, which is 12.4 percentage points higher than the 82.3% accuracy of the independent classification model.

[0086] During the training dataset creation process, technicians recorded 30 days of distributed transaction execution logs, extracting 48,620 samples. After manual annotation, normal state samples accounted for 67%, slightly drifted samples for 18%, moderately drifted samples for 11%, and severely drifted samples for 4%. To enhance model robustness, 3,200 slightly drifted samples were generated by adding Gaussian noise with a standard deviation of 0.3 to the latency sequence of normal state samples; 2,100 moderately drifted samples were generated by scaling the write rate to 0.6 times the original and introducing periodic fluctuations with a period of 50ms and an amplitude of 15% of the original value; and 1,500 severely drifted samples were generated by simultaneously applying latency spikes with a peak value three times the average value and a rate drop to 0.3 times the original value. The samples were divided into a training set of 34,034 samples, a validation set of 9,720 samples, and a test set of 4,866 samples in a 7:2:1 ratio.

[0087] During model training, the convolutional layer weights were initialized using Xavier distribution sampling values, with an initial learning rate of 0.001. The Adam optimizer was used, and the batch size was 32. During training, forward propagation calculated the cross-entropy loss between the output drift level probability distribution and the true label. A regularization term based on the factor graph structure was added to the loss function, with a regularization coefficient set to 0.05. Backpropagation calculated the gradient and updated the model parameters. Accuracy was evaluated on the validation set every 10 epochs. If the validation set accuracy did not improve for 5 consecutive epochs, the learning rate was reduced to 0.1 times its original value. At the 127th epoch, the validation set accuracy converged to 95.2%, and these model parameters were selected as the final model.

[0088] The strategy for adjusting field-level lock granularity parameters and group commit window duration parameters based on drift level is shown in Table 2.

[0089]

[0090] Table 2. Parameter Adjustment Strategies Corresponding to Drift Levels During the test, a network partition failure was simulated, and node 5's network connection with other nodes was interrupted. At this time, the node set consisting of nodes 1, 2, 3, and 4 held a majority lease and continued processing transaction requests. Node 5 entered read-only mode and recorded a version vector [23, 45, 67, 89, 34], representing the operation counts observed by that node. The network partition lasted for 8 minutes before recovery, and the system extracted the version vectors of each node for conflict detection. Node 5's version vector was [23, 45, 67, 89, 34], and node 1's version vector was [35, 52, 73, 95, 34]. Comparison revealed that node 1 performed 12 additional operations during the partition. Figure 5 As shown, the conflict detection algorithm identified three BOM data items with write-write conflicts, generated a reverse operation sequence using the compensated transaction SAGA mode, and performed data merging, which took 1.2 seconds.

[0091] The temperature parameter of the attention mechanism is dynamically adjusted based on the current system state. During testing, the transaction concurrency was 320, the system design concurrency limit was 500, and the normalized concurrency was 0.64. The network partitioning frequency was 0.8 times per hour, the historical average frequency was 0.5 times per hour, and the normalized partitioning frequency was 1.6. The average depth of the BOM tree was 8 levels, the designed maximum depth was 15 levels, and the normalized depth was 0.53. The sum of the three normalized values ​​multiplied by weight coefficients of 0.5, 0.3, and 0.2 respectively yielded a comprehensive fitness value of 0.894, which is greater than or equal to 0.7. Therefore, the temperature parameter was set to 2.0 to smooth the attention distribution and improve the model's robustness.

[0092] Drift detection was periodically performed on the convolutional layers of the transaction state drift detection model, and the mean energy deviation of the output feature maps for each channel was calculated. The current mean energy of the output feature map of the 32nd channel was 12.45, the historical mean energy was 11.87, and the mean energy deviation was 0.58. The cosine similarity of the weight update direction was 0.93, and the drift level of the convolutional layer was determined to be moderate. The technicians replaced the convolutional kernels with sparse convolutions, retained the 30% of connections with the largest absolute weights, froze all layers except the convolutional layer, and fine-tuned the convolutional layer using a fine-tuning learning rate of 0.0001. The activation map output by the convolutional layer was compressed from 64 channels to 32 channels, and the compressed activation map was used as the input for the next layer. After fine-tuning the convolutional layer again and performing lightweight recovery training for 8 epochs, the mean energy deviation decreased to 0.15, the cosine similarity decreased to 0.85, and the drift level recovered to mild.

[0093] This invention represents a significant advancement over traditional distributed transaction processing methods. Traditional methods employ row-level locking, which can still lead to lock contention when multiple transactions concurrently access different fields of the same BOM node. In contrast, this invention's field-level locking mechanism only locks the fields actually modified, fundamentally eliminating lock contention between different fields and enabling truly parallel execution of concurrent transactions. Traditional methods write each transaction log to disk separately, generating numerous random I / O operations. This invention's group commit technology aggregates multiple transaction logs into contiguous storage blocks, fundamentally transforming random writes into sequential writes and fully utilizing the sequential access performance of the disk. Traditional methods use TCP network transmission of logs, requiring multiple data copies and context switches within the operating system kernel. This invention uses RDMA technology to bypass the kernel and directly access remote memory, fundamentally eliminating the software overhead of network transmission. Traditional methods employ recursive algorithms for BOM tree queries, requiring multiple database round trips. This invention's closure table stores all ancestor-descendant relationships in a flattened manner, fundamentally transforming recursive queries into a single range scan. Traditional methods monitor the transaction status of each node independently, failing to detect abnormal relationships between nodes. In contrast, the factor graph structure of this invention explicitly models the correlation between nodes and transmits drift state information between nodes through a belief propagation algorithm, thus achieving globally consistent anomaly detection in principle.

[0094] It should be noted that the variables involved in this invention are explained in detail in Table 3.

[0095]

[0096] Table 3. Variable Explanation Table The above description is merely a specific embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any changes or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in the present invention should be included within the scope of protection of the present invention.

Claims

1. A distributed transaction processing method for BOM data in a PLM system, characterized in that, In the PLM system, a distributed transaction coordinator is deployed on each data center node, and a lease management module is established based on the majority arbitration mechanism to record the set of nodes holding leases and the lease expiration timestamp. When a BOM data modification transaction is initiated, a transaction preparation request is sent to all participating nodes, and field-level locks are acquired to generate local transaction logs. The response status of each participating node is collected to obtain the number of nodes with a majority vote to determine whether to enter the transaction commit phase or execute the rollback process. The transaction logs to be committed are batch-aggregated according to time windows to form group commit log blocks, which are then copied to the persistent memory area of ​​remote nodes via RDMA. A closure table is established for the BOM tree structure to store ancestor-descendant relationships. A transaction state drift detection model is used to monitor the node response latency distribution and log write rate distribution during the execution of distributed transactions, and the field-level lock granularity parameters and group commit window duration parameters are adjusted according to the drift level. When a network partition failure is detected, the set of nodes holding a majority of leases continues to process transaction requests, while the set of nodes without leases enters read-only mode and records version vectors. After the network partition is recovered, the version vectors of each node are extracted for conflict detection, and BOM data items with write-write conflicts are generated in the SAGA mode of compensating transactions to generate a reverse operation sequence and perform data merging.

2. The method according to claim 1, characterized in that, The majority arbitration mechanism refers to a voting protocol in a distributed system that requires more than half of the nodes to reach a consensus on a transaction before it can be submitted. The criterion for this is that the number of nodes receiving positive responses is greater than half of the total number of nodes.

3. The method according to claim 2, characterized in that, The lease management module is used to allocate time-limited exclusive write permission credentials to nodes holding majority votes. The lease includes a start timestamp, validity period, and a list of authorized nodes. The lease duration is dynamically calculated based on the statistical quantile of network round-trip latency.

4. The method according to claim 3, characterized in that, The field-level lock refers to a locking mechanism that refines traditional row-level locks to the granularity of individual fields in a data table. It locks only the fields that are actually modified by the transaction, rather than locking the entire row record. This is achieved by maintaining an independent lock flag bitmap for each field in memory.

5. The method according to claim 4, characterized in that, The group commit log block merges the redo and undo logs of multiple transactions within a time window into a single contiguous storage block. The default value of the time window is 5 milliseconds. Batch writing is triggered when the number of transactions accumulated within the window reaches a threshold or the window times out.

6. The method according to claim 5, characterized in that, The RDMA transmission refers to Remote Direct Memory Access technology, which allows one node to bypass the operating system kernel and directly read and write the memory area of ​​another node. The log replication latency is reduced to the microsecond level. It needs to be supported at the network interface card level and implemented through the verbs interface programming.

7. The method according to claim 6, characterized in that, The persistent memory region refers to a storage region constructed using non-volatile memory media, which combines access speed close to DRAM with persistent characteristics that prevent data loss after power failure. The persistent memory is exposed to the application through a memory-mapped file interface.

8. The method according to claim 7, characterized in that, The closure table is a flattened relational table used to store all ancestor-descendant pairs in a tree structure. Each record in the table contains a pair of nodes with an ancestor relationship and their hierarchical interval. To query all descendants of a node, a single range scan is required of all records in the table whose ancestor column is equal to the target node.

9. The method according to claim 8, characterized in that, Each record in the closure table stores the node identifier, ancestor node identifier, level depth, and materialized path string. The materialized path string refers to the complete path from the root node to the current node recorded in each node of the BOM tree. The path is represented by a sequence of forward slashes separating the node identifiers.

10. The method according to claim 9, characterized in that, The version vector is a logical clock mechanism used in a distributed system to track causal relationships and detect conflicts. Each node maintains a vector to record the operation counts of itself and other nodes. The order of operations or concurrent conflicts are determined by comparing the size relationship of the components of two version vectors.

Images