| Entries |
| Document | Title | Date |
|---|
| 20100070481 | SYSTEM AND METHOD FOR ALLOWING UPDATES TO DATABASE OBJECTS - A system and method for allowing flexible and simultaneous updates to database objects from one or more users is disclosed. The system may receive a change request to the object from the first user and then from a second user. The system may determine if the object is locked and, if so, informing the first user. If an edit request is received from the second user, the second user may be provided with multiple options, such as incorporating changes made by first user and overwriting changes made by second user with changes made by first user, incorporating changes made by first user and overwriting changes made by first user with changes made by second user, and cancelling changes made by second user. | 03-18-2010 |
| 20100076940 | METHOD FOR PROVIDING MAXIMAL CONCURRENCY IN A TREE STRUCTURE - Techniques for providing maximal concurrency while ensuring no deadlock in a tree structure are provided. The techniques include accessing a minimum number of one or more nodes to perform an operation. | 03-25-2010 |
| 20100106696 | FILE MANAGEMENT METHOD - The invention relates to a file management method that comprises a first step of organising the data file base that comprises creating a tree structure of directories with M levels of N directories each, M being an integer higher than 1, and the steps of storing data files including: applying a hash function on the identifier of a data file F | 04-29-2010 |
| 20100106697 | SYSTEM FOR ACCESSING SHARED DATA USING MULTIPLE APPLICATION SERVERS - A system including multiple application servers for accessing shared data and a centralized control unit for centrally controlling a lock applied to the shared data by each of the application servers. Each application server includes a distributed control unit for controlling a lock applied to the shared data by the application server and a selection unit for selecting any one of distributed mode in which a lock is acquired from the distributed control unit or a centralized mode in which a lock is acquired from the centralized control unit. | 04-29-2010 |
| 20100114848 | ATOMIC MULITPLE MODIFICATION OF DATA IN A DISTRIBUTED STORAGE SYSTEM - Atomic multiple modifications of streams is provided. Streams are selected for the application of an atomic multiple modification. A lock is acquired on the meta-data associated with the streams. Each stream is de-coupled from its name. Multiple modifications are applied to the selected streams. After performing the modifications, names are coupled to the streams. The lock on the meta-data associated with each stream is released. | 05-06-2010 |
| 20100114849 | Allocating Priorities to Prevent Deadlocks in a Storage System - One embodiment is a server in a cluster storage system. The server includes a Global Lock Manager (GLM) that receives requests for lock priorities for transactions from local lock manager (LLMs) in the cluster storage system. The GLM prevents deadlocks in the cluster storage system by issuing groups of priorities for transactions to the LLMs. | 05-06-2010 |
| 20100114850 | Event recording with local event record locking - Systems, methods, and other embodiments associated with event recording are described. One example method includes locally locking a record in an event data store corresponding to an event having a same event type as a given event when a prior occurrence of the given event has not yet been recorded. The event data store is updated to record the given event while the record is locked. One example system includes an event data store configured to store records corresponding to events, an event recorder configured to record event data in the event data store and a local lock actuable by the event recorder. The event recorder is configured to update the locked record to correspond to a received event. | 05-06-2010 |
| 20100153352 | DISCARDABLE FILES - The present application includes methods and system for managing a storage device. In one implementation, a storage allocator that is present in a host or a storage device receives a request to store a file in a storage area of the storage device. The storage allocator marks the file as discardable in a file system structure associated with the storage device and updates a primary file allocation table (“FAT”) to associate a cluster chain that is allocated to the file with the file. The storage allocator additionally updates a discardable FAT or a database to reflect a physical location of the file, or may generate one or more location files that store the physical location of the file. The storage allocator then manages the storage area device based on the FAT and a discardable FAT, database, or one more location files indicating the physical location of the file. | 06-17-2010 |
| 20100161571 | ULTIMATE LOCKING MECHANISM - A system and method for an ultimate locking mechanism which minimizes a lock period for modifying shared data in a shared database. A process is executed as one or more initial instances and a final instance. Each initial instance reads the shared data from the shared database without acquiring a lock on the shared database. The locking mechanism obtains results that are directed to modifying the shared data and buffers the results at least partially. During or after each of the initial instances, it determines whether the next instance is to be the final one (e.g., the estimated runtime of the next instance is acceptable as the lock period). In response to a positive determination, the final instance of the process is executed. The final instance uses at least one of the buffered results during execution and acquires the lock on the shared database to modify the shared data. | 06-24-2010 |
| 20100161572 | CONCURRENCY MANAGEMENT IN CLUSTER COMPUTING OF BUSINESS APPLICATIONS - A system and method for concurrency management in an environment, in which a common pool of objects is shared by multiple users. A virtual lock owner is created for a main thread of a processing task. The main thread spawns parallel threads to update the objects in the common pool with locks. The virtual lock owner is passed to each parallel thread. Each thread (including the main thread) is associated with a thread dependent lock indicator identified by the virtual lock owner. The lifetime of the thread dependent lock indicator is coupled with the lifetime of the associated thread. The virtual lock owner is also associated with a thread independent lock indicator that has a lifetime independent of the lifetime of the main thread. Thus, the parallel threads can perform object update with lock protection even if the main thread aborts. | 06-24-2010 |
| 20100161573 | Time Limited Lock Ownership - Described herein are techniques for time limited lock ownership. In one embodiment, in response to receiving a request for a lock on a shared resource, the lock is granted and a lock lease period associated with the lock is established. Then, in response to determining that the lock lease period has expired, one or more lock lease expiration procedures are performed. In many cases, the time limited lock ownership may prevent system hanging, timely detect system deadlocks, and/or improve overall performance of the database. | 06-24-2010 |
| 20100179946 | SYSTEM AND METHOD FOR HANDLING PARALLEL UPDATES OF OBJECTS REQUIRING TIME SENSITIVE ACKNOWLEDGEMENT - A system and method of updating persistent objects in a persistent store. In response to receipt of a confirmation of task competition, an attempt is made to acquire a lock for corresponding item data in the persistent store. Regardless of whether the lock is acquired, a successful update of the persistent store is acknowledged to the sender of the confirmation within a defined time period. | 07-15-2010 |
| 20100185597 | Method and Apparatus for Optimistic Locking Using SQL Select, Update, Delete, and Insert Statements - A method, computer program product and data processing system for optimistic locking. An integer column is added to a database table. A Structured Query Language statement is constructed and prepared to form a prepared Structured Query Language statement, wherein a result set of the prepared Structured Query Language statement includes the integer column. Any required parameter information is set in the prepared Structured Query Language statement. The prepared Structured Query Language statement is executed in a database transaction. A unique key associated with an element of the result set of the prepared Structured Query Language statement is determined. The row of the database table that the unique key is associated with is determined. A value in the integer column of the determined row is determined. The value in the integer column of the determined row is stored to form a stored value associated with the unique key, wherein the stored value ceases to exist when the database transaction ends. | 07-22-2010 |
| 20100191711 | Synchronizing Access To Resources In A Hybrid Computing Environment - Synchronizing access to resources in a hybrid computing environment that includes a host computer, a plurality of accelerators, the host computer and the accelerators adapted to one another for data communications by a system level message passing module, where synchronizing access to resources includes providing in a registry, to processes executing on the accelerators and the host computer, a key associated with a resource, the key having a value; attempting, by a process, to access the resource including determining whether a current value of the key represents an unlocked state for the resource; if the current value represents an unlocked state, attempting to lock access to the resource including setting the value to a unique identification of the process; determining whether the current value is the unique identification of the process; if the current value is the unique identification accessing the resource by the process. | 07-29-2010 |
| 20100191712 | COMMIT RATE MANAGEMENT WITH DECOUPLED COMMIT OPERATIONS - Consistency is managed among data operations by coalescing commit operations, adjusting a commit rate to optimize latency, and converging to fairness across servers. Write operations representing a change to data stored by one or more of a plurality of computing devices are received in succession by, for example, a cloud computing service. A state of a plurality of tracking objects is adjusted to indicate whether the change in data has been provided to the computing devices and whether the change in data has been acknowledged by the computing devices. Changes to the same data are coalesced such that only the most recent change is provided to the computing devices for storage. In some embodiments, the commit rate is adjustable such that the commit rate decreases quickly but increases slowly based on measured latencies. | 07-29-2010 |
| 20100191713 | UNBUNDLED STORAGE TRANSACTION SERVICES - Systems (and corresponding methods) that unbundle the kernel or storage engine of a database system are provided. The unbundling separates transactional aspects from storage aspects. The two components of the storage engine resulting from the unbundling are a transaction component (TC) and a data component (DC). Data storage access methods are implemented in the DC without the added complexity of dealing with transactions, which are handled separately in the TC. The interface supported by the DC is a logical interface, e.g., record oriented, in which the way that records are mapped to disk pages (or flash memory blocks, etc.) need not be exposed. The TC then deals with logical locking and logging, meaning that it need know nothing about the way pages are used in the DC. | 07-29-2010 |
| 20100198800 | ALLOCATION LOCKS AND THEIR USE - Systems and methodologies are provided that employ an allocation lock, which permits only a single transaction to acquire space on a particular page at any one time. The allocation lock of the present invention facilitates operations of concurrent transactions at a subpage level (e.g., a row level), and in conjunction with a heap manager can enforce a set of conditions such that prior to a commit stage of a transaction, a space availability for a particular page can be typically assured (e.g., that transactions operating on various copies of the page do not consume all of storage space on that page), and reorganization of data around the page is mitigated (e.g., that a transaction need not move data around the page for purpose of merging various copies.) | 08-05-2010 |
| 20100205164 | Maintaining Data Integrity - Data integrity is maintained in an environment in which multiple instances of a software component each can include multiple processes capable of accessing a shared resource. Each instance of the software component can be either an “active” instance (which is allowed to update data) or a “standby” instance (which is not allowed to update data). At any point in time, the environment does not comprise more than one active instance. There can, however, be more than one standby instance. Preferably, a single standby instance can become a new active instance in the event of a complete failure of the active instance, i.e. a failure associated with every process of the current active instance. | 08-12-2010 |
| 20100223242 | File Operations with Multiple Level File Locking Techniques - File systems which provide several different and improved locking capabilities. An application on a client workstation communicates through a client driver to a server which interfaces with a metadata database, which contains locking information about the files. Applications perform as normal. The client driver provides lock and unlock requests to the server when a write lock or a read with intent to write lock is required. If only a read lock is considered appropriate, the client driver does not provide a lock request. The server transparently performs read operations and read locking using the metadata database without specific requests from the client driver. When a read with intent to write or write lock is required, the lock ownership is placed with a given expiration time. When the time expires the lock is not automatically released but remains with the particular requesting client driver until another client driver requests it. | 09-02-2010 |
| 20100250507 | ENUMERATION OF A CONCURRENT DATA STRUCTURE - An enumerable concurrent data structure referred to as a concurrent bag is provided. The concurrent bag is accessible by concurrent threads and includes a set of local lists configured as a linked list and a dictionary. The dictionary includes an entry for each local list that identifies the thread that created the local list and the location of the local list. Each local list includes a set of data elements configured as a linked list. A global lock on the concurrent bag and local locks on each local list allow operations that involve enumeration to be performed on the concurrent bag. | 09-30-2010 |
| 20100250508 | SYSTEMS AND METHODS FOR DATA MIGRATION IN A CLUSTERED FILE SYSTEM - Systems and methods for providing more efficient handling of I/O requests for clustered file system data subject to data migration or the like. For instance, exemplary systems can more quickly determine if certain files on primary storage represent actual file data or stub data for recalling file data from secondary storage. Certain embodiments utilize a driver cache on each cluster node to maintain a record of recently accessed files that represent regular files (as opposed to stubs). A dual-locking process, using both strict locking and relaxed locking, maintains consistency between driver caches on different nodes and the data of the underlying clustered file system, while providing improved access to the data by the different nodes. Moreover, a signaling process can be used, such as with zero-length files, for alerting drivers on different nodes that data migration is to be performed and/or that the driver caches should be flushed. | 09-30-2010 |
| 20100262590 | MULTI-COMPUTER DISTRIBUTED PROCESSING WITH REPLICATED LOCAL MEMORY EXCLUSIVE READ AND WRITE AND NETWORK VALUE UPDATE PROPAGATION - A modified computer architecture enables an applications program to be run simultaneously on a plurality of computers (M | 10-14-2010 |
| 20100281007 | Cross-Channel Coauthoring Consistency - A computing device includes a processing unit, and a memory with instructions that, when executed by the processing unit, cause the processing unit to create: a document processing module that processes the creation and editing of document content; and a metadata processing module that generates, monitors and stores metadata for a document on the computing device, the metadata processing module generating lock creation metadata that include information about a new lock that is created when a user begins to edit a portion of a document, lock removal metadata that includes information about removing a lock, and lock deletion metadata that includes information about deleting a lock, the metadata processing module writing lock creation metadata to both a data channel and to a separate metadata channel, the metadata processing module writing lock removal metadata to the data channel and the metadata processing module writing lock deletion metadata to the metadata channel. | 11-04-2010 |
| 20100293154 | MANAGING LONG-LIVED RESOURCE LOCKS IN A MULTI-SYSTEM MAIL INFRASTRUCTURE - Embodiments of the present invention address deficiencies of the art in respect to managing resource locks and provide method, system and computer program product for managing long-lived resource locks. In a first embodiment, a data processing system for managing long-lived resource locks can include one or more work items disposed in a database of work items, each of the work items including a lock time and a lock flag. The system also can include one or more worker tasks in a work system enabled to access the work items and to assert locks on the work items. Notably, the system can include a stale lock detection task in an administration system enabled to detect and release stale locks in the work items. Finally, the system can include a lock assertion task in the work system enabled to maintain locks on the work items on behalf of corresponding ones of the worker tasks utilizing the work items. | 11-18-2010 |
| 20100306181 | METHOD AND APPARATUS FOR ROLLING BACK STATE CHANGES IN DISTRIBUTED TRANSACTIONS - During a distributed transaction, a computing device that hosts a participant of the distributed transaction intercepts an operation to change a resource from an initial state to a resultant state. The computing device determines an inverse operation that will change the resource from the resultant state back to the initial state. The computing device records the inverse operation and performs the operation. | 12-02-2010 |
| 20100312759 | THROTTLING TO REDUCE SYNCHRONIZATIONS OF EXCESSIVELY CHANGING DATA - Embodiments of the invention determine if a user preference or other piece of data is being synchronized too frequently. If the user preference is being synchronized too frequently, synchronization of the user preference is throttled to prevent it from synchronizing for some number of synchronization cycles. If the user preference rarely changes, the user preference is rewarded by throttling it less often. | 12-09-2010 |
| 20100318504 | METHOD AND SYSTEM FOR ROBUST FUTEXES - An embodiment relates to a method of managing primitives. The method includes providing a data structure available in user-space where the data structure comprises at least one futex. The method also includes detecting a termination of the process and searching the data structure for status of the at least one futex. The method further includes releasing the at least one futex in response to status of the at least one futex being held and setting a flag for at least one futex. The method further includes notifying at least one process waiting for the released at least one futex. | 12-16-2010 |
| 20100325098 | ELIDING SYNCHRONIZATION IN A CONCURRENT DATA STRUCTURE - A concurrent data structure allows synchronization to be elided for read accesses. Processing resources that remove one or more elements of the concurrent data structure are allowed to delete the elements only after all other processing resources have reached a safe point. Each processing resource maintains an indicator that indicates whether the processing resource has reached as safe point (i.e., will not access the concurrent data structure). When the indicators indicate that all processing resources have reached a safe point, elements of the data structure may be deleted. | 12-23-2010 |
| 20100332463 | SURROGATE KEY GENERATION AND UTILIZATION - The subject disclosure pertains to databases as well as generation and utilization of keys. A desired or default number of values can be requested from a domain and allocated for use. These values can be utilized to generate surrogate keys. Subsequently or concurrently, the keys can be employed with respect to operations such as single pass loading of databases and/or data warehouses. Any unused keys can be returned and made available for use by other users or processes. Furthermore, the key generation functionality can be provided outside a database thereby relieving a database system of this burden. | 12-30-2010 |
| 20110022576 | Processing Substantial Amounts of Data Using a Database - Among other disclosed subject matter, a computer-implemented method for handling large amounts of data is to be initiated. The method includes receiving, using an application program executed from local memory of a computer system, portions of information from a first file. The method includes generating a database table in a peripheral storage device. The method includes storing the portions of information in the database table of the peripheral storage device. The method includes locking the database table, wherein the locking exclusively provides the application program a database accessing technique to the database table. The method includes processing by the application program the portions of information in the database table using the database accessing technique. The method includes clearing the database table upon a termination of the application program. The method includes, unlocking the database table upon the termination of the application program. | 01-27-2011 |
| 20110035365 | Distributed Knowledge Storage - According to one embodiment, a method for writing to a distributed knowledge store includes receiving a plurality of Resource Description Framework (RDF) expressions. A distributed knowledge store is identified. The distributed knowledge store contains a plurality of physical knowledge stores. The RDF expressions are written to the distributed knowledge store by storing the plurality of RDF expressions in a buffer and then receiving a plurality of threads from the plurality of physical knowledge stores. The plurality of threads are responsible for downloading the plurality of RDF expressions to the plurality of physical knowledge stores. | 02-10-2011 |
| 20110040738 | PARALLEL NESTED TRANSACTIONS IN TRANSACTIONAL MEMORY - Various technologies and techniques are disclosed for supporting parallel nested transactions in a transactional memory system. Releasing a duplicate write lock for rollback is supported. During rollback processing of a parallel nested transaction, a write log entry is encountered that represents a write lock. If the write lock is a duplicate, a global lock is used to synchronize access to a global versioned write lock map. Optimistic read validation is supported. During validation, if a versioned write lock indicates a sibling conflict, consult information to determine if a parallel nested transaction should be doomed. Write lock acquisition is supported. Upon attempting to acquire a write lock for a parallel nested transaction, a transactional memory word is analyzed to determine if the write lock can be obtained. If the transactional memory word indicates a versioned write lock, retrieve a write log entry pointer from a global versioned write lock map. | 02-17-2011 |
| 20110055182 | FILE SYSTEM - In response to a request to a file system to perform a requested update, a lock of a first node in a file system can be acquired, and an update of the first node can be performed while the lock of the first node is held. Also in response to the request, a lock of a second node can be acquired, and an update of the second node, which reflects the update of the first node, can be performed while the lock of the second node is held. The update of the first node can be independent of acquiring the lock of the second node. A file system can allow a pair of update operations to be performed in parallel where both operations include updating the same container node. Additionally, while a file system is running, new namespace types can be defined, and the file system can be extended to manage nodes within the new namespace types. | 03-03-2011 |
| 20110055183 | High Performance Real-Time Read-Copy Update - A technique for reducing reader overhead when referencing a shared data element while facilitating realtime-safe detection of a grace period for deferring destruction of the shared data element. The grace period is determined by a condition in which all readers that are capable of referencing the shared data element have reached a quiescent state subsequent to a request for a quiescent state. Common case local quiescent state tracking may be performed using only local per-reader state information for all readers that have not blocked while in a read-side critical section in which the data element is referenced. Uncommon case non-local quiescent state tracking may be performed using non-local multi-reader state information for all readers that have blocked while in their read-side critical section. The common case local quiescent state tracking requires less processing overhead than the uncommon case non-local quiescent state tracking. | 03-03-2011 |
| 20110055184 | FILE SYSTEM - For each of one or more existing nodes in a file system, pending notifications of updates that have been performed on the node can be identified and sent to one or more other nodes. The file system can be opened for use, and one or more other nodes can be updated in response to the pending notifications while the file system is open for use. For example, this may be done in an operation for recovering from a crash of the file system. Also, a process for dealing with stale data in container nodes in a file system can include processing access requests according to a stale data scheme. | 03-03-2011 |
| 20110066604 | METHOD AND AN ARRANGEMENT FOR CONCURRENCY CONTROL OF TEMPORAL DATA - The method is for granting access to data of a first object that has at least one temporally access controlled public attribute and a clock capable of measuring time independently of the clocks of other objects. A request to access a value of the public attribute of the first object is received. The value of the clock of the first object is compared with the value of the clock of at least one second object. If necessary, the clock values of the first and the second objects are synchronized. Access to the value of the attribute of the first object is granted. Also an arrangement and a computer program product are disclosed. | 03-17-2011 |
| 20110071993 | METHOD AND SYSTEM FOR EFFICIENT ENFORCEMENT OF DERIVED LOCKS IN A HIERARCHICAL STRUCTURE - An improved approach is described for handling locks and locking for hierarchical structures. The approach efficiently captures lock information for hierarchical nodes as well as for the enforcement of derived locks. Support is provided for locking of leaf nodes as well as for locking of intermediate nodes. | 03-24-2011 |
| 20110078126 | METHOD, SYSTEM, AND PROGRAM FOR LOCK AND TRANSACTION MANAGEMENT - Disclosed is a method, system, and program for lock management. Under control of a lock manager, lock request queuing is performed, heartbeat functions are performed, and state information is maintained. | 03-31-2011 |
| 20110087642 | Memory-Mapped Objects - A method and apparatus for efficiently managing cached objects is provided. A mapping is a typed relationship between cached objects. A base object contains content, and a mapped object is mapped to a base object when there is a particular relationship between the mapped object and the base object. The type of mapping defines how the objects in the relationship are treated when the mapped object is created, read, or written. At creation time, the mapping type may define how the mapping relationship is recognized. Sometimes recognizing a relationship requires establishing equivalence between the objects. At read and write time, the mapping type may define on which object a mutual exclusion lock is held, which content is returned or which object's content is updated. A wide range of applications can benefit from enhanced object caching performance, and in addition, application may define application-specific semantics on mapping types as well. | 04-14-2011 |
| 20110106777 | SYSTEM AND METHOD FOR AUTOMATION OF CONSISTENT LOCK MANAGEMENT - A system and method for automation of consistent lock management, wherein a shared resource is accessed through an accessor object. An accessor object class includes at least one const read access function and one write access function. A const accessor object is received for read-only access of a shared resource. The compiler is enlisted to enforce lock selection. | 05-05-2011 |
| 20110106778 | LOCK MANAGER ON DISK - A method and apparatus for managing shared resources in a clustered database management system is provided. In an embodiment, multiple master nodes exist in a database management system. A master node receives a lock request from a second node. The lock request is a request for a lock on a shared resource. The master node grants the lock request to the second node. While the second node holds the lock, the second node causes the master node to modify the shared resource. | 05-05-2011 |
| 20110131192 | Approaches to Reducing Lock Communications In a Shared Disk Database - Lock communications in a shared disk database system is reduced by several approaches: sending a single message to a lock manager for locks required for an operation and locks that will be required in the future, the operations may include row update, row delete, large scan, and row insert; performing an operation in two executions, where in a first execution locks required for the operation is determined without performing the operation, and in a second execution a single message is sent to a lock manager for the required locks and the operation is performed; in free space searching, sending a single message to a lock manager for row and page locks before a row insert is actually performed; and granting locks in an unfair manner. | 06-02-2011 |
| 20110131193 | On Demand Locking of Retained Resources in a Distributed Shared Disk Cluster Environment - Systems, methods, computer program product embodiments are provided for locking retained resources of database information in a distributed shared disk cluster environment. An embodiment includes providing a request on demand for physical access to a page by a task of a node among a cluster of nodes, managing selective bypassing of waiting access requests to the page at intranode and internode levels in response to the request on demand, and handling requests for page ownership to prioritize a request on demand. Further included are determining whether another node holds a lock on the page and identifying an access type for the waiting access requests in order to coordinate transfer of the lock to the node. | 06-02-2011 |
| 20110137879 | DISTRIBUTED LOCK ADMINISTRATION - Apparatus, systems, and methods may operate to grant a renewable lease synchronization lock to a node for a file having copies distributed among a group of nodes that is unsynchronized and for which no write lock has already been granted. The synchronization lock disables modification of the file, and enables synchronization of a file copy on the requesting node to a synchronization master copy on another node in the group. A renewable lease write lock can be granted to a node in the group when the file is synchronized and when the write lock has not already been granted. The write lock disables granting the synchronization lock, and enables file modification. The synchronization lock and write lock are maintained until their respective leases expire. Additional apparatus, systems, and methods are disclosed. | 06-09-2011 |
| 20110184924 | STORING TEMPORARY STATE DATA IN SEPARATE CONTAINERS - A temporary state service protocol is utilized by clients to temporarily store and access data within rows of a database between different requests made by end users. Each client creates and manages one or more items for storing data in rows of the database independently from other clients. An Application Programming Interface (API) is used to create and interact with the data that is temporarily stored in items within rows of the database. Different clients may share data within a single item and the data may persist beyond a session ending. Different rows of the database may be related such that a procedure affecting one of the rows affects its related rows. | 07-28-2011 |
| 20110246435 | SYSTEM, METHOD AND COMPUTER PROGRAM PRODUCT FOR MAINTAINING DATA STORED IN A DATA STRUCTURE - There are provided mechanisms and methods for maintaining data stored in a data structure. These mechanisms and methods for maintaining data stored in a data structure can provide maintenance operations with improved efficiency, functionality, etc. | 10-06-2011 |
| 20110276549 | OPTIMISTIC LOCKING IN A DISTRIBUTED FILE SYSTEM REPLICATION ENVIRONMENT - Described is optimistic locking in a distributed file system replication environment, in which a replica machine (e.g., a replicated file server) sends an optimistic lock to other replica machines when a file is opened for write access. Other replica machines that receive the optimistic lock prevent read-write opening of the file until the file is unlocked, thereby preventing many conflicts. Acknowledgements are not required by the locking replica. Of the reduced number of conflicts, many of those conflicts may be detected and thus handled before the file is closed, while conflicts detected after close may be handled via conventional conflict resolution techniques, e.g., last-writer wins. | 11-10-2011 |
| 20110282850 | Concurrently Accessing Data - A database management system having a database component, which includes a lock manager, and a filesystem component. The filesystem component is configured to: generate a mapping between one or more filesystem access modes, one or more filesystem sharing modes and one or more database locks, receive a request from a filesystem stack to perform one or more actions on data in a database, identify a filesystem access mode and a filesystem share mode of the request, determine which one of the database locks corresponds to the filesystem access mode and the filesystem share mode of the request based on the mapping, and receive a notification lock on the data from the lock manager when no other database locks conflict with the notification lock, wherein the notification lock corresponds to the one of the database locks. After receiving the notification lock on the data, the lock manager is configured to send a notification to the filesystem component when a subsequent request from a database stack includes accessing the data. | 11-17-2011 |
| 20110295822 | Methods to Perform Disk Writes in a Distributed Shared Disk System Needing Consistency Across Failures - Techniques are provided for managing caches in a system with multiple caches that may contain different copies of the same data item. Specifically, techniques are provided for coordinating the write-to-disk operations performed on such data items to ensure that older versions of the data item are not written over newer versions, and to reduce the amount of processing required to recover after a failure. Various approaches are provided in which a master is used to coordinate with the multiple caches to cause a data item to be written to persistent storage. Techniques are also provided for transferring data items and locks associated with the data items from one node to another. | 12-01-2011 |
| 20110302143 | MULTI-VERSION CONCURRENCY WITH ORDERED TIMESTAMPS - Multiple versions of a set of data objects can be maintained to allow concurrent conflicting access to the objects. Additionally, a range of acceptable timestamps for each transaction in a set of database transactions can be tracked. Conflicting access requests for an object in the set of objects can be detected, and the requests can be made by two or more conflicting transactions in the set of transactions. A range of acceptable timestamps for at least one of the conflicting transactions can be adjusted, such that an order of transaction timestamps can be maintained in accordance with a specified transaction isolation level. Such timestamp range adjustment can frequently permit conflicting read and write accesses to proceed concurrently. When concurrent access cannot be allowed while maintaining such an order of transaction timestamps, in many cases one of the conflicting accesses can be blocked instead of aborting one of the transactions. | 12-08-2011 |
| 20110313984 | SYSTEM AND METHOD FOR PARALLEL GRAPH SEARCHING UTILIZING PARALLEL EDGE PARTITIONING - A method and system for performing a graph search, includes constructing an abstract representation of the graph using state-space abstraction. The abstract representation of the graph includes one or more abstract nodes having duplicate detection scopes and one or more abstract edges having operator groups. The duplicate detection scopes of the abstract nodes are partitioned into smaller duplicate detection scopes using edge partitioning. The abstract edges include the smaller duplicate detection scopes. Nodes in the current search layer are expanded using the operator groups of outgoing abstract edges of the abstract nodes the nodes map to. The operator groups associated with abstract edges having disjoint duplicate detection scopes are used to expand the nodes in parallel. Once all the operator groups in the current search layer have been used for node expansion the method progresses to the next search layer. | 12-22-2011 |
| 20120005176 | CO-OPERATIVE LOCKING BETWEEN MULTIPLE INDEPENDENT OWNERS OF DATA SPACE - Locking allocated data space is disclosed. An indication is received that certain previous version data is required to be retained. A map of metadata records, each associated with a journaling process write of previous version data which write includes previous version data required to be retained, is built. In some embodiments, the map associates a write time with each record in the map. A reclamation process checks to determine whether any storage proposed to be reclaimed is included in the map of record identifiers. In some embodiments, the determination is made based at least in part on the write time associated in the map with at least a first record identifier in time-sorted order. | 01-05-2012 |
| 20120016854 | FILE-SHARING SYSTEM AND METHOD FOR MANAGING FILES, AND PROGRAM - A file, for which writing has been reserved, in a file-sharing system can be efficiently read. A check-in file agent is provided in a computer that executes check-in of a file as the file-write reserving processing, a file manager is provided in a file-sharing computer, and a check-out file agent is provided in a computer that executes check-out of a file as the file reading processing. Upon request for check-in of a file, the check-in file agent divides the file into divided files and generates metadata that indicates the order of division of the file, and transmits them to the file-sharing computer for storage therein. Upon request for check-out of the file, the check-out file agent receives the metadata from the file-sharing computer, and based on the metadata, sequentially receives the divided files to generate a file to be checked out. | 01-19-2012 |
| 20120016855 | INTERPROCESS COMMUNICATION USING A SINGLE SEMAPHORE - A method to enable communication between software processes includes initiating a plurality of processes, the processes including both attachment processes and target processes. A single semaphore is created and initialized for use by the plurality of processes such that each of the target processes wait on the semaphore. An attachment process writes a message file, identifying a specific target process, to a location accessible by the target processes. The attachment process then increments the semaphore by the number of target processes, thereby unblocking the target processes and allowing them to check the message file. When the specific target process determines that the message file is intended for that target, a connection is established between the attachment process and the specific target process. The attachment process then decrements the semaphore to zero to block the target processes. A corresponding computer program product and apparatus are also disclosed herein. | 01-19-2012 |
| 20120047118 | NETWORK DEVICE AND METHOD FOR UPDATING DATA OF THE NETWORK DEVICE - A network device and method for updating parameters of the network device provides an object adapting interface. The object adapting interface generates a service access interface and a configuration adapting interface. A management agent of the network device sends a requirement command. If the requirement command is a write command, the configuration adapting interface updates configuration parameters of the management agent stored in a configuration database of the network device. If the requirement command is a read command, the service access interface reads configuration parameters stored in the management agent. | 02-23-2012 |
| 20120059808 | ACCESSING DATA ENTITIES - Data entities in a client-server system are accessed. The client-server system comprises a set of clients, a server system, and a repository for storing a plurality of data entities. The server system comprises an inter-transactional cache, the inter-transactional cache being accessible for each client of the set of clients. A first client of the set of clients comprises a first intra-transactional cache. If a copy of a first data entity is in the inter-transactional cache, a version identifier of the original first data entity is read from the repository. If the copy of the first data entity is to be accessed with an exclusive lock, a copy of the copy of the first data entity is added to the first intra-transactional cache. The copy of the copy of the first data entity in the first intra-transactional cache is accessed for further processing of the first data entity by the first client. | 03-08-2012 |
| 20120066191 | OPTIMIZED CONCURRENT FILE INPUT/OUTPUT IN A CLUSTERED FILE SYSTEM - Embodiments include a method comprising transmitting from a node of a plurality of nodes within a clustered file system provides concurrent file I/O access for files, to write access a region of a file. The method includes receiving an authorization to write access the region without a lock to preclude access of the region by other nodes, if at least one physical section in a machine-readable medium has been allocated for storage of the region by the server. The method includes receiving the authorization to write access the region with the lock to preclude access of the region by the other nodes, if the at least one physical section in the machine-readable medium has not been allocated for storage of the region by the server. Responsive to receiving the authorization to write access, metadata is transmitted for storage into the at least one physical section in the machine-readable medium. | 03-15-2012 |
| 20120066192 | MAINTENANCE AND ACCESS OF A LINKED LIST - A method includes atomically reading a next field of a current element of the linked list to determine a first value that encodes a first pointer to the first element and a first indication of an owner of the first element. The first indication of the owner is stored in a first of a plurality of multi-field reservation data structures. The operation includes determining whether the next field of the current element still indicates the first value. The operation includes reading the first element of the linked list via the first pointer if the next field of the current element still indicates the first value. If the next field of the current element indicates a current value different than the first value, the first indication of the owner is removed from the first multi-field reservation data structure, and storing and determining with the second value is repeated. | 03-15-2012 |
| 20120066193 | Distributed Garbage Collection - Described are computer-based methods and apparatuses, including computer program products, for garbage collection. A garbage collection data structure is provided for deleting unused data objects. One or more object identifiers are stored in a first data structure in the garbage collection data structure. Each object identifier represents a data object about to be created but not yet assigned any references from other data objects. The first data structure prevents the data object from being deleted during creation of the data object but before one or more references are created to the data object. Data indicative of one or more objects is stored in a second data structure in the garbage collection data structure. The data includes one or more object identifiers, each object identifier representing a created data object. The data also includes one or more references to created data objects. | 03-15-2012 |
| 20120072400 | DIRECTORY OPLOCK - Current file systems may implement opportunistic locks on files that allow clients to locally cache file data, while promoting data consistency when multiple clients read/write the same file. Unfortunately, when a client locally caches directory content of a directory, the file system may lack a mechanism for notifying the client of changes to the directory that would render the cached directory content “stale”. Accordingly, one or more systems and/or techniques for managing a directory oplock are disclosed herein. A directory oplock may be generated based upon an oplock request comprising a first target key and a first parent key. Subsequent access requests for access to the directory or objects therein may be compared with the directory oplock to determine whether to break the directory oplock, and notify the client (e.g., directory oplock is broken if the client submitting the access request is different than the client owning the directory oplock). | 03-22-2012 |
| 20120078866 | Method For Managing Lock Resources in a Distributed Storage System - A method and a distributed locking system for the management of lock resources in a distributed files system having several lock managers, each managing lock resources in its respective domain. Each lock manager maintains a registry lock file that comprises of a list of all locked files and a list of lock requests. The registry lock files of all lock managers in the distributed locking system are saved in a central database. Furthermore, the system enables concurrent locking operations of different file sharing protocols on the same file system resources. | 03-29-2012 |
| 20120109920 | SYSTEMS AND METHODS PROVIDING A SOFT EXIT STATE FRO SECONDARY BUSINESS OBJECTS LOCKS - According to some embodiments, a primary business object BO | 05-03-2012 |
| 20120143838 | HIERARCHICAL SOFTWARE LOCKING - A processor chip may have a built-in hardware lock and deterministic exclusive locking of the hardware lock by execution units executing in parallel on the chip. A set of software locks may be maintained, where the execution units set and release the software locks only by first acquiring a lock of the hardware lock. A first execution unit sets a software lock after acquiring a lock of the hardware lock, and other execution units, even if exclusively locking the hardware lock, are unable to lock the software lock until after the first execution unit has reacquired a lock of the hardware lock and possibly released the software lock while exclusively locking the hardware lock. An execution unit may release a software lock after and while holding a lock of the hardware lock. The hardware lock is released when a software lock has been set or released. | 06-07-2012 |
| 20120158681 | VOLUMES AND FILE SYSTEM IN CLUSTER SHARED VOLUMES - The present invention extends to methods, systems, and computer program products for sharing volumes between clustered nodes. Embodiments of the invention include a Clustered Shared Volume File System (CsvFs) that appears to clients as a local file system. The CsvFs communicates to a node where a disk is mounted to coordinate access to files on the disks. CsvFs uses Opportunistic Locks (oplocks) to decide when direct access to a volume is safe. CsvFs can be extended with oplock upgrade mechanisms that allow a coordinating node to tell CsvFs when it is safe to attempt to upgrade oplock. CsvFs also uses a transitivity property of oplocks to be able to grant (delegate) oplocks to clients that are on top of CsvFs. | 06-21-2012 |
| 20120158682 | SCATTER-GATHER LIST USAGE FOR A CONFIGURATION DATABASE RETRIEVE AND RESTORE FUNCTION AND DATABASE BLOCKING AND CONFIGURATION CHANGES DURING A DATABASE RESTORE PROCESS - Disclosed is a method of reading and writing data to and from a transactional database using a scatter-gather routine that minimizes the time in which the database is subject to a transaction lock. Data is placed in a scatter-gather list in RAM, which speeds the process of reading and writing data to the database. Further, a process is disclosed for restoring data in a transactional database that is accessed by more than one controller. An alternate controller is held in reset mode and placed offline, so that data in the transactional database cannot be changed during the restoration process. In addition, the database is placed offline and the host is notified that the database is invalid, so that the host cannot access the transactional database. | 06-21-2012 |
| 20120158683 | Mechanism for Inode Event Notification for Cluster File Systems - A mechanism for inode event notification for cluster file systems is disclosed. A method of the invention includes implementing a lock scheme for a cache manager associated with an inode of a cluster file system, wherein the lock scheme includes a null lock (NL) used as a reference count for a lock value block (LVB) and an exclusive (EX) lock used for setting up inode event notifications, and associating a first global counter and a second global counter with the cache manager for the inode, wherein the first global counter is configured to track one or more processes that have the inode open in read-only mode and the second global counter is configured to track processes that have the inode open in read-write mode. | 06-21-2012 |
| 20120158684 | PERFORMANCE ENHANCED SYNCHRONIZATION MECHANISM WITH INTENSITY-ORIENTED READER API - A method for synchronizing data operations in a multi-threaded computer system using a hybrid lock data structure that allows the computer system to dynamically implement a low contention cost lock or a low overhead cost lock based on the intensity of the memory operation. | 06-21-2012 |
| 20120166408 | Aspected Interfaces and Methods for Synchronized Containers and Other Data Structures - The subject disclosure is directed towards an object (e.g., an aspected vector, queue, map, stack and so forth) container having an exclusive interface, a shared-read-only interface and a shared-write (and read) interface to a common set of data. Use cases during runtime determine the appropriate interface to use. No locking is needed with methods of the exclusive interface or the read-only interface. The shared-write interface is configured to have only concurrency safe methods. Also described is blocking the use of other interfaces while one interface is in use, and the use of reference counter tracking to know when no concurrent readers and/or writers remain, to allow transitioning to use a different interface. | 06-28-2012 |
| 20120173499 | MANAGING LOCKS AND TRANSACTIONS - An indication of refusal of a lock request is received with a first operation identifier for a resource that is already locked with a lock associated with a second operation identifier from an agent that controls the resource, wherein the agent returns a value that determines how long the lock request is to stay on the queue. The lock request is placed in a queue with a lock queue timeout period based on the value from the agent. The lock request is reissued if the lock associated with the second operation identifier has been released and the lock request reaches a position of the queue from which the lock request is processed within the lock queue timeout period. The lock request is re-queued if the reissued lock request is not granted based on how many times the lock request has been previously placed in the queue. | 07-05-2012 |
| 20120185452 | SYSTEM AND METHOD FOR FILE COORDINATION - An apparatus and method are described for performing file coordination operations on a computer system. For example, one embodiment of a system for performing file coordination comprises: a file coordination service having arbitration logic for arbitrating among different read and write processes attempting to perform file read and write operations, respectively; and a file presenter representing a file opened by a file editing application and registering the opened file with the file coordination service; wherein prior to permitting a read/write process to perform its designated read/write operation, the file coordination service notifies the file presenter and waits for a response from the file presenter indicating that the read/write operation may proceed. | 07-19-2012 |
| 20120185453 | SCSI PROTOCOL EMULATION FOR VIRTUAL STORAGE DEVICE STORED ON NAS DEVICE - A virtualization technique, in accordance with one embodiment of the present invention, includes emulating the small computing system interface (SCSI) protocol to access a virtual SCSI storage device backed by a file stored on network attached storage (NAS). | 07-19-2012 |
| 20120209823 | METHOD AND SYSTEM FOR MANAGING DATABASE ACCESS CONTENTION - A method comprises receiving an access request for a database table; selecting a table from two or more tables corresponding to the requested database table; and providing access according to the access request to the selected table. The selecting is based on a type of access request and a designation of the selected table corresponding to the type of access request. | 08-16-2012 |
| 20120221538 | OPTIMISTIC, VERSION NUMBER BASED CONCURRENCY CONTROL FOR INDEX STRUCTURES WITH ATOMIC, NON-VERSIONED POINTER UPDATES - Methods, systems and computer program products for traversing a level in a search path in a tree data structure by recording a version number of a node on the search path, finding a child pointer in the node on the search path, recording a version number of a child node corresponding to the child pointer, reading a version number of the node on the search path, comparing the recorded version number of the node to the read version number of the node, reading at least one child pointer in the node and comparing the read child pointer to an address of the child node. | 08-30-2012 |
| 20120226673 | CONFIGURATION-LESS NETWORK LOCKING INFRASTRUCTURE FOR SHARED FILE SYSTEMS - A network-based method for managing locks in a shared file system (SFS) for a group of hosts that does not require any configuration to identify a server for managing locks for the SFS. Each host in the group carries out the steps of checking a predetermined storage location to determine whether there is a host ID written in the predetermined location. If there is no host ID written in the predetermined location, the first host to notice this condition writes its host ID in the predetermined location to identify itself as the server for managing locks. If there is a host ID written in the predetermined location, the host ID of the server for managing locks is maintained in local memory. When the host needs to perform IO operations on a file of the SFS, it communicates with the server for managing locks over the network using the host ID of the server for managing locks to obtain a lock to the file. | 09-06-2012 |
| 20120254139 | PROVIDING LOCK-BASED ACCESS TO NODES IN A CONCURRENT LINKED LIST - A method of providing lock-based access to nodes in a concurrent linked list includes providing a plurality of striped lock objects. Each striped lock object is configured to lock at least one of the nodes in the concurrent linked list. An index is computed based on a value stored in a first node to be accessed in the concurrent linked list. A first one of the striped lock objects is identified based on the computed index. The first striped lock object is acquired, thereby locking and providing protected access to the first node. | 10-04-2012 |
| 20120271804 | DATA ACCESS DEVICE, DATA ACCESS METHOD AND DATA ACCESS PROGRAM - A data access device provided with a sequence storage unit which stores in advance a sequence for accessing the data contained in each of the multiple data units stored in a data storage section. The data access device receives and stores in the data access request storage section multiple data access requests for any of the multiple stored data units, determines an execution sequence for the multiple stored data access requests that corresponds to the aforementioned sequence stored in the sequence storage unit, locks the data units to be accessed as per the data access requests, sequentially implements the data access requests in the determined execution sequence, and removes all the locks after implementing all of the stored data access requests. | 10-25-2012 |
| 20120278294 | SELECTIVE LOCKING OF OBJECT DATA ELEMENTS - Product Data Management systems, methods, and mediums. A method includes receiving a lock request for data of a specified type. The method includes processing the lock request in response to the lock request, including locking the data of the specified type for a plurality of data objects in response to the lock request. The method includes receiving at least one change to data of the specified type for at least one of the plurality of data objects, The method includes updating and saving the at least one of the plurality of objects according to the received change by changing the data of the specified type. | 11-01-2012 |
| 20120310909 | FILE SYSTEM WITH OPTIMISTIC I/O OPERATIONS ON SHARED STORAGE - A method for performing I/O operations on a file stored in a file system utilizing a shared data storage system and accessible by a plurality of host computers is disclosed. A host computer receives from a process executing on it, a request to read data stored in the file. The host computer then requests the data stored in the file without acquiring a lock from the file system. The host computer also maintains a timeout value associated with the file while reading the data. The host computer receives at least a portion of the data prior to an expiration of time, and if all the data has not been received before the expiration of time, it then assesses whether another of the host computers has acquired a lock on the file, and, if so, invalidates the received data without providing it to the requesting process. | 12-06-2012 |
| 20120317085 | SYSTEMS AND METHODS FOR TRANSMITTING CONTENT METADATA FROM MULTIPLE DATA RECORDS - Systems and methods are provided for cataloging content metadata from a variety of sources and providing metadata to client devices. A processing device receives inconsistent data records representative of a common content element, with different values for a metadata field descriptive of a common attribute of the content element. The processor assign confidence scores metadata fields from each data record, and use these confidence scores to select the metadata that is transmitted to the client device. | 12-13-2012 |
| 20120323872 | TWO-PHASE EVICTION PROCESS FOR FILE HANDLE CACHES - Systems and methods are provided for evicting entries from a file handle cache. In accordance with certain embodiments, a two-stage eviction process is utilized. In a first stage of the eviction process, entries in the file entry cache are analyzed and marked for eviction while a shared lock is maintained on the file handle cache. The shared lock enables the file handle cache to be concurrently accessed by a content serving system to service content requests. In a second stage of the eviction process, entries in the file handle cache that are marked for eviction are removed while an exclusive lock is maintained on the file handle cache. The exclusive lock prevents the content serving system from concurrently accessing the file handle cache to service content requests. | 12-20-2012 |
| 20120323873 | Managing Concurrent Access to Data in Database Sytem - A method for managing access to data in a database system includes receiving requests to update data stored in one or more fields of a record in a database table. The method further identifies lock information of the one or more fields from a look-up table associated with the record. The look-up table associated with the record includes lock information of each field of the record. The method then handles the requests based on the identified lock information of the one or more fields. | 12-20-2012 |
| 20130006950 | Method for Attaching Partition ONLINE to Range Partitioned Table - Method for attaching one or more tables online to a range partitioned table, includes: starting a child transaction; obtaining an exclusive lock on a source table; obtaining an intent exclusive lock on a target table; soft invalidating queries on the target table where compiled form of queries are cached for reuse; attaching the source table(s) to the target table as a new partition(s) of the target table; modifying indices and table structure of the target table to reflect the attaching of the new partition; committing the child transaction; and releasing the exclusive lock and the intent exclusive lock, where concurrently running queries over the target table continue to run without considering the partition until the intent exclusive lock and the exclusive lock are released. Queries on the target table only consider existing partitions when the attaching is in progress. The new partition is available once the attach operation is complete. | 01-03-2013 |
| 20130018861 | DUAL LOCKING MECHANISM FOR A DOMAIN - One embodiment is directed to a method for controlling access to a domain. The method includes receiving a request from a workbook process for a shared lock on a primary lock file and a secondary lock file controlling access to the domain, and providing the shared lock(s) when there is not an exclusive lock. While the workbook process is still in progress, the method may further include receiving a request from a batch process for an exclusive lock on the primary lock file, immediately providing an exclusive lock on the primary lock file the batch process, receiving a request from the batch process for an exclusive lock on the secondary lock file, and providing the exclusive lock on the secondary lock file to the batch process when there is not a shared lock on the secondary lock file. | 01-17-2013 |
| 20130024436 | SYSTEMS AND METHODS FOR DATA MIGRATION IN A CLUSTERED FILE SYSTEM - Systems and methods for providing more efficient handling of I/O requests for clustered file system data subject to data migration or the like. For instance, exemplary systems can more quickly determine if certain files on primary storage represent actual file data or stub data for recalling file data from secondary storage. Certain embodiments utilize a driver cache on each cluster node to maintain a record of recently accessed files that represent regular files (as opposed to stubs). A dual-locking process, using both strict locking and relaxed locking, maintains consistency between driver caches on different nodes and the data of the underlying clustered file system, while providing improved access to the data by the different nodes. Moreover, a signaling process can be used, such as with zero-length files, for alerting drivers on different nodes that data migration is to be performed and/or that the driver caches should be flushed. | 01-24-2013 |
| 20130031069 | ALLOWING WRITES TO COMPLETE WITHOUT OBTAINING A WRITE LOCK TO A FILE - Provided are a computer program product, system, and method for allowing writes to complete without obtaining a write lock to a file. A lock is provided to a first request, comprising a read or write request, to access the file. A second write request is received while the first request maintains the lock. A temporary file associated with the file for the second write request is created. The second write request is controlled to write to the temporary file while the lock is held by the first request. In response to completing the first request, the lock is granted to the second write request to write the data in the temporary file to the file. | 01-31-2013 |
| 20130060742 | MULTI-ROW TRANSACTIONS - Techniques are provided for more efficient multi-row atomic, consistent, isolated and durable (ACID)-compliant transactions with snapshot isolation semantics (or just “multi-row transactions” for short). In some embodiments, the techniques are implemented in a computing system that includes a client application, a lightweight in-memory lease-based lock service, a multi-row transaction orchestrator, and an underlying database system. The transaction orchestrator implements a read protocol and a write protocol that provides support to the client application for carrying out multi-row transactions against the underlying database system irrespective of whether the database system itself supports multi-row transactions. The transaction orchestrator explicitly maintains transaction-level locks obtained from the lease-based lock service as part of the transaction protocol. Further, the transaction orchestrator is tolerant to lock service failure and unavailability without compromising ACID-compliance and snapshot isolation guarantees to the client application. | 03-07-2013 |
| 20130073532 | COORDINATION OF EVENT LOGGING OPERATIONS AND LOG MANAGEMENT - A plurality of log processes are synchronized. Each is independently performed in parallel with one another, into a single set of log files. A line buffering mechanism of an operating system (OS) of the computing environment forecloses interleaving of the log processes. Log management operations are concurrently performed by a single process protected by a file-system lock of the OS. The log management operations include at least one of a log compression, log retention, and log rotation operation. | 03-21-2013 |
| 20130097135 | METHOD AND SYSTEM FOR GENERATING DOMAIN SPECIFIC IN-MEMORY DATABASE MANAGEMENT SYSTEM - A concurrent graph DBMS allows for representation of graph data structures in memory, using familiar Java object navigation, while at the same time providing atomicity, consistently, and transaction isolation properties of a DBMS, including concurrent access and modification of the data structure from multiple application threads. The concurrent graph DBMS serves as a “traffic cop” between application threads to prevent them from seeing unfinished and inconsistent changes made by other threads, and atomicity of changes. The concurrent graph DBMS provides automatic detection of deadlocks and correct rollback of a thread's incomplete transaction when exceptions or deadlocks occur. The concurrent graph DBMS may be generated from a schema description specifying objects and relationships between objects, for the concurrent graph DBMS. | 04-18-2013 |
| 20130097136 | METHOD AND SYSTEM FOR ACESSING DOMAIN SPECIFIC IN-MEMORY DATABASE MANAGEMENT SYSTEM - A concurrent graph DBMS allows for representation of graph data structures in memory, using familiar Java object navigation, while at the same time providing atomicity, consistently, and transaction isolation properties of a DBMS, including concurrent access and modification of the data structure from multiple application threads. The concurrent graph DBMS serves as a “traffic cop” between application threads to prevent them from seeing unfinished and inconsistent changes made by other threads, and atomicity of changes. The concurrent graph DBMS provides automatic detection of deadlocks and correct rollback of a thread's incomplete transaction when exceptions or deadlocks occur. The concurrent graph DBMS may be generated from a schema description specifying objects and relationships between objects, for the concurrent graph DBMS. | 04-18-2013 |
| 20130144853 | DEVICE AND METHOD FOR ACQUIRING RESOURCE LOCK - A lock control device receives a lock acquisition request from an application and transmits a lock acquisition request to a DBMS, receives a lock acquisition response from the DBMS, and transmits a lock acquisition response to the application, and each time, acquires statistical time information including the lock request counter, subsequent lock request counter, lock request time, lock acquisition time, initial lock acquisition time, and subsequent lock request time. The statistical processing device calculates the lock request count for each resource, subsequent lock request count for each resource, average lock wait time, and average lock acquisition delay expectation time, based on the statistical time information. Based on these values, the statistical processing device calculates an evaluation value which is the degree of expectation for the time eliminated from the lock wait time when lock acquisition is postponed, and outputs the lock order of the resources arranged in order of smallest evaluation value to a lock order table. | 06-06-2013 |
| 20130159266 | N-DIMENSIONAL LOCKING - An apparatus, method and computer-readable storage medium for determining intent object preferences for locking intent objects, and grouping the intent objects into sets based on the intent object preferences for locking. The sets may contain intent objects with matching preference values for the intent object preferences for locking. Each set may be locked such that only a matcher object associated with the set may operate on the set. The locking may be done in memory, or via a database. The matcher associated with a set may determine whether the intent objects in that set match other intent objects in the set. Multiple matchers may operate on their associated sets in parallel. | 06-20-2013 |
| 20130173567 | DEFERRED RELEASE PROCESSING WITHOUT DATABASE RECORD LOCKING - Performance in databases stored over multiple host computer systems may be improved by writing and releasing records without locking the records. An attribute flag may be set on certain records in a database to indicate to the database that the records may be written and released without locking the records. When the attribute flag is set, the record may be processed during deferred processing by writing a free bit pattern and releasing the record without locking the record. | 07-04-2013 |
| 20130185270 | LOCK ACCELERATION - A method for locking resources, including: receiving, by an accelerator, a first request from a first client to lock a first resource; evaluating, by a computer processor of a server, a hash function using an identifier of the first resource as an input to the hash function; identifying, by the computer processor and based on evaluating the hash function, a first hash bucket in a shared memory residing in a physical memory of the server; detecting that the first hash bucket is occupied; and sending the first request to a master lock monitor residing in a user space of the server based at least on detecting that the first hash bucket is occupied. | 07-18-2013 |
| 20130185271 | OPTIMIZED B-TREE - The present technology includes an optimized b-tree. To improve concurrent access, a read lock can be applied to traversed nodes of a b-tree in a lock coupling. A read locked node can be promoted to a write locked node upon a determination that the node is likely to be modified, wherein the locked node first restricts access to further functions and then applies a write lock to the node when all existing functions accessing the node end. If one of the other functions attempts to promote the later function can be canceled and removed from the tree. A node can be promoted if the node is likely to be modified when considering multiple factors such as type of function, whether it is a leaf node, the number of keys in the node, or the number of keys in a child node. | 07-18-2013 |
| 20130254173 | MULTI-TENANCY IN DATABASE NAMESPACE - Methods for processing a query in a multi-tenancy environment utilizing an electronic computing device are presented, the methods including: causing the electronic computing device to receive the query to a database, where the query includes a number of objects; causing the electronic computing device to determine whether any of the number of objects correspond with the set of tenant database objects; if any of the number of objects correspond with the set of tenant database objects, causing the electronic computing device to process the number of objects from the tenant production table; and if any of the number of objects correspond with the set of instance database objects, causing the electronic computing device to process the number of objects from the instance production table. | 09-26-2013 |
| 20130275401 | METHOD AND SYSTEM FOR ELECTRONIC CONTENT LOCKING - A method for electronic content locking including: accessing electronic content and determining if the electronic content is currently locked for a first user. The method further determines meta-data relating to the electronic content and allows a second user to override the lock such that the electronic content is unlocked if the meta-data meet predetermined criteria. A system for electronic content locking having: an electronic content repository; and a locking controller adapted to change the status of electronic content in the electronic content repository between locked and unlocked. The system further includes a data collection module designed to retrieve meta-data relating to electronic content; and an override controller designed to override the locking controller and change the status of the locked electronic content from a first user to a second user. | 10-17-2013 |
| 20130290286 | METHOD, APPARATUS, AND SYSTEM FOR OPERATING SHARED RESOURCE IN ASYNCHRONOUS MULTIPROCESSING SYSTEM - Technical effects of a method, an apparatus, and a system for operating a shared resource in an asynchronous multiprocessing system that are provided in the present invention are as follows: A processor in an asynchronous multiprocessing system implements an operation on a shared resource by locking a hardware resource lock, and the hardware resource lock is implemented by a register; in this way, a bus in the asynchronous multiprocessing system does not need to support a synchronization operation, and the processor also does not need to have a feature of supporting a synchronization operation, and is capable of implementing the operation on the shared resource only in a manner of accessing the register, which simplifies the operation on the shared resource by the processor in the asynchronous multiprocessing system, enlarges a selection range of the processor in the asynchronous multiprocessing system, and further improves flexibility of the asynchronous multiprocessing system. | 10-31-2013 |
| 20130304716 | ALLOWING UPDATES TO DATABASE OBJECTS - A system and method for allowing flexible and simultaneous updates to database objects from one or more users is disclosed. The system may receive a change request to the object from the first user and then from a second user. The system may determine if the object is locked and, if so, informing the first user. If an edit request is received from the second user, the second user may be provided with multiple options, such as incorporating changes made by first user and overwriting changes made by second user with changes made by first user, incorporating changes made by first user and overwriting changes made by first user with changes made by second user, and cancelling changes made by second user. | 11-14-2013 |
| 20130318060 | MULTI-ROW TRANSACTIONS - Techniques are provided for more efficient multi-row atomic, consistent, isolated and durable (ACID)-compliant transactions with snapshot isolation semantics (or just “multi-row transactions” for short). In some embodiments, the techniques are implemented in a computing system that includes a client application, a lightweight in-memory lease-based lock service, a multi-row transaction orchestrator, and an underlying database system. The transaction orchestrator implements a read protocol and a write protocol that provides support to the client application for carrying out multi-row transactions against the underlying database system irrespective of whether the database system itself supports multi-row transactions. The transaction orchestrator explicitly maintains transaction-level locks obtained from the lease-based lock service as part of the transaction protocol. Further, the transaction orchestrator is tolerant to lock service failure and unavailability without compromising ACID-compliance and snapshot isolation guarantees to the client application. | 11-28-2013 |
| 20140025653 | Source Control Inheritance Locking - An embodiment of the invention provides a method for source control in a program, wherein the program includes hierarchical files for execution of processes, wherein the hierarchical files include parent files and child files. A revised process selected by a user on a graphical user interface is identified; and, files in the revised process are identified. The files in the revised process are locked with a source control processor. This includes disallowing revisions to the files in the revised process. One or more files that are descendents of a file in the revised process are identified. The one or more files that are descendents of a file in the revised process are locked with the source control processor. This includes disallowing revisions to the one or more files that are descendents of a file in the revised process. | 01-23-2014 |
| 20140032515 | FILE SYSTEM WITH OPTIMISTIC I/O OPERATIONS ON SHARED STORAGE - A method for performing I/O operations on a file stored in a file system utilizing a shared data storage system and accessible by a plurality of host computers is disclosed. A host computer receives from a process executing on it, a request to read data stored in the file. The host computer then requests the data stored in the file without acquiring a lock from the file system. The host computer also maintains a timeout value associated with the file while reading the data. The host computer receives at least a portion of the data prior to an expiration of time, and if all the data has not been received before the expiration of time, it then assesses whether another of the host computers has acquired a lock on the file, and, if so, invalidates the received data without providing it to the requesting process. | 01-30-2014 |
| 20140040218 | METHODS AND SYSTEMS FOR AN INTENT LOCK ENGINE - In at least some examples, a system may include a processor core and a non-transitory computer-readable memory in communication with the processor core. The non-transitory computer-readable memory may store an intent lock engine to manage intent locks based on a private lock table for each process associated with said processor core and a global lock table for a plurality of processes associated with at least one of a plurality of processor cores including said processor core. | 02-06-2014 |
| 20140040219 | METHODS AND SYSTEMS FOR A DEADLOCK RESOLUTION ENGINE - In at least some examples, a system may include a processor core and a non-transitory computer-readable memory in communication with the processor core. The non-transitory computer-readable memory may store a deadlock resolution engine to resolve a deadlock condition based on an abort shortest pipeline policy. | 02-06-2014 |
| 20140040220 | METHODS AND SYSTEMS FOR DEADLOCK DETECTION - In at least some examples, a system may include a processor core and a non-transitory computer-readable memory in communication with the processor core. The non-transitory computer-readable memory may store deadlock detection engine to determine a deadlock condition, wherein the deadlock detection engine accounts for a set of database lock modes. | 02-06-2014 |
| 20140040221 | SECURE STORAGE MANAGEMENT SYSTEM AND METHOD - The present invention provides a storage management system and method for managing access between a plurality of processes and a common store. According to the invention, each individual process comprises data processing means, a cache for the temporary storage of data generated by the data processing means, and a control unit for managing the transferral of data between the cache and a common store. The control unit comprises a manager for monitoring the availability of storage locations in the store to receive and store data and for allocating data to available storage locations, an interface for transferring the allocated data to the available storage locations, and a locking arrangement for locking the store during data transfer in order to ensure exclusive access and thereby preserve data integrity. | 02-06-2014 |
| 20140122453 | METHOD AND SYSTEM FOR REDUCING LOCK OCCURRENCES IN SERVER/DATABASE SYSTEMS - The invention relates to a computer-implemented method for limiting the number of concurrent requests in a database system including the following steps: arranging requests to be handled by the database system in at least one queue; defining a maximum value (SS) of concurrent requests corresponding to the at least one queue; monitoring at least one queue utilization parameter corresponding to the at least one queue and calculating a performance value based on the at least one queue utilization parameter, adapting the maximum value (SS) of concurrent requests of the at least one queue dynamically based on the performance value (PF) in order to improve system performance and limiting the number of concurrent requests of the at least one queue dynamically based on the dynamically adapted maximum value (SS). | 05-01-2014 |
| 20140136501 | DATABASE USAGE TRENDS BASED ON DATABASE LOCK REQUESTS - An enterprise locking service coordinates multiple cooperating applications to ensure that one and only one user is modifying a database record at a given time. The database records may be stored in multiple databases having potentially different database record locking protocols. Through monitoring and tracking requests for database locks, the enterprise locking service is also able to determine database usage trends under various metrics. | 05-15-2014 |
| 20140136502 | File Lock Preservation - A method for preserving file locks is described herein. The method includes detecting a node migration event, occurring at a migrating node, in a cluster system ( | 05-15-2014 |
| 20140258255 | SYSTEM AND METHOD FOR MINIMIZING LOCK CONTENTION - According to one aspect, provided are methods and systems for minimizing lock contention in a distributed database environment. The methods and systems can include a database management component configured to manage database instances, the database management component also configured to receive a first data request operation on the distributed database, an execution component configured to process the first data request operation including at least one write request on at least one database instance managed by the database management component, and a fault prediction component configured to detect a potential page fault responsive to a target data of the write request, wherein the execution component is further configured to suspend execution of the first data request operation, request access a physical storage to read the target data into active memory, and re-execute the first data request operation after a period of time for suspending the first data request operation. | 09-11-2014 |
| 20140279987 | WORKFLOW DESIGN FOR LONG-RUNNING DISTRIBUTED OPERATIONS USING NO SQL DATABASES - Transactions or operations associated with a received request are performed with a NoSQL database. A request ID is assigned to the request, an operation ID to the operation, and an entity ID to the entity associated with the operation. The entity is locked in the database, and the operation is performed. The database is unlocked, and a message is transmitted to a lock queue to release an entry therein associated with the request. If a second request attempt to lock the same entity while the first is concurrent, it requests that the lock queue inform it when the lock is released. | 09-18-2014 |
| 20140289209 | PROVIDING RECORD-LEVEL SHARING (RLS) TO LOCAL DATA SETS - Systems, methods, and computer program products are described for providing record-level sharing (RLS) for data sets to local users of a system. In one embodiment, a process includes requesting access to a data set from a record-oriented file system in which the file system manages records on behalf of one or more users, and the access is requested for a first local user. The process proceeds by locking the data set in the file system such that no direct access of the data set is allowed. Read and/or write requests for the data set are processed using the representation of the data set in the designated server address space. The data set in the file system is updated with any changes made to the representation of the data set in the designated server address space. | 09-25-2014 |
| 20140304246 | SYSTEMS AND METHODS FOR IMPLEMENTING BULK HANDLING IN ASYNCHRONOUS PROCESSING - In accordance with disclosed embodiments, there are provided systems and methods for implementing bulk handling in asynchronous processing. According to a particular embodiment such a system includes a processor and a memory to execute instructions at the system; a broker to enqueue received messages; a push connection from the broker to a thread, in which the broker is to push an initial message to the thread for processing; a pull connection from the thread to the broker, in which the thread is to request one or more additional messages for bulk processing with the initial message from the broker; a query interface to issue a database query from the thread to a data store, the database query specifying the initial message and the one or more additional messages as a set of messages to obtain a lock for the set of messages; and a message processing engine to handle the set of messages in bulk based on whether the lock for the set of messages is obtained. Other related embodiments are disclosed. | 10-09-2014 |
| 20140330802 | METADATA STRUCTURES AND RELATED LOCKING TECHNIQUES TO IMPROVE PERFORMANCE AND SCALABILITY IN A CLUSTER FILE SYSTEM - Metadata structures and related locking techniques to improve performance and scalability in a cluster file system are disclosed. In one implementation, a method includes receiving, by a server, a request for a first file, retrieving, by the server, the first file and metadata for a second file that is related to the first file, and sending, by the server in response to the retrieving and in advance of any request for the metadata for the second file, an asynchronous lock request to obtain a lock for accessing at least a portion of the metadata for the second file. | 11-06-2014 |
| 20140351231 | Low Overhead Contention-Based Switching Between Ticket Lock And Queued Lock - A technique for low overhead contention-based switching between ticket locking and queued locking to access shared data may include establishing a ticket lock, establishing a queue lock, operating in ticket lock mode using the ticket lock to access the shared data during periods of relatively low data contention, and operating in queue lock mode using the queue lock to access the shared data during periods of relatively high data contention. | 11-27-2014 |
| 20140372396 | Database System Lock Operation Method and Device - A database system lock operation method is provided that includes: acquiring, by a first processing node, a lock operand of a target lock; using, by the first processing node, the target lock to perform a lock acquiring operation on a target data object; when the lock operand meets a condition for a successful lock acquiring operation, determining, by the first processing node, that the lock acquiring operation is successful, and updating a value of a data bit that is in the lock operand and used to indicate a state of the target lock on the first processing node to a value that is used to indicate that the state of the target lock on the first processing node is lock held. Accordingly, the embodiments of the present invention further disclose a node device. The embodiments of the present invention can improve performance of a database system. | 12-18-2014 |
| 20140372397 | REDUCING LOCK OCCURRENCES IN SERVER/DATABASE SYSTEMS - Limiting the number of concurrent requests in a database system. Arranging requests to be handled by the database system in at least one queue. Defining a maximum value (SS) of concurrent requests corresponding to the at least one queue. Monitoring at least one queue utilization parameter corresponding to the at least one queue and calculating a performance value based on the at least one queue utilization parameter. Adapting the maximum value (SS) of concurrent requests of the at least one queue dynamically based on the performance value (PF) in order to improve system performance. Limiting the number of concurrent requests of the at least one queue dynamically based on the dynamically adapted maximum value (SS). | 12-18-2014 |
| 20140379676 | Highly Scalable Tree-Based Trylock - A tree-based trylock technique for reducing contention on a root trylock includes attempting to acquire a trylock at each node of a tree-based hierarchical node structure while following a traversal path that begins at a leaf node, passes through one or more of internal nodes, and ends at a root node having the root trylock. The trylock acquisition operation succeeds if each trylock on the traversal path is acquired, and fails if any trylock on the traversal path cannot be acquired. A trylock housekeeping operation releases all non-root trylocks visited by the trylock acquisition operation, such that if the trylock acquisition operation succeeds, only the root trylock will be remain acquired at the end of the operation, and if the trylock acquisition operation fails, none of the trylocks will be remain acquired at the end of the operation. | 12-25-2014 |
| 20140379677 | TEST SANDBOX IN PRODUCTION SYSTEMS DURING PRODUCTIVE USE - Methods and systems are directed to controlling access to data in a production environment. Production data may be stored in a production database and test data may be stored in a test database. A production application may have access only to the data in the production database while a test application may have access to both the production database and the test database. The test application may have read-only access to the production database and read-write access to the test database. Data in the test database may be handled differently than data in the production database. A type of data may be associated with a range of valid values. The values assigned to the elements may differ depending on whether the elements are stored in the production database or the test database. | 12-25-2014 |
| 20140379678 | Highly Scalable Tree-Based Trylock - A tree-based trylock technique for reducing contention on a root trylock includes attempting to acquire a trylock at each node of a tree-based hierarchical node structure while following a traversal path that begins at a leaf node, passes through one or more of internal nodes, and ends at a root node having the root trylock. The trylock acquisition operation succeeds if each trylock on the traversal path is acquired, and fails if any trylock on the traversal path cannot be acquired. A trylock housekeeping operation releases all non-root trylocks visited by the trylock acquisition operation, such that if the trylock acquisition operation succeeds, only the root trylock will be remain acquired at the end of the operation, and if the trylock acquisition operation fails, none of the trylocks will be remain acquired at the end of the operation. | 12-25-2014 |
| 20140379679 | DEVICE AND METHOD FOR ACQUIRING RESOURCE LOCK - A lock control device receives a lock acquisition request from an application and transmits a lock acquisition request to a DBMS, receives a lock acquisition response from the DBMS, and transmits a lock acquisition response to the application, and each time, acquires statistical time information including the lock request counter, subsequent lock request counter, lock request time, lock acquisition time, initial lock acquisition time, and subsequent lock request time. The statistical processing device calculates the lock request count for each resource, subsequent lock request count for each resource, average lock wait time, and average lock acquisition delay expectation time, based on the statistical time information. Based on these values, the statistical processing device calculates an evaluation value which is the degree of expectation for the time eliminated from the lock wait time when lock acquisition is postponed, and outputs the lock order of the resources arranged in order of smallest evaluation value to a lock order table. | 12-25-2014 |
| 20150019517 | METHOD FOR CONCURRENCY CONTROL IN A DOCBASE MANAGEMENT SYSTEM - A method for concurrency control in a docbase management system is provided by an embodiment of the present invention. Document data is stored in a tree structure; the method includes: determining whether an operation instruction on at least one node in the tree structure is compatible with every operation being implemented in the tree structure, when the operation instruction is received; implementing the operation instruction when it is determined that the operation instruction is compatible with the operation being implemented; otherwise, not implementing the operation instruction. | 01-15-2015 |
| 20150081652 | METHOD AND A SYSTEM FOR MERGING DATA INTO A DATABASE TABLE WITH CONSTRAINTS CONSISTENCY ANALYSIS AND CUSTOMIZED MERGE PARAMETERS - A method and a system import data into a table. The method includes providing the table with data identities and a primary key assigned to each of the data identities. A temporary copy of the table is provided and contains a data identity to be merged into the table. The table structure of the table and of the temporary copy is determined and the determined table structure is compared to the table structure of the temporary copy to decide which data identities have to be updated and/or imported. In the temporary copy a new column contains a final primary key of the related data identity for its transfer into the table. The data identities in the table that are present in the temporary copy are locked and an update function for the data identities having the same primary key in both the table and the temporary copy are executed. | 03-19-2015 |
| 20150120687 | REDUCING DATABASE LOCKING CONTENTION USING MULTI-VERSION DATA RECORD CONCURRENCY CONTROL - Managing a multi-version data record database is provided. A mapping is maintained between a logical record identifier and committed and uncommitted physical record identifiers corresponding to data records using an indirection mapping table. Entries are updated within an index to point to the logical record identifier instead of the committed and uncommitted physical record identifiers. The committed physical record identifier corresponding to a data record is read from the indirection mapping table to access a committed version of the data record while a writer is modifying the data record to prevent the writer from blocking a reader. An uncommitted physical record identifier corresponding to the data record is written in the indirection mapping table to insert a new uncommitted version of the data record within a data table while the reader is reading the committed version of the particular data record to prevent the reader from blocking the writer. | 04-30-2015 |
| 20150134630 | ALLOWING WRITES TO COMPLETE WITHOUT OBTAINING A WRITE LOCK TO A FILE - Provided are a computer program product, system, and method for allowing writes to complete without obtaining a write lock to a file. A lock is provided to a first request, comprising a read or write request, to access the file. A second write request is received while the first request maintains the lock. A temporary file associated with the file for the second write request is created. The second write request is controlled to write to the temporary file while the lock is held by the first request. In response to completing the first request, the lock is granted to the second write request to write the data in the temporary file to the file. | 05-14-2015 |
| 20150293953 | ROBUST, LOW-OVERHEAD, APPLICATION TASK MANAGEMENT METHOD - Application task management (“ATM”) methods may employ a task list stored in a file on a nonvolatile information storage medium. Parallel processing instances employ an application programming interface (“API”) that enables each processing instance to individually access the task list. The access protocol enforced by the API is sufficient to provide robust, fault-tolerant behavior without requiring a specific process or daemon to be responsible for ATM. The API may employ a locking mechanism based on universal or widely-available operating system calls (such as directory creation) that implicitly or explicitly guarantee atomic operations. Each processing instance performs a check-out of unfinished tasks with a request that includes a timeout value, transforms the unfinished tasks into finished tasks, and provides a check-in of the finished tasks, and repeats. This approach supports the use of a variety of models through the use of chained or nested task lists, and it can be readily scaled. | 10-15-2015 |
| 20150310030 | ADAPTIVE FRAGMENT ASSIGNMENT FOR PROCESSING FILE DATA IN A DATABASE - Scheduling mechanisms for assigning data in a distributed file system to database workers are provided. In one embodiment, a method of and computer program product for assignment of data blocks to database workers are provided. A request for table data is received. Metadata for a plurality of blocks in a file system is retrieved from a metadata store. Each of the plurality of blocks contains a subset of the table data. A request for work is received from a requestor. An assignment of one or more of the plurality of blocks is provided to the requestor. | 10-29-2015 |
| 20150356110 | MANAGING OPPORTUNISTIC LOCKS IN A DISTRIBUTED FILESYSTEM - The disclosed embodiments disclose techniques for managing opportunistic locks in a distributed filesystem. Two or more cloud controllers collectively manage distributed filesystem data that is stored in the cloud storage systems; the cloud controllers ensure data consistency for the stored data, and each cloud controller caches portions of the distributed filesystem. During operation, a client sending a request to access a file from a cloud controller also requests an opportunistic lock for the file. If there are no other outstanding client accesses on the other cloud controllers that preclude the requested opportunistic lock, the cloud controller grants the client file access and the opportunistic lock. | 12-10-2015 |
| 20150363417 | JOB EXECUTION DEVICE, NON-TRANSITORY COMPUTER-READABLE RECORDING MEDIUM AND DATA DELETION METHOD - A job execution device includes: a storing unit; a file system that divides a storing area of the storing unit into a plurality of division areas, and manages the storing area of the storing unit; a management table in which deletion management information indicating whether an overwrite deletion is necessary is registered for each of the division areas; a deletion processing unit; a job execution unit; and a management table updating unit. When the file system receives the releasing request, the file system changes the division area management information for the division areas to be released by the releasing request so as to change the status to “unused” before the deletion management information for all of the division areas to be released by the releasing request is changed to a non-necessity of the overwrite deletion. | 12-17-2015 |
| 20160019253 | PLANNED CLUSTER NODE MAINTENANCE WITH LOW IMPACT ON APPLICATION THROUGHPUT - Techniques for taking one or more nodes of a multi-node database system offline are provided. Initially, the multi-node database system uses a first data access management system (e.g., a distributed lock management system) to manage access to data stored in a database. In response to determining that one or more nodes need to be taken offline or otherwise become unavailable, the remaining nodes implement a second data access management system (e.g., an affinity-based access system) to manage access to data stored in the database. After the offline nodes are brought back online, all the nodes in the multi-node database system implement the first data access management system again. The transitions between the two data access management system may involve multiple phases that involve communicating different types of information between nodes that are taken offline and nodes that are not taken offline. | 01-21-2016 |
| 20160070738 | REDUCING LOCK OCCURRENCES IN SERVER/DATABASE SYSTEMS - Limiting the number of concurrent requests in a database system. Arranging requests to be handled by the database system in at least one queue. Defining a maximum value (SS) of concurrent requests corresponding to the at least one queue. Monitoring at least one queue utilization parameter corresponding to the at least one queue and calculating a performance value based on the at least one queue utilization parameter. Adapting the maximum value (SS) of concurrent requests of the at least one queue dynamically based on the performance value (PF) in order to improve system performance. Limiting the number of concurrent requests of the at least one queue dynamically based on the dynamically adapted maximum value (SS). | 03-10-2016 |
| 20160085788 | REDUCING LOCK OCCURRENCES IN SERVER/DATABASE SYSTEMS - Limiting the number of concurrent requests in a database system. Arranging requests to be handled by the database system in at least one queue. Defining a maximum value (SS) of concurrent requests corresponding to the at least one queue. Monitoring at least one queue utilization parameter corresponding to the at least one queue and calculating a performance value based on the at least one queue utilization parameter. Adapting the maximum value (SS) of concurrent requests of the at least one queue dynamically based on the performance value (PF) in order to improve system performance. Limiting the number of concurrent requests of the at least one queue dynamically based on the dynamically adapted maximum value (SS). | 03-24-2016 |
| 20160092462 | LOCK-BASED UPDATING OF A DOCUMENT - Mechanisms can be provided for locking a component and extending the lock to one or more additional component(s) in a visual analyzer application. Embodiments can receive a request for a first component of a document for a first thread where the document is displayed by a graphical user interface (GUI) and has components including the first component and a second component. A lock manager may lock the first component. An action handler can determine, based on code associated with an event pertaining to the request, that the second component also needs to be locked. The lock manager may lock the second component for a same thread, if the first and second components are not currently locked. Additional user actions directed to other components of the application not currently locked may still proceed, permitting asynchronous calls to be processed without interference with a previous action that has already started. | 03-31-2016 |
| 20160092489 | REDUCING LOCK OCCURRENCES IN SERVER/DATABASE SYSTEMS - Limiting the number of concurrent requests in a database system. Arranging requests to be handled by the database system in at least one queue. Defining a maximum value (SS) of concurrent requests corresponding to the at least one queue. Monitoring at least one queue utilization parameter corresponding to the at least one queue and calculating a performance value based on the at least one queue utilization parameter. Adapting the maximum value (SS) of concurrent requests of the at least one queue dynamically based on the performance value (PF) in order to improve system performance. Limiting the number of concurrent requests of the at least one queue dynamically based on the dynamically adapted maximum value (SS). | 03-31-2016 |
| 20160092498 | MANAGING MULTIPLE LOCKS FOR DATA SET MEMBERS IN A DATA SET INDEX - Provided are a computer program product, system, and method for managing multiple locks for data set members in a data set index. The data set index has leaf nodes and internal nodes. In response to determining that a current lock is set at a locked node that prevents a grant to a requested lock, a determination is made as to whether there are different first and second descendant nodes from the locked node at a same level of the tree data structure linked to the requested data set member and the locked data set member, respectively. If so, the requested lock for the requested data set member is set at the first descendant node, the current lock is moved to the second descendant node for the locked data set member and the requested lock is granted. | 03-31-2016 |
| 20160098438 | Managing Write Accesses During Database Upgrade Procedure - As part of an upgrade procedure transitioning from a source system to a target system, table entries used by both the source system and the target system can be selectively locked on a row-by-row basis using a lock table and one or more select triggers. Related apparatus, systems, techniques and articles are also described. | 04-07-2016 |
| 20160154817 | Versioned File System with Global Lock | 06-02-2016 |
| 20160162532 | DIGITAL CONTENT AGGREGATION FROM MULTIPLE SOURCES - Embodiments are directed to aggregating content from a plurality of sources and to applying exclusive locks to portions of content on distributed systems. In one scenario, a computer system accesses content from at least two different content sources. The computer system validates the accessed content and determines that the accessed portions of content are related to at least one version of a specified item. This specified item is to be presented in a user interface along with the accessed portions of content from the at least two different content sources. The computer system then merges the accessed portions of content into an aggregated representation of the specified item which is displayable in the user interface. | 06-09-2016 |
| 20160179865 | METHOD AND SYSTEM FOR CONCURRENCY CONTROL IN LOG-STRUCTURED MERGE DATA STORES | 06-23-2016 |
| 20160253353 | INDEX RECORD-LEVEL LOCKING FOR RECORD-ORIENTED FILE SYSTEMS | 09-01-2016 |
| 20160253370 | HYPERLINK-INDUCED TOPIC SEARCH ALGORITHM LOCK ANALYSIS | 09-01-2016 |
| 20160253371 | ACCESSING DATA ENTITIES | 09-01-2016 |
| 20160253375 | TRANSACTION PROCESSING SYSTEM, METHOD AND PROGRAM | 09-01-2016 |
| 20160378783 | QUERY PROCESSING USING A DIMENSION TABLE IMPLEMENTED AS DECOMPRESSION DICTIONARIES - According to one embodiment of the present invention, a system may execute database queries and may comprise a computer system including at least one processor. The system may select a column of a first table as a candidate column for creating a dictionary, create tokens for a foreign key in a second table that corresponds to a primary key in the first table, generate the dictionary for the selected column using the created tokens as indexes in the dictionary and modify a query accessing the column of the first table to retrieve column values based on the dictionary. Embodiments of the present invention further include a method and computer program product executing database queries in substantially the same manner described above. | 12-29-2016 |
| 20170235780 | PROVIDING LOCK-BASED ACCESS TO NODES IN A CONCURRENT LINKED LIST | 08-17-2017 |
