公开(公告)号：US11914996B2

公开(公告)日：2024-02-27

申请号：US17817854

申请日：2022-08-05

Applicant: Oracle International Corporation

Inventor： David Dice ,  Alex Kogan

IPC: G06F12/00 ,  G06F9/30 ,  G06F12/0802 ,  G06F9/52 ,  G06F13/16 ,  G06F9/38

CPC classification number: G06F9/3009 ,  G06F9/3802 ,  G06F9/52 ,  G06F9/526 ,  G06F12/0802 ,  G06F13/1663 ,  G06F13/1689 ,  G06F2212/60

Abstract: A computer comprising one or more processors and memory may implement multiple threads that perform a lock operation using a data structure comprising an allocation field and a grant field. Upon entry to a lock operation, a thread allocates a ticket by atomically copying a ticket value contained in the allocation field and incrementing the allocation field. The thread compares the allocated ticket to the grant field. If they are unequal, the thread determines a number of waiting threads. If the number is above the threshold, the thread enters a long term wait operation comprising determining a location for long term wait value and waiting on changes to that value. If the number is below the threshold or the long term wait operation is complete, the thread waits for the grant value to equal the ticket to indicate that the lock is allocated.

公开(公告)号：US20230401113A1

公开(公告)日：2023-12-14

申请号：US18365880

申请日：2023-08-04

Applicant: Oracle International Corporation

Inventor： David Dice ,  Virendra J. Marathe

IPC: G06F9/52 ,  G06F9/46 ,  G06F16/176 ,  G06F16/23

CPC classification number: G06F9/526 ,  G06F9/468 ,  G06F16/1774 ,  G06F13/1605 ,  G06F16/2343 ,  G06F16/1767 ,  G06F9/52 ,  G06F16/176

Abstract: NUMA-aware reader-writer locks may leverage lock cohorting techniques that introduce a synthetic level into the lock hierarchy (e.g., one whose nodes do not correspond to the system topology). The synthetic level may include a global reader lock and a global writer lock. A writer thread may acquire a node-level writer lock, then the global writer lock, and then the top-level lock, after which it may access a critical section protected by the lock. The writer may release the lock (if an upper bound on consecutive writers has been met), or may pass the lock to another writer (on the same node or a different node, according to a fairness policy). A reader may acquire the global reader lock (whether or not node-level reader locks are present), and then the top-level lock. However, readers may only hold these locks long enough to increment reader counts associated with them.

公开(公告)号：US11809917B2

公开(公告)日：2023-11-07

申请号：US16723766

申请日：2019-12-20

Applicant: Oracle International Corporation

Inventor： David Dice ,  Timothy L. Harris ,  Alex Kogan ,  Yosef Lev ,  Mark S. Moir

IPC: G06F9/46 ,  G06F9/52 ,  G06F9/38 ,  G06F9/30

CPC classification number: G06F9/526 ,  G06F9/30087 ,  G06F9/3851 ,  G06F9/467

Abstract: Transactional Lock Elision allows hardware transactions to execute unmodified critical sections protected by the same lock concurrently, by subscribing to the lock and verifying that it is available before committing the transaction. A “lazy subscription” optimization, which delays lock subscription, can potentially cause behavior that cannot occur when the critical sections are executed under the lock. Hardware extensions may provide mechanisms to ensure that lazy subscriptions are safe (e.g., that they result in correct behavior). Prior to executing a critical section transactionally, its lock and subscription code may be identified (e.g., by writing their locations to special registers). Prior to committing the transaction, the thread executing the critical section may verify that the correct lock was correctly subscribed to. If not, or if locations identified by the special registers have been modified, the transaction may be aborted. Nested critical sections associated with different lock types may invoke different subscription code.

公开(公告)号：US11726838B2

公开(公告)日：2023-08-15

申请号：US17547505

申请日：2021-12-10

Applicant: Oracle International Corporation

Inventor： David Dice ,  Alex Kogan

IPC: G06F9/50 ,  G06F9/52

CPC classification number: G06F9/52 ,  G06F9/5022 ,  G06F9/524

Abstract: Generic Concurrency Restriction (GCR) may divide a set of threads waiting to acquire a lock into two sets: an active set currently able to contend for the lock, and a passive set waiting for an opportunity to join the active set and contend for the lock. The number of threads in the active set may be limited to a predefined maximum or even a single thread. Generic Concurrency Restriction may be implemented as a wrapper around an existing lock implementation. Generic Concurrency Restriction may, in some embodiments, be unfair (e.g., to some threads) over the short term, but may improve the overall throughput of the underlying multithreaded application via passivation of a portion of the waiting threads.

公开(公告)号：US11636152B2

公开(公告)日：2023-04-25

申请号：US16407007

申请日：2019-05-08

Applicant: Oracle International Corporation

Inventor： Alex Kogan ,  David Dice ,  Shady Alaaeldin Mohamed Abdelkader Rabie Issa

IPC: G06F16/901 ,  G06F11/30 ,  G06F16/176

Abstract: A computer comprising one or more processors and memory may implement multiple threads performing mutually exclusive lock acquisition operations on disjoint ranges of a shared resource each using atomic compare and swap (CAS) operations. A linked list of currently locked ranges is maintained and, upon entry to a lock acquisition operation, a thread waits for all locked ranges overlapping the desired range to be released then inserts a descriptor for the desired range into the linked list using a single CAS operation. To release a locked range, a thread executes a single fetch and add (FAA) operation. The operation may be extended to support simultaneous exclusive and non-exclusive access by allowing overlapping ranges to be locked for non-exclusive access and by performing an additional validation after locking to provide conflict resolution should a conflict be detected.

公开(公告)号：US11442871B2

公开(公告)日：2022-09-13

申请号：US17079361

申请日：2020-10-23

Applicant: Oracle International Corporation

Inventor： Yosef Lev ,  David Dice ,  Daniel McNaught Jordan

IPC: G06F12/122 ,  G06F12/123 ,  G06F16/901 ,  G06F9/50 ,  G06F9/52

Abstract: A remove operation and an add-to-front operation may be currently performed with respect to nodes in an Least Recently Used (LRU) queue. A remove operation for a node may proceed if a lock can be obtained on the node to be removed and a predecessor node. During the remove operation, an add-to-front operation may proceed if a lock can be obtained on a dummy node that precedes the current front node of the LRU queue.

公开(公告)号：US20220245217A1

公开(公告)日：2022-08-04

申请号：US17586629

申请日：2022-01-27

Applicant: Oracle International Corporation

Inventor： Alex Kogan ,  David Dice

IPC: G06F17/16

Abstract: Adaptive selection of source matrix version for matrix multiply operations may be performed. Different versions of a matrix used in a matrix multiply operation, such as a transposed matrix and non-transposed matrix, may be selected and used when a matrix multiply operation is performed. The selection may be based on a performance profile that is identified for the matrix multiply operation.

公开(公告)号：US20220138022A1

公开(公告)日：2022-05-05

申请号：US17245820

申请日：2021-04-30

Applicant: Oracle International Corporation

Inventor： David Dice ,  Alex Kogan

IPC: G06F9/52 ,  G06F9/30 ,  G06F9/50 ,  G06F9/54

Abstract: A computer including multiple processors and memory implements a managed runtime providing a synchronization application programming interface (API) for threads that perform synchronized accesses to shared objects. A standardized header of objects includes a memory word storing an object identifier. To lock the object for synchronized access, the memory word may be converted to store the tail of a linked list of a first-in-first-out synchronization structures for threads waiting to acquire the lock, with the object identifier relocated to the list structure. The list structure may further include a stack of threads waiting on events related to the object, with the synchronization API additionally providing wait, notify and related synchronization operations. Upon determining that no threads hold or desire to hold the lock for the object and that no threads are waiting on events related to the object, the memory word may be restored to contain the object identifier.

公开(公告)号：US20210287716A1

公开(公告)日：2021-09-16

申请号：US17337891

申请日：2021-06-03

Applicant: Oracle International Corporation

Inventor： Alex Kogan ,  David Dice

IPC: G11B20/10 ,  G11C16/26 ,  G06F16/23 ,  G06F9/52

Abstract: A reader of a set of data accessors that includes readers and writer detects that a particular lock of a first collection of non-global locks associated with a data object of a computing environment is held by another accessor. After checking a blocking indicator, the reader uses a second lock (which is not part of the first collection) to obtain read access to the data object and implements its reads without acquiring the particular lock. Prior to implementing a write on the data object, a writer acquires at least some locks of the first collection, and sets the blocking indicator to prevent readers from using the second lock to obtain read access to the data object.

公开(公告)号：US20210224140A1

公开(公告)日：2021-07-22

申请号：US17200610

申请日：2021-03-12

Applicant: Oracle International Corporation

Inventor： Alex Kogan ,  David Dice

IPC: G06F9/52

Abstract: A computer comprising multiple processors and non-uniform memory implements multiple threads that perform a lock operation using a shared lock structure that includes a pointer to a tail of a first-in-first-out (FIFO) queue of threads waiting to acquire the lock. To acquire the lock, a thread allocates and appends a data structure to the FIFO queue. The lock is released by selecting and notifying a waiting thread to which control is transferred, with the thread selected executing on the same processor socket as the thread controlling the lock. A secondary queue of threads is managed for threads deferred during the selection process and maintained within the data structures of the waiting threads such that no memory is required within the lock structure. If no threads executing on the same processor socket are waiting for the lock, entries in the secondary queue are transferred to the FIFO queue preserving FIFO order.