Systems, apparatuses and methods suitable for optimizing synchronization mechanisms for multi-core processors are provided. The synchronizing mechanisms may be optimized by receiving a command stream which comprises a plurality of commands including one or more wait commands, wherein each wait command has an associated state and one or more associated conditions; sequentially processing each command in the command stream until a wait command is reached; checking the state associated with the wait command to be processed, wherein if said state is a blocking state, further processing of commands in the command stream is paused until each of said wait command's associated conditions are met, and wherein if said state is a non-blocking state, the next command in the command stream is retrieved and processed.

Various embodiments of an apparatus, methods, systems and computer program products described herein are directed to detecting initiation of one or more shared libraries being loaded into a runtime memory of an application. While the one or more shared libraries are being loaded into the runtime memory, randomization code is placed into the runtime memory. For each respective shared library loaded into the runtime memory: randomization code allocates a new segment of runtime memory. The randomization code inserts a copy of the shared library into the new segment of runtime memory and overwrites a current segment of runtime memory at which the shared library is currently stored.

A method, comprising: receiving a request to acquire a lock that is associated with a resource; transitioning the lock into an acquired state in response to the request; and releasing the lock.

A method, computer program product, and computing system for defining a first flow for one or more processing threads with access to shared data within the storage system. The one or more processing threads may be executed using the first flow. A processing thread reference count may be determined for the one or more processing threads being executed using the first flow. One or more management threads may be executed on the shared data within the storage system based upon, at least in part, the processing thread reference count.

Throughput is preserved in a distributed system while maintaining concurrency by pushing a commit wait period to client commit paths and to future readers. As opposed to servers performing commit waits, the servers assign timestamps, which are used to ensure that causality is preserved. When a server executes a transaction that writes data to a distributed database, the server acquires a user-level lock, and assigns the transaction a timestamp equal to a current time plus an interval corresponding to bounds of uncertainty of clocks in the distributed system. After assigning the timestamp, the server releases the user-level lock. Any client devices, before performing a read of the written data, must wait until the assigned timestamp is in the past.

This application provides a data processing method and a related device, to keep data consistency between a management device and a forwarder in a multi-head management scenario. The method performed by a first management device in the plurality of management devices includes: sending a lock instruction to the forwarder; performing difference comparison between target data of the first management device and corresponding data that is on the forwarder and that corresponds to the target data to obtain a comparison result; and synchronizing the target data with the corresponding data if the first management device determines, by using the comparison result, that the target data and the corresponding data do not match, so that the target data matches the corresponding data.

Methods and systems for file locking are described herein. An on-premise file share may store files that are accessible to both a local on-premise client and a remote off-premise client. The off-premise file share may request to check-out one of the files. In response, one of multiple nodes may obtain for the file a file handle with exclusive write access. File locking information may be stored at the file share that indicates the node that holds the file handle and that indicates the file is in a locked state whereby other remote off-premise clients or local on-premise clients are prevented from editing the file.

Devices and techniques for programmable atomic operator resource locking are described herein. A request for a programmable atomic operator (PAO) can be received at a memory controller that includes a programmable atomic unit (PAU). Here, the request includes an identifier for the PAO and a memory address. The memory addressed is processed to identify a lock value. A verification can be performed to determine that the lock value indicates that there is no lock corresponding to the memory address. Then, the lock value is set to indicate that there is now a lock corresponding to the memory address and the PAO is invoked based on the identifier for the PAO. In response to completion of the PAO, the lock value is set to indicate that there is no longer a lock corresponding to the memory address.

Backup data equivalent to the maximum number of generations to be held can be secured even when backup data is locked. When locking of prohibiting overwrite of one or more storage areas is performed, a backup server prepares a new backup management table and uses the backup management table and an archive management table, which is the past backup management table, to store the backup data equivalent to the maximum number of generations to be held into a storage system.

A shard polling system fairly distributes stored items from producers to consumer processes and includes polling threads that poll for items from respective portions of a storage source, place the items in respective queues, and increment a global permit counter, restricted to a configurable maximum, that tracks the quantity of messages across the respective queues. The polling threads are restricted by respective shard permit counters that limit a quantity of items that may be moved from a storage source to a respective queue. A global thread applies a fairness technique, such as round robin, to fairly obtain the items from each of the respective queues and places the items in a global queue, decrementing the global permit counter, and incrementing the respective shard permit counter for each item obtained. Consumer threads poll the global queue (e.g., a blocking output queue) for the messages.