33 results about "Commit" patented technology

The application relates to a transaction submission control method and system. The method comprises the following steps: based on a transaction request sent by a client being received, freezing a write set of a transaction corresponding to the transaction request; writing a transaction log record of the transaction request into a prewrite log, including all modification records in the transaction corresponding to the transaction request and a submission mark record; performing a persistence operation on the prewrite log by a persistence module, and returning a persistence completion information and a corresponding log location LSN to a submission point control module after a preset persistence condition is met, the persistence module and the submission point control module being isolated from each other; marking the transaction corresponding to the transaction request as reaching a persistent submission point by the submission point control module, and writing the mark into the prewrite log to form a recoverable submission point record; and returning a transaction submission success response to the client only after the mark representing the persistent submission point is written into the prewrite log. The normalization of transaction submission semantics is realized.

This invention relates to the field of vector instruction processing technology, specifically to a method and apparatus for processing vector memory access instructions. It includes an instruction issuance step, an address authentication step, whereby if all elements pass authentication, the vector processor sends a commit permission instruction to the scalar pipeline; if any element fails authentication, address authentication is immediately stopped, the location information of the failed element is recorded in an exception location register, and an exception signal is sent to the scalar pipeline, followed by a vector execution step. This invention avoids the blocking problem caused by vector memory access instructions occupying the pipeline for a long time, significantly improves the utilization rate of the scalar pipeline, effectively hides authentication latency, and allows for rapid instruction commit after all elements pass authentication, with the remaining elements then executed without obstruction. Overall memory access latency is significantly reduced, authentication throughput is improved, and the release speed of the scalar pipeline is accelerated.

The application discloses a kind of distributed reservation systems and methods for multi-resource cooperation, comprising: transaction manager, at least two resource managers, lock manager, transaction log module and workflow controller;Transaction manager coordinates each resource manager through two-phase commit 2PC protocol, realizes the atomicity execution of cross-node shadow and summary table update;Lock manager adopts read-write lock separation mechanism to resolve concurrent conflict, and handles deadlock problem through timeout detection and active unlocking strategy;Transaction log module is based on prewrite log mechanism Complete record shadow and summary table linkage operation details, provide reliable support for fault recovery and transaction rollback;Workflow controller encapsulates distributed call details, realizes service survival real-time detection and automatic reconnection function.The application has high expansibility, strong consistency, high concurrent adaptation capability and perfect exception fault-tolerant mechanism, and can be widely applied to travel service scene of multi-node deployment.

Systems and methods enforce non-bypassable, fail-closed permit-before-commit control of external-effect requests at an effect boundary between an execution substrate and one or more external interfaces. An interceptor captures each request, deterministically canonicalizes it, computes an action digest, and obtains a machine-verifiable permit receipt bound to a policy digest and epoch identifier with a time-bounded validity. Prior to commitment, the interceptor verifies receipt authenticity, authorization by digest match and / or cryptographic commitment verification, epoch-compatibility, and revocation status using signed revocation data and / or transparency-log proofs subject to policy-defined recency, including in intermittently connected environments, and may enforce scope and permit-provenance constraints. If required verification evidence is missing, stale, conflicting, or indeterminate, the external effect is denied. Optional embodiments use trusted execution boundaries, capability tokens for dual enforcement, and machine-verifiable decision, audit, and denial receipts.

The application discloses a kind of blockchain-based smart contract asynchronous execution method, system, equipment and medium, mainly related to smart contract asynchronous execution technical field, to solve the problem of slow efficiency of existing smart contract execution. It includes: generating Pre-Prepare message, sending to all nodes;When any node receives external Pre-Prepare message, the legality verification and correctness verification of external Pre-Prepare message are carried out, to be cached to local after the verification result is legal and correct, and Prepare message is sent to all nodes;When any node receives external Prepare message, the legality verification of external Prepare message is carried out, to obtain the verification result after verification is legal, to send Commit message to all nodes after the verification result meets preset rule;After any node is verified legal and correct, the Pre-Prepare message corresponding to external Prepare message in local cache is read, and the block data in the corresponding Pre-Prepare message is put into the waiting execution queue.

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.

Embodiments of the present application provide a consistent data writing method and system, electronic equipment and storage medium, which are applied to a connector of a data source or a connector of a destination. The connector of the data source is used to write data from the data source to Kafka, and the connector of the destination is used to write data from Kafka to the destination. First, it is determined whether the connector has transaction capability. If the connector has transaction capability, the data writing operation and the offset writing operation are submitted as a same transaction through the connector, so that it is determined that the transaction is successfully executed after the data writing operation and the offset writing operation are both completed. If the connector does not have transaction capability, it is determined that the data writing is completed after the data writing operation and the offset writing operation are both executed through the connector by using a two-phase commit protocol. By determining whether the connector has transaction capability and taking different measures, the consistency of data before and after data writing is ensured.

A method for a transactional commit in a storage unit is provided. The method includes receiving a logical record from a storage node into a transaction engine of a storage unit of the storage node and writing the logical record into a data structure of the transaction engine. The method includes writing, to a command queue of the transaction engine, an indication to perform an atomic update using the logical record and transferring each portion of the logical record from the data structure of the transaction engine to non-persistent memory of the storage unit as a committed transaction. A storage unit for a storage system is also provided.

The application discloses a kind of distributed database two-stage transaction submission method and device based on RDMA, it is related to distributed database high-performance transaction processing technical field, comprising: in pre-commitment stage, data jump is completed using RDMA unilateral writing operation;Through polling, transaction redo log data is written successfully;In the submission stage, the atomic update submission state flag bit is carried out through the RDMA atomic comparison and exchange operation;When the number of successful times reaches the majority threshold value through polling RDMA completion queue, exit waiting loop and execute consensus achievement processing. It can eliminate the multiple network round trip and software processing delay in traditional protocol, so that the end-to-end transaction delay is reduced from the software protocol level to the hardware network level, the system CPU resources are released so that it does not need to participate in the protocol processing, so that the computing resources can be efficiently utilized, and the overall throughput and concurrent processing capacity of the distributed cluster are significantly improved.

This invention relates to the field of software development technology, specifically to a software compilation method, system, device, and storage medium based on Jenkins. The method includes: pre-setting a manifest file describing the project structure and building a base build image encapsulating a complete compilation environment; pulling the full code of each project to a physical server; triggering an automated compilation task when a commit event occurs in the code repository; the task updating the manifest file according to the commit information and generating an updated manifest file with a sequence number; performing incremental pulls on the physical server for the changed projects based on the updated manifest file; synchronizing the code to a container environment started by the base build image via a local Git HTTP server; and finally performing automated compilation within the container. This invention can significantly improve the compilation efficiency of large projects, completely eliminate environmental differences, and enhance the stability and reliability of the automated process.

Methods and systems are described for detecting and reporting a vulnerability fix in a code repository. A commit obtained from the code repository is preprocessed to generate file-level token sequences each representing a file-level code change for respective files. Respective file-level code change embedding vectors are generated by inputting each file-level token sequence into a transformer model, each file-level code change embedding vector being a vector representation of the file-level code change for the respective file. The file-level code change embedding vectors are combined into a commit-level code change embedding vector that represents all code changes contained in the commit. A predicted commit-level vulnerability fix score is generated by inputting the commit-level code change embedding vector into a classifier. A vulnerability fix report is outputted, containing an identification of the commit and the predicted commit-level vulnerability fix score.

The Java-based memory transaction management method disclosed by the embodiment of the application comprises the following steps: enabling a Java class data structure to be a Diff class; obtaining a transaction context instance of a Diff object through a unique identifier rootID of the Diff object; executing a start method of the transaction context to start a transaction; executing original business logic to modify memory data of the Diff object; after the execution of the business logic, if the business logic is normal, executing a commit method of the transaction context to submit the transaction, and ending the transaction; if the business logic has an exception, executing a rollback method of the transaction context to roll back the transaction, restoring modified data content of the Diff object, and ending the transaction. The Java-based memory transaction management method realizes memory level transaction processing of Java objects and object attributes, supports complex class data structure and multi-layer transaction nested execution, and provides a method with application potential for transaction management based on memory data.

This invention relates to an optimization method for high-speed memory read and write operations. The method involves dividing the memory address space into multiple address units according to a preset address granularity; receiving write and read requests for each address unit; when an address unit receives a write request, if no corresponding write record to be committed exists in the local commit area, the write record to be committed is created and the write data is recorded; if the address unit has the write record to be committed and is not interrupted by the read request, the latest write data in the write record to be committed is updated for subsequent write requests, so that multiple writes to the address unit are merged into a final write result before physical commit; when the read request hits the write record to be committed, the write record to be committed outputs the read result; when the commit condition is met, the final write result corresponding to the write record to be committed is written to physical memory, and the write record to be committed is released.

A database system includes a commit layer implemented using a first set of host computing devices and a storage layer implemented using a second set of host computing devices. A control plane of the distributed database system determines a first sharding scheme for the commit layer and a second sharding scheme for the storage layer, wherein the first and second sharding schemes are not required to be the same. Also, in some embodiments, the second sharding scheme used for the storage layer enables overlapping key spaces across the shards of the storage layer, wherein various ones of the shards are optimized for different types of workloads.

This invention discloses a secure access method for network interface card (NIC) firmware based on dynamic instruction mapping and transactional buffering. During session initialization, the driver and application construct an instruction opcode mapping table and data structure offset rules valid only for the current session based on a negotiated random seed, achieving dynamic obfuscation of communication protocol features. When processing write requests, the driver temporarily stores the data, reads the current hardware snapshot, performs semantic-level virtual assembly and logical conflict prediction, and intercepts dangerous operations with valid signatures but mutually exclusive configuration logic. Only after pre-verification passes and a commit instruction is received does the driver calculate the differential bitstream between the shadow buffer and the hardware data, lock the bus, and perform atomic incremental synchronization. This invention effectively resists reverse engineering and replay attacks through three mechanisms: dynamic protocol transformation, logical conflict immunity, and differential atomic commit, while also preventing firmware corruption caused by configuration errors or abnormal interruptions.

The application relates to the computer technology field and discloses a commit query method for querying related codes in a code warehouse, which comprises the following steps: traversing an initial version of the code warehouse, writing all code files into an incremental index and recording the commit ID of the latest submission; when the code warehouse version is updated, obtaining the commit ID of the latest submission after the version is updated, comparing the recorded commit ID of this submission with the recorded commit ID before the submission, obtaining the code files with addition, deletion and modification, and updating the code files into the incremental index; and finally, searching, querying and managing the code warehouse through the incremental index. The incremental index is used to record and manage the code files with addition, deletion or modification during the code warehouse version update, the version update related problems of the code warehouse can be effectively solved, the code files with modification during the version update can be better marked and queried, and the code files in the code warehouse of different versions during the version update can be managed.

This disclosure proposes a distributed transaction processing method, a distributed database system, and its computing nodes, relating to the field of computer science. The method includes: in response to a client's distributed transaction, obtaining a globally unique start timestamp; initiating the distributed transaction by sending the start timestamp as an identifier to multiple relational data storage nodes; during the write phase, based on the start timestamp, instructing the relational data storage nodes involved in the write operation to apply row locks in the row lock management table and write the data to be written to their local data storage table; during the pre-commit phase, obtaining a first commit timestamp, instructing all relational data storage nodes involved in the write operation to update their respective local data storage tables based on the first commit timestamp, pre-committing the distributed transaction; and during the commit phase, instructing all relational data storage nodes involved in the write operation to commit the distributed transaction, so that all write operations take global effect. This reduces the burden and complexity of computing nodes.

The embodiment of the present specification provides a data processing method and system, which is applied to a data processing method of a storage node, comprising: in response to a transaction preparation request sent by a computing node, determining a target branch transaction according to a transaction identifier carried by the transaction preparation request; executing the target branch transaction to modify target data, obtaining updated data, and updating the transaction state of the target branch transaction to a preparation state; determining and persistently storing the transaction timestamp of the target branch transaction, and returning a response success data packet to the computing node according to the transaction timestamp; in response to a transaction commit request sent by the computing node, updating the transaction state of the target branch transaction to a commit state, wherein the transaction commit request is asynchronously sent by the computing node in the case of receiving a response success data packet corresponding to the number of branch transactions; by omitting the step of persistently storing the transaction log, the RTT is saved, and the data processing efficiency is improved.

In some implementations, a server determines that project code in a development system references an older version of a component in a third-party library and that a newer version of the component has a fix commit that addresses a vulnerability in the older version. The system determines a subset of code changes associated with the fix commit that addresses the vulnerability. The system submits, via a network, a pull request to create a branch in a developer platform. In the branch: a patch is created based on the subset of the code changes associated with the fix commit, the patch is applied to the older version of the component to create a patched component, and after the patch is successfully validated in the branch, the patched component and information associated with the patch is uploaded to a registry to enable a software developer to download and use the patched component.

This invention provides a data storage method and system for distributed object storage. The method includes: encoding the original data of the target object using erasure coding to generate a group of shards to be written, containing k data shards and m check shards; writing each shard to independent physical extended shards on different storage nodes, wherein the extended shards are stored hierarchically using record blocks and check information blocks; generating a write success response when the number of successfully written shards reaches a preset threshold (≥k and ≤k+m); and performing a sealing operation on the extended shards after writing, using the minimum logical commit length of each successfully written shard as the trust boundary, truncating excess data and locking write permissions. This application solves the dilemma of existing systems where some shards cannot be securely confirmed after writing, eliminates node blocking, balances write efficiency and data consistency, and improves the availability, integrity, and efficiency of the storage system.

This application discloses a consistency verification method and related apparatus and storage medium for a distributed system. The method includes: constructing a business semantic topology of the distributed system; dynamically identifying key time points of a target distributed transaction based on the business semantic topology; wherein the key time points include the transaction preparation completion time point and the global commit completion time point; determining the critical state window of the target distributed transaction based on the key time points; injecting disturbances into some participating services of the target distributed transaction within the critical state window based on the business semantic topology; collecting the operating indicators of the distributed system in real time based on the business semantic topology; predicting whether the distributed system has an instability risk in real time based on the current operating indicators and historical operating indicators; if an instability risk exists, stopping the disturbance injection and performing state rollback or configuration recovery; and performing consistency verification of the target distributed transaction based on the state change results of the distributed system before and after the exercise.

The present disclosure relates to a method, a device and a program product for managing objects in a software development project. In one method, in response to receiving a commit request for committing a set of objects in a software development project, a set of historical commit requests associated with the set of objects is obtained based on a commit history of the software development project, a historical commit request in the set of historical commit requests relates to the set of objects. A candidate object is selected from at least one object different from the set of objects to which the historical commit request relates. An association between the candidate object and the set of objects is determined. In response to determining that the association satisfies a predetermined condition, the candidate object is identified as a missing object, the missing object representing an object associated with the commit request but not included in the commit request. A corresponding device and computer program product are provided. With exemplary implementations of the present disclosure, objects missing in a commit request can be automatically checked.

A computing system can execute a continuous integration (CI) pipeline for merging a code commit into a software project. The CI pipeline can include CI phases that can output sets of result data. Each CI phase can generate a respective set of result data among the sets of result data. The computing system can determine delay times associated with the sets of result data, each respective set of result data being assigned a corresponding delay time among the delay times. For each respective delay time, the computing system can prevent a set of users from accessing the respective set of result data prior to an expiration of the corresponding delay time. The computing system can also permit the set of users to access the respective set of result data following the expiration of the corresponding delay time.

The present application relates to the technical field of computers, and in particular relates to a multi-repository integration construction method and device, equipment and medium. The present application uses descriptors as configuration carriers to centrally manage integrated information originally scattered in repositories, scripts, CI configurations and documents, thereby reducing maintenance costs and hidden faults. Secondly, based on descriptors, version constraints and cross-repository constraints are solved to generate a lock file binding an analyzer and a descriptor version, convert complex rules such as multi-variant and cross-repository compatibility into a determined and reproducible commit record number, and solve the problem of incomplete multi-repository version combination expression. Then, the lock file is used to synchronize the code to ensure that the repository combination is completely consistent in any environment, thereby avoiding version drift and construction irreproducibility from the root. Finally, combined with the construction environment and standardized pipeline, the construction behavior is further ensured to be consistent, and multi-repository integration is stable, traceable and efficient.

The application discloses a visibility determination method and device, equipment and a storage medium, and relates to the technical field of databases. The method comprises the following steps: in response to a first visibility judgment event of a target transaction being triggered, obtaining a current cache value from transaction public cache data of a node, and obtaining a first cache commit sequence number snapshot, wherein the transaction public cache data comprises a global commit sequence number in a cached metadata node; determining a first target commit sequence number snapshot of the target transaction according to the first cache commit sequence number snapshot; performing initial judgment on the visibility according to the first target commit sequence number snapshot; and in the case that the initial judgment result is visible, determining that the visibility judgment result of the first visibility judgment event is visible. Through the above technical solution, the communication cost with the metadata node can be reduced, and the efficiency of the visibility determination and the transaction execution efficiency can be improved.

A database system includes a commit layer implemented using a first set of host computing devices and a storage layer implemented using a second set of host computing devices. A control plane of the distributed database system determines a first sharding scheme for the commit layer and a second sharding scheme for the storage layer, wherein the first and second sharding schemes are not required to be the same. Also, in some embodiments, the second sharding scheme used for the storage layer enables overlapping key spaces across the shards of the storage layer, wherein various ones of the shards are optimized for different types of workloads.

This invention discloses a distributed metadata ordered synchronization method based on inode semantics, belonging to the field of distributed file system technology. This method parses the semantic dependencies of inode metadata operations, constructs a directed acyclic graph of metadata operation dependencies, and groups operations with semantic dependencies into a serial synchronization queue, while operations without dependencies and belonging to different directory tree branches into a parallel synchronization queue. A queue-level lock is allocated to the serial synchronization queue, and ordered synchronization commits are executed through a distributed consensus algorithm. When a cluster anomaly causes synchronization interruption, the operation logs of the master and slave nodes are compared, and the metadata state is verified and repaired according to the dependency order. This invention can ensure the semantic consistency of metadata in a distributed cluster, reduce lock contention during synchronization, improve the concurrent processing capability of metadata operations, and reduce the difficulty of metadata repair in cluster anomaly scenarios.

A decentralized two-phase commit in a datastore or database includes determining pre-validating a transaction, writing first metadata to a leader partition, the first metadata including a state indicating preparing and mutations of the transaction, and writing second metadata of a follower partition to indicate the follower partition is locked by the leader partition. The decentralized two-phase commit further includes updating the state of the first metadata to indicate committed and performing the transaction on the leader partition, performing the transaction on the follower partition and unlocking the follower partition, and updating the first metadata to remove the mutations of the transaction and updating the state of the first metadata to indicate the transaction is completed. The decentralized two-phase commit may further include selecting a leader partition key and updating the state of the first metadata to indicate committed unapplied.

This invention discloses an atomic operation aggregation acceleration method based on RISC-V architecture. The method includes the following steps: extending the execution semantics of RISC-V atomic operation instructions to introduce an atomic operation aggregation execution mode; introducing an atomic operation aggregation coprocessor in the processor; when the processor core executes an atomic operation instruction using the aggregation execution mode, it sends an atomic operation request to the atomic operation aggregation coprocessor; the atomic operation aggregation coprocessor receives atomic operation requests from multiple concurrent execution contexts and associates the requests with the corresponding aggregators; the aggregator internally accumulates the operands of the atomic operations and maintains the state information of the current aggregation batch; when a preset aggregation batch commit condition is met, an aggregation commit operation is triggered, and an atomic write-back operation is performed on the target memory address; after the aggregation commit is completed, the state of the current aggregation batch is reset, and the next aggregation batch is initialized. The purpose of this invention is to address the problems of severe cache consistency contention, high memory access pressure, and increased energy consumption caused by multiple threads frequently performing atomic read-modify-write operations on the same memory address when multiple processor cores concurrently execute atomic operations. By introducing an atomic operation aggregation execution mechanism in the RISC-V architecture, the linearization point of atomic operations is moved forward to the atomic operation aggregation coprocessor, realizing the merging and batch submission of multiple atomic operation requests, thereby significantly reducing the number of atomic accesses to the target memory, improving system throughput performance, and reducing memory access power consumption.

This application relates to a method for processing a data region in a database performed by a computer device. The method includes: creating a second region in response to a split instruction for a first region in a database; suspending a second transaction in the first region from entering a commit phase or a read / write phase; transferring first transaction data of a first transaction from the first region to the second region, the first transaction data being data corresponding to the split second region in data of a first transaction; and in response to the first transaction data being transferred completely, resuming the first transaction in the first region to enter the read / write phase and / or the commit phase. This application can shorten transaction blocking time while ensuring execution efficiency of distributed transactions.