Abstract:
A serverless distributed file system manages the storage of files and directories using one or more directory groups. The directories may be managed using Byzantine-fault-tolerant groups, whereas files are managed without using Byzantine-fault-tolerant groups. Additionally, the file system may employ a hierarchical namespace to store files. Furthermore, the directory group may employ a plurality of locks to control access to objects (e.g., files and directories) in each directory.
Abstract:
Techniques are provided for responding to the termination of a node executing one or more transactions by selecting another node to complete the transactions, and assigning to the selected node the affinity relationships that existed between the terminated node and the objects being accessed by said transactions.
Abstract:
A serverless distributed file system manages the storage of files and directories using one or more directory groups. The directories may be managed using Byzantine-fault-tolerant groups, whereas files are managed without using Byzantine-fault-tolerant groups. Additionally, the file system may employ a hierarchical namespace to store files. Furthermore, the directory group may employ a plurality of locks to control access to objects (e.g., files and directories) in each directory.
Abstract:
A method and apparatus is presented for controlling spin lock instrumentation for a spin lock in a system with a cache. A lock flag represents a busy state for the spin lock; a first instrumentation flag is a global variable representing an enablement state for the spin lock instrumentation. A second instrumentation flag, stored within the same cache line as the lock flag, is also maintained as an updateable indication of the first instrumentation flag. Prior to each acquirement of the spin lock, the second instrumentation flag is checked for an indication that spin lock instrumentation is enabled. Although a reading of the lock flag may generate a cache miss, the lock flag is necessarily checked upon attempting to acquire the lock; the check of the second instrumentation flag cannot generate a superfluous cache miss because the second instrumentation flag is in the same cache line as the lock flag.
Abstract:
A serverless distributed file system manages the storage of files and directories using one or more directory groups. The directories may be managed using Byzantine-fault-tolerant groups, whereas files are managed without using Byzantine-fault-tolerant groups. Additionally, the file system may employ a hierarchical namespace to store files. Furthermore, the directory group may employ a plurality of locks to control access to objects (e.g., files and directories) in each directory.
Abstract:
An apparatus and method, using an inter-processor lock to control access to inter-process relationship data structures in the memory of each processor in a multiprocessor system. The apparatus and method insure that each inter-process relationship is modified in the same sequence on each processor. The apparatus and method also insure that an inter-process relationship is maintained in a consistent state in the face of failure of any of the processors.
Abstract:
A data management system, which is equipped with a data file and a journal file and adapted to reserve the exclusive occupation for data and then update the data, is characterized by releasing the exclusive occupation of data prior to writing of a journal to the journal file and of corresponding updated data to the data file. When data on a data base is updated, the exclusive occupation states of data to be updated are reserved first and then updating of the data is executed on a data buffer placed on a main memory and journals on the updating of the data are collected. The collected journals are entered into a first-in first-out journal queue in units of transactions. The exclusive occupation states of data on a corresponding transaction is released after corresponding journals have been stored in the journal queue. The journals stored in the journal queue are written to the journal file in units of transactions in the order in which they are entered into the queue. Subsequently updated data is written to the data file. The data in the data file is restored using the journal file when a system failure occurs in the data base.
Abstract:
Apparatus and method for reading data pages in a transaction processing system without locking the pages are disclosed. The system maintains a Global.sub.-- Committed.sub.-- LSN identifying the oldest uncommitted transaction accessing any of the data, and Object.sub.-- Committed.sub.-- LSNs identifying the oldest uncommitted transactions accessing particular files, tables and indexes. Each data page includes a Page.sub.-- LSN identifying the last transaction to have updated the page. To read a page, a transaction first latches the pages, and compares the page's Page.sub.-- LSN with the Global.sub.-- Committed.sub.-- LSN, or with the page's respective Object.sub.-- Committed.sub.-- LSN. If the Page.sub.-- LSN is older than the Committed.sub.-- LSN with which it was compared, then the transaction reads the page without locking it, since there can be no uncommitted transaction in process which might have updated the page's data. However if the Page.sub.-- LSN is younger than the Committed.sub.-- LSN, the page is locked before being read.
Abstract:
A memory system for use in a text entry system is provided. The system includes a retentive data memory and a system for locking a portion of the retentive memory and a key for unlocking the lockable portion of the memory to allow a predetermined number of bits of data to be written to the memory when the lockable memory is in unlocked state. The system automatically locks the memory after the predetermined number of bits have been written into the lockable portion of memory.
Abstract:
Techniques are provided for synchronous replication based cutover. An asynchronous replication process is executed to perform asynchronous incremental transfers of data of a storage object from a first computing environment to a replicated storage object at a second computing environment until a cutover criteria is met. A synchronous replication process is executed to synchronously replicate operations, targeting the storage object, to the replicated storage object based upon the cutover criteria being met. A cutover is performed to direct operations from targeting the storage object to targeting the replicated storage object based upon the synchronous replication process reaching a steady state of synchronous replication for sub-objects of the storage object, where operations are committed to both the storage object and the replicated storage object.