Search Images Maps Play YouTube News Gmail Drive More »
Sign in
Screen reader users: click this link for accessible mode. Accessible mode has the same essential features but works better with your reader.

Patents

  1. Advanced Patent Search
Publication numberUS20080021934 A1
Publication typeApplication
Application numberUS 11/477,848
Publication dateJan 24, 2008
Filing dateJun 29, 2006
Priority dateJun 29, 2006
Also published asUS7542977
Publication number11477848, 477848, US 2008/0021934 A1, US 2008/021934 A1, US 20080021934 A1, US 20080021934A1, US 2008021934 A1, US 2008021934A1, US-A1-20080021934, US-A1-2008021934, US2008/0021934A1, US2008/021934A1, US20080021934 A1, US20080021934A1, US2008021934 A1, US2008021934A1
InventorsRichard L. Hudson, Ali-Reza Adl-Tabatabai, Bratin Saha
Original AssigneeHudson Richard L, Ali-Reza Adl-Tabatabai, Bratin Saha
Export CitationBiBTeX, EndNote, RefMan
External Links: USPTO, USPTO Assignment, Espacenet
Transactional memory with automatic object versioning
US 20080021934 A1
Abstract
Embodiments of a system and method for transactional memory (TM) with automatic object versioning are described. Embodiments described herein include a TM system and method that facilitates the execution of object-oriented application programs in a transactional environment, including automatically versioning objects to enhance efficiency. Embodiments of the TM automatically designate versions of objects using pointers, accurately identifying usable and unusable versions. Object versioning as described herein allows the garbage collector to easily and efficiently determine which objects may be moved, freeing memory space and reducing the number of objects traversed by a transaction before finding a useable version of an object. Other embodiments are described and claimed.
Images(7)
Previous page
Next page
Claims(20)
1. A transactional memory (TM) method comprising:
determining a version of an object; and
automatically indicating the version of the object, wherein indicating comprises modifying at least one pointer associated with the object.
2. The method of claim 1, wherein the version comprises an old version, a speculative version, and a definitive version.
3. The method of claim 2, further comprising indicating a definitive version by modifying one of the at least one pointers to point to the object itself.
4. The method of claim 1, further comprising:
a transaction T1 seeking to access the object traversing forward pointers associated with the object; and
reading a transaction descriptor pointed to by the at least one pointer.
5. The method of claim 4, further comprising reading a transaction descriptor pointed to by the at least one pointer to determine:
whether the at least one pointer includes a self-referential pointer, indicating that the object is a definitive version of the object; and
whether the object is a speculative version of the object.
6. The method of claim 5, further comprising, if the object is a speculative version of the object, determining whether the speculative version of the object includes a pointer to a T1 transaction descriptor or a T2 transaction descriptor associated with a transaction T2 that is different from transaction T1.
7. The method of claim 6, further comprising:
if the speculative version of the object includes a pointer to a T2 transaction descriptor, determining that there is contention; and
executing a contention strategy.
8. The method of claim 7, further comprising executing a non-blocking contention strategy, the strategy comprising:
determining whether transaction T2 is active;
if T2 is active, completing T2 in a manner based on a character of T2; and
modifying the one of the at least one pointers to the at least one speculative version of the object to reflect a correct version of the object, comprising modifying to indicate the speculative version of the object is currently a definitive version of the object.
9. A transactional memory (TM) system, comprising:
a virtual machine to execute code contained in class files; and
a TM implementation coupled to the virtual machine to facilitate execution of the code in a transactional environment, wherein the TM automatically indicates a version of an object.
10. The system of claim 9, wherein the TM implementation further determines whether an object is an old version, a speculative version, or a definitive version, and modifies a pointer to the object to indicate a version of the object.
11. The system of claim 9, wherein the TM implementation further:
facilitates a transaction seeking to access an object to traverse pointers associates with the object; and
reads a transaction descriptor pointed to by one of the pointers, wherein the transaction descriptor indicates whether the version of the object is definitive or speculative.
12. The system of claim 9, wherein the TM implementation further:
facilitates a transaction seeking to access an object to traverse pointers associates with the object;
read a transaction descriptor pointed to by one of the pointers, wherein the reads descriptor indicates whether contention exists; and
if contention exists, executes a contention strategy, and modifies the pointer to indicate a current version of the object.
13. The system of claim 9, wherein the TM implementation further:
facilitates a transaction seeking to access an object to traverse pointers associates with the object;
reads a transaction descriptor pointed to by one of the pointers, wherein the transaction descriptor indicates whether the version of the object is definitive or speculative;
if the version of the object is definitive, determines whether the transaction includes a read operation or a write operation.
14. The system of claim 13, wherein:
if the transaction includes a read operation, the TM adds the definitive object to a read set of the transaction; and
if the transaction includes a read operation or a write operation, the TM creates a new, speculative version of the object for the transaction to write, and automatically installs a pointer to the speculative version in the definitive version.
15. A computer-readable medium having stored thereon instructions which when executed in a system cause the system to perform a method, the method comprising:
facilitating execution of object-oriented software application code in a transactional environment, comprising,
traversing forwarding pointers associated with an object that a transaction seeks to access;
reading a transaction descriptor pointed to by one of the pointers;
determining a version of the object, wherein versions comprise an old version, a speculative version, and a definitive version; and
indicating the version of the object.
16. The medium of claim 15, wherein indicating the version of the object comprises facilitating identification of unusable versions by a garbage collector.
17. The medium of claim 15, wherein indicating a version of the object comprises modifying a pointer associated with the object.
18. The medium of claim 15, wherein the method further comprises:
determining whether a pointer to the transaction descriptor is a self-referential pointer; and
determining whether a pointer that is not a self-referential pointer points to a transaction descriptor that is associated with the transaction or with another transaction.
19. The medium of claim 18, wherein the method further comprises:
determining whether there is contention for the object among transactions;
executing a contention strategy; and
modifying at least one pointer after execution of the contention strategy.
20. The medium of claim 19, wherein the contention strategy comprises a non-blocking contention strategy that comprises taking actions to make it possible for the transaction to proceed.
Description
    FIELD OF THE INVENTION
  • [0001]
    Embodiments are in the field of transactional memory (TM), and particularly in the field of garbage collection in TM environments.
  • BACKGROUND OF THE DISCLOSURE
  • [0002]
    Computer systems and applications continually evolve to be ever more complex and capable. Even fairly inexpensive portable personal computer systems are routinely expected to support video application, for example. As a result, there is constant pressure on computer hardware and software developers to support increased capability and speed in systems that are affordable and relatively small. One of the responses to this pressure is central processing units (CPUs) with multiple processing cores that perform parallel processing. Parallel processing involves resource sharing among the multiple cores. Handling memory sharing is a significant challenge. For example, consider a situation in which one processing thread modifies the contents of a portion of memory for later use. Before the processing thread uses the modified contents, another processing thread might overwrites the portion of memory resulting in a loss of consistency between the memory locations. If the contents are not consistent a significant delay, or an error, results. Therefore, software mechanisms for multi-core processors and parallel processing have been developed.
  • [0003]
    One software mechanisms suitable for parallel processing is transactional memory (TM). TM is a concurrency control mechanism analogous to database transactions for controlling access to shared memory in multi-core computing. TM functions as an alternative to lock-based synchronization, and is typically implemented in a lock-free way. A transaction in this context is a piece of code that executes a series of reads and writes to shared memory. These reads and writes logically occur at a single instant in time, and intermediate states are not visible to other (successful) transactions. One can implement transactional memory either in software or hardware or a combination of the two. Software transactional memory (STM) may be semantically richer while hardware transactional memory (HTM) may have higher performance.
  • [0004]
    Many popular programming languages are object-oriented languages, such as Java. Object-oriented languages allow for application development in the context of heterogeneous, network-wide, distributed environments. Object-oriented languages may include automatic memory storage management to take over the burden of memory management from the programmer. One way this is accomplished is by using a garbage collector. Current TM systems and methods (referred to herein simply as TMs) may not be adapted to take advantage of all of the efficiencies that object-oriented applications are capable of. For example, current TMs may not efficiently maintain multiple version of objects, where some are speculative, some are definitive, and some are unreachable and therefore garbage. The indirection inherent in object-based garbage collection schemes may provide a mechanism for efficiently identifying and maintaining the various versions of objects, thus improving both memory management as well as the TM mechanisms.
  • BRIEF DESCRIPTION OF THE DRAWINGS
  • [0005]
    FIG. 1 is a block diagram of elements of a system, including a transactional memory implementation (TM), according to an embodiment.
  • [0006]
    FIG. 2 is a block diagram of an object and a pointer, according to an embodiment.
  • [0007]
    FIG. 3 is a block diagram of objects, illustrating a case in which there is more than one version of an object, according to an embodiment.
  • [0008]
    FIG. 4 is a block diagram of versions of an object during a transaction, according to an embodiment.
  • [0009]
    FIG. 5 is a block diagram of versions of an object after cleanup, according to an embodiment.
  • [0010]
    FIG. 6 is a block diagram illustrating path compression as performed by the garbage collector using pointers, according to an embodiment.
  • [0011]
    FIGS. 7 and 8 are a flow diagram of a method for object versioning, according to an embodiment.
  • DETAILED DESCRIPTION
  • [0012]
    Embodiments described herein include a transactional memory system and method (TM) that facilitates the execution of object-oriented application programs in a transactional environment, including automatically versioning objects to enhance efficiency. Embodiments of the TM automatically designate versions of objects as further described below. Object versioning as described herein allows a garbage collector to easily and efficiently determine which objects may be moved by the garbage collector, freeing memory space and reducing the number of objects traversed by a transaction before finding a useable version of an object.
  • [0013]
    FIG. 1 is a block diagram of elements of a system 100, including a transactional memory implementation (TM) 112, according to an embodiment. The system 100 is equipped to interpret and compile class files from an object oriented language, such as Java, for example. The system 100 includes computer hardware 104 controlled by an operating system 116. The computer hardware 104 further includes a memory device 118 and machine registers 120. The system 100 also includes a virtual machine (VM) implementation 110 for executing object-oriented code contained in class files 124. In an embodiment, the VM implementation 110 is a Java virtual machine (JVM) and the object-oriented code is Java code, but embodiments are not so limited. The virtual machine (VM) implementation 110 includes a garbage collector 114, and a TM 112.
  • [0014]
    When class filed 124 are downloaded during operation of the system 100, an interpreter 108 may begin interpreting the class files 124 such that the object-oriented code is executed. Alternatively, a just-in-time compiler (JIT) 106 may compile the class files 124 and generate compiled code 122 in the form of native processor code. The compiled code 122 may be directly executed by computer hardware 104. In order to maintain the state of the VM 110 and to make system calls, compiled code 122 may make calls 130 into VM 110. Likewise VM 110 makes calls 130 to compiled code 122 to cause it to execute on the computer hardware 104. The TM 112, as further described below, facilitates the execution of the code in a transactional environment.
  • [0015]
    An object, as referred to herein, is a collection of contiguous memory locations, lying in a single region that can be addressed and accessed via references. A reference, also called a pointer, is the address of an object. Objects do not overlap and may be relocated independently of one another by the garbage collector. In some cases, an object may correspond to a Java object. An object may contain slots, non-slot data, or both. A slot is a memory location that may contain a reference (pointer) to an object. A slot may also refer to no object, that is, it may contain the null pointer.
  • [0016]
    In an embodiment, the TM 112 automatically designates versions of objects, such that the versions are easily identifiable as old, speculative, or definitive. The identification is useful to transactions seeking to access an object, because embodiments eliminate the need to traverse several unusable versions before finding a version the transaction can use. In addition, embodiments make it easy for an existing garbage collector to clean up unusable object versions and free the memory space they occupy.
  • [0017]
    In an embodiment, the TM 112 is non-blocking. For example, if a transaction T1 detects a conflict (also referred to as contention) with another transaction T2, T1 can decide to either: 1) back off and let T2 continue; or 2) abort T2 and cleanup enough of T2's state so that T1 can continue execution. In other embodiments, a blocking TM 112 scheme may be employed.
  • [0018]
    In an embodiment, the TM 112 works at the granularity of objects, but embodiments are not so limited. In an embodiment, the TM 112 is implemented in Java, but could be implemented in any other suitable language. A Java virtual machine (JVM) and just-in-time compiler (JIT) can use embodiments to provide transactional semantics automatically for existing types in an application program. Embodiments increase the efficiency of object-oriented application programs using TM 112 by removing the indirection inherent in object-oriented schemes.
  • [0019]
    In an embodiment, object versioning is applied to allow optimistic concurrency. At any point in time several versions of the same object may exist, but only one definitive version represents the most up-to-date non-speculative globally visible version of the object. A transaction that writes to an object creates a new, speculative version of the object. The speculative version is a clone of the definitive version of the object. When the speculative version of the object is successfully committed, the transaction automatically makes the speculative version of the object the definitive version. In other embodiments, pessimistic schemes are implemented.
  • [0020]
    Each transaction has a transaction descriptor (also referred to as a descriptor) object that tracks the state of the transaction and maintains the read and write sets of the transaction. States of the transaction may include “active”, “aborted”, and “committed”. The read and write sets contain references to the object versions that the transaction has read or written, respectively.
  • [0021]
    FIG. 2 is a block diagram of an object and a pointer according to an embodiment. A slot 204 holds a pointer (PNTR) to an object 202. The slot 204 can be in another object on the heap, in a globally accessible location, on a stack, or in a register. In an embodiment, the pointer points to the first word in the object 202. The virtual machine, such as the VM 110 adds a forwarding pointer to each object. This illustrates a typical case involving only one object. The forwarding pointer shown by arrow 206 is a self-referential pointer that transitively refers to the definitive version of the object 202. Alternatively the field may hold information, possibly using distinguished bits, that distinguishes what the slot holds. In general in the embodiments described, a transaction seeking to access objects traverses forwarding pointers associated with the object to find a usable version of the object. As will be further described below, the transaction further modifies forwarding pointers to reflect a current version of an object, for example, based on the transaction.
  • [0022]
    FIG. 3 is a block diagram illustrating a case in which there is more than one version of an object, specifically an old version 308 and a definitive version 302. A pointer in a slot 304 refers to the old version 308, which in turn refers to the definitive version 302. The definitive version 302 of the object includes a self-referential forwarding pointer shown by arrow 306. There may be multiple older versions, forming a list of versions threaded through the forwarding pointer.
  • [0023]
    When a transaction creates a speculative version “S”, the transaction sets the forwarding pointer of S to point to a transaction descriptor associated with S. This is illustrated in FIG. 4, which is a block diagram of versions of an object during a transaction, including a speculative version of an object. In FIG. 4, a slot 404 holds a pointer to the definitive version 408, which in turn holds a pointer to a speculative version 401. The speculative version 401 holds a pointer, placed in the version 401 by the transaction, to its transaction descriptor 403.
  • [0024]
    Upon committing, the transaction makes the forwarding pointer of any speculative versions it created self-referential so that these versions become definitive versions, resulting in the situation of FIG. 3. The previous definitive version becomes an old version.
  • [0025]
    Upon aborting, a transaction cleans up by making the forwarding pointers of any definitive version in its write set self-referential if it points to a speculative version that the transaction created. This situation is illustrated in FIG. 5, which is a block diagram of versions of an object after cleanup. A slot 504 holds a pointer to a definitive version 502, which includes a self-referential pointer as shown by arrow 506. A version 510 holds a pointer to a transaction descriptor. Version 510 is now unreachable because there are no pointers to it. Therefore, version 510 is now garbage and is subject to reclamation by the garbage collector. Version 502 was previously a definitive version of an object in the write set of the transaction, and previously pointed to a speculative version (now garbage) 510. Because the transaction made the version 502 pointer self-referential, the unusable version 510 becomes garbage, and the memory occupied by version 510 can be made available again.
  • [0026]
    In an embodiment, during its normal heap traversal, the garbage collector performs path compression by updating references that point to an old version so that they point to definitive versions. FIG. 6 is a block diagram illustrating path compression as performed by the garbage collector using the pointers as modified by the transaction. A slot 604 holds a pointer to a definitive version 602, as illustrated by an arrow 607. In an embodiment, the garbage collector recognizes the definitive version 602 by its self-referential pointer (shown by an arrow 606) and updates references (pointers) accordingly. Previously, the slot 604 held a pointer to an old version 610, which is now garbage, because it is not referred to. Version 610 is thus made available for reclamation by the garbage collector.
  • [0027]
    In various situations, an object can have multiple speculative versions. Each speculative version holds a pointer with a transaction descriptor associated with the “owner” transaction. When transaction T1 is committed, the speculative object belonging to T1 becomes the definitive version of the object.
  • [0028]
    The state of a speculative object “S” that points to a transaction descriptor “T” (as shown in FIG. 4, for example) depends on the state of T. There are typically three states to consider: T is aborted; T is committed; or T is active. If T is active, then object S is a speculative version. Depending on whether T commits or aborts, S may become either the definitive object or a garbage object.
  • [0029]
    Consider the transaction T1 seeking to access an object “O”. Before accessing the object O's field, the transaction T1 must first perform an OpenForRead operation or an OpenForWrite operation. These operations return a version of the object suitable for reading or writing, respectively. An open operation first traverses the forwarding pointers until it finds either a definitive object or a speculative object pointing to a transaction descriptor. Various cases may be encountered. FIGS. 7 and 8 are a flow diagram of a method for object versioning, according to an embodiment. The method includes accessing an object, including handling the various cases, according to a TM embodiment.
  • [0030]
    Referring first to FIG. 7, a method 700 begins with a transaction T1 traversing forwarding pointers of an object O at 702. T1 determines, at 704, whether it encounters a forwarding pointer that is self-referential (indicating a definitive object), or a pointer to a transaction descriptor. If T1 encounters neither, it continues traversing at 702. If T1 does encounter a self-referential forwarding pointer or a pointer to a transaction descriptor, there are, in general, three cases to consider. The first case is the case of the self-referential pointer, which indicates a definitive object. The second case is the case of a pointer of a speculative object which points to a transaction descriptor belonging to T1. The third case is the case of a pointer of a speculative object which points to a transaction descriptor belonging to a different transaction, T2. Each of the cases will be described with reference to FIGS. 7 and 8. The first case will be described with reference to a method 700A in FIG. 8. First, however, the other second and third cases will be described with further reference to FIG. 7.
  • [0031]
    If a pointer of a speculative object which points to a transaction descriptor is encountered, it is determined at 706 whether the transaction descriptor belongs to T1 or to another transaction T2. If the transaction descriptor belongs to T1, an OpenForRead operation or OpenForWrite operation, as applicable, is initiated at 708 and a speculative version of the object is returned for reading or writing at 710.
  • [0032]
    If the transaction descriptor belongs to T2, it is then determined at 712 whether T2 is active. If T2 is active, it indicates that there is contention for the object among transactions T1 and T2. According to embodiments as described herein, any contention strategy may be executed upon encountering contention. In the particular example of FIGS. 7 and 8, a non-blocking contention strategy is illustrated that includes taking actions to make it possible for the transaction to proceed, but embodiments are not so limited.
  • [0033]
    In an embodiment, if transaction T2 is active, T2 is completed in a manner based on the character of T2, as further described below. If T2 is active, it is determined at 720 whether the operation is an OpenForRead operation. If the operation is an OpenForRead operation, the operation proceeds with the definitive object O (which points to a speculative version S) of the object O at 722. While committing the transaction at 724, a check is made to determine whether O is still the definitive version.
  • [0034]
    If the operation is not an OpenForRead operation, as determined at 720, T2 is aborted and cleanup is performed at 728, including modifying the forwarding pointer of the object pointing to speculative object S such that the pointer becomes self-referential and the object becomes definitive. Alternatively (not shown), if the operation is an OpenForRead operation, as determined at 720, could abort T2 and perform cleanup at 728, including modifying the forwarding pointer of the object pointing to speculative object S such that the pointer becomes self-referential and the object becomes definitive. T1 could then use the definitive object O for reading.
  • [0035]
    If the operation is an OpenForWrite then T1 may either abort itself, proceed with its own speculative version, abort T2, or wait for T2 to complete before proceeding. If T1 aborts itself then T2 may be allowed to continue unimpeded. T1 may create its own speculative version and proceed with that version. Before committing T1 may need to validate that object O is still the definitive object version. Upon commit T1 may eagerly abort or may lazily allow T2 to discover that T2 needs to abort. If T1 aborts T2 it may adjust T2's transaction descriptor to indicate the abort. T1 may then create its own speculative version S of object O referring to T1 's transaction descriptor and proceed using the newly created speculative version of the object.
  • [0036]
    Returning to 712, if T2 is not active, it is determined at 714 whether T2 is aborted, which would indicate that T2's speculative version S is garbage. If T2 is committed, T1 “helps out” and makes version S self-referential, or definitive, by modifying S's pointer. If T2 is aborted, T1 makes object O self-referential, or definitive, by modifying its pointer.
  • [0037]
    Returning to 704, if a self-referential pointer is encountered during T1's traversal, the operation continues with method 700A as illustrated in FIG. 8. With reference to 728, it is determined whether the operation is an OpenForRead operation or and OpenForWrite operation. If the operation is an OpenForRead operation, the definitive object, as may be identified by a self-referential pointer, is added to the read set of T1 at 730, and the definitive version is returned for reading at 732.
  • [0038]
    If the operation is an OpenForWrite operation, a new speculative version of the object is created for writing by T1 at 734. A pointer to the speculative version is installed in the definitive object at 736. The definitive version is added to the write set of T1 at 738, and the speculative version is returned for writing at 740.
  • [0039]
    Aspects of the methods and systems described herein may be implemented as functionality programmed into any of a variety of circuitry, including programmable logic devices (“PLDs”), such as field programmable gate arrays (“FPGAs”), programmable array logic (“PAL”) devices, electrically programmable logic and memory devices and standard cell-based devices, as well as application specific integrated circuits. Implementations may also include microcontrollers with memory (such as EEPROM), embedded microprocessors, firmware, software, etc. Furthermore, aspects may be embodied in microprocessors having software-based circuit emulation, discrete logic (sequential and combinatorial), custom devices, fuzzy (neural) logic, quantum devices, and hybrids of any of the above device types. Of course the underlying device technologies may be provided in a variety of component types, e.g., metal-oxide semiconductor field-effect transistor (“MOSFET”) technologies like complementary metal-oxide semiconductor (“CMOS”), bipolar technologies like emitter-coupled logic (“ECL”), polymer technologies (e.g., silicon-conjugated polymer and metal-conjugated polymer-metal structures), mixed analog and digital, etc.
  • [0040]
    The term “processor” as generally used herein refers to any logic processing unit, such as one or more central processing units (“CPU”), digital signal processors (“DSP”), application-specific integrated circuits (“ASIC”), etc. While the term “component” is generally used herein, it is understood that “component” includes circuitry, components, modules, and/or any combination of circuitry, components, and/or modules as the terms are known in the art.
  • [0041]
    The various components and/or functions disclosed herein may be described using any number of combinations of hardware, firmware, and/or as data and/or instructions embodied in various machine-readable or computer-readable media, in terms of their behavioral, register transfer, logic component, and/or other characteristics. Computer-readable media in which such formatted data and/or instructions may be embodied include, but are not limited to, non-volatile storage media in various forms (e.g., optical, magnetic or semiconductor storage media) and carrier waves that may be used to transfer such formatted data and/or instructions through wireless, optical, or wired signaling media or any combination thereof. Examples of transfers of such formatted data and/or instructions by carrier waves include, but are not limited to, transfers (uploads, downloads, e-mail, etc.) over the Internet and/or other computer networks via one or more data transfer protocols.
  • [0042]
    Unless the context clearly requires otherwise, throughout the description and the claims, the words “comprise,” “comprising,” and the like are to be construed in an inclusive sense as opposed to an exclusive or exhaustive sense; that is to say, in a sense of “including, but not limited to.” Words using the singular or plural number also include the plural or singular number respectively. Additionally, the words “herein,” “hereunder,” “above,” “below,” and words of similar import refer to this application as a whole and not to any particular portions of this application. When the word “or” is used in reference to a list of two or more items, that word covers all of the following interpretations of the word: any of the items in the list; all of the items in the list; and any combination of the items in the list.
  • [0043]
    The above description of illustrated embodiments is not intended to be exhaustive or limited by the disclosure. While specific embodiments of, and examples for, the systems and methods are described herein for illustrative purposes, various equivalent modifications are possible, as those skilled in the relevant art will recognize. The teachings provided herein may be applied to other systems and methods, and not only for the systems and methods described above. The elements and acts of the various embodiments described above may be combined to provide further embodiments. These and other changes may be made to methods and systems in light of the above detailed description.
  • [0044]
    In general, in the following claims, the terms used should not be construed to be limited to the specific embodiments disclosed in the specification and the claims, but should be construed to include all systems and methods that operate under the claims. Accordingly, the method and systems are not limited by the disclosure, but instead the scope is to be determined entirely by the claims. While certain aspects are presented below in certain claim forms, the inventors contemplate the various aspects in any number of claim forms. Accordingly, the inventors reserve the right to add additional claims after filing the application to pursue such additional claim forms for other aspects as well.
Patent Citations
Cited PatentFiling datePublication dateApplicantTitle
US6223344 *Jun 11, 1998Apr 24, 2001Internationl Business Machines CorporationApparatus and method for versioning persistent objects
US6826757 *Apr 18, 2001Nov 30, 2004Sun Microsystems, Inc.Lock-free implementation of concurrent shared object with dynamic node allocation and distinguishing pointer value
Referenced by
Citing PatentFiling datePublication dateApplicantTitle
US7802136Dec 28, 2006Sep 21, 2010Intel CorporationCompiler technique for efficient register checkpointing to support transaction roll-back
US8001421Aug 13, 2010Aug 16, 2011Intel CorporationCompiler technique for efficient register checkpointing to support transaction roll-back
US8132158Dec 28, 2006Mar 6, 2012Cheng WangMechanism for software transactional memory commit/abort in unmanaged runtime environment
US8161247Jun 26, 2009Apr 17, 2012Microsoft CorporationWait loss synchronization
US8229907Jun 30, 2009Jul 24, 2012Microsoft CorporationHardware accelerated transactional memory system with open nested transactions
US8250331Jun 26, 2009Aug 21, 2012Microsoft CorporationOperating system virtual memory management for hardware transactional memory
US8341133 *Jun 27, 2008Dec 25, 2012Microsoft CorporationCompressed transactional locks in object headers
US8356166Jun 26, 2009Jan 15, 2013Microsoft CorporationMinimizing code duplication in an unbounded transactional memory system by using mode agnostic transactional read and write barriers
US8370577Jun 26, 2009Feb 5, 2013Microsoft CorporationMetaphysically addressed cache metadata
US8397052Aug 19, 2009Mar 12, 2013International Business Machines CorporationVersion pressure feedback mechanisms for speculative versioning caches
US8489864Jun 26, 2009Jul 16, 2013Microsoft CorporationPerforming escape actions in transactions
US8521961Aug 20, 2009Aug 27, 2013International Business Machines CorporationCheckpointing in speculative versioning caches
US8533440Dec 15, 2009Sep 10, 2013Microsoft CorporationAccelerating parallel transactions using cache resident transactions
US8539465Dec 15, 2009Sep 17, 2013Microsoft CorporationAccelerating unbounded memory transactions using nested cache resident transactions
US8589621 *Jul 27, 2011Nov 19, 2013International Business Machines CorporationObject persistency
US8688951Jul 20, 2012Apr 1, 2014Microsoft CorporationOperating system virtual memory management for hardware transactional memory
US8719807Dec 28, 2006May 6, 2014Intel CorporationHandling precompiled binaries in a hardware accelerated software transactional memory system
US8812796Jun 26, 2009Aug 19, 2014Microsoft CorporationPrivate memory regions and coherence optimizations
US8868848Dec 21, 2009Oct 21, 2014Intel CorporationSharing virtual memory-based multi-version data between the heterogenous processors of a computer platform
US8954995Oct 1, 2008Feb 10, 2015Microsoft CorporationArray object concurrency in STM
US9053003 *Jun 21, 2012Jun 9, 2015Microsoft Technology Licensing, LlcMemory compaction mechanism for main memory databases
US9092253Dec 15, 2009Jul 28, 2015Microsoft Technology Licensing, LlcInstrumentation of hardware assisted transactional memory system
US9104628Jan 10, 2015Aug 11, 2015Microsoft Technology Licensing, LlcArray object concurrency in STM
US9239803Aug 10, 2015Jan 19, 2016Microsoft Technology Licensing, LlcArray object concurrency in STM
US9304769May 6, 2014Apr 5, 2016Intel CorporationHandling precompiled binaries in a hardware accelerated software transactional memory system
US9542431Oct 24, 2008Jan 10, 2017Microsoft Technology Licensing, LlcCyclic commit transaction protocol
US9658880Mar 18, 2013May 23, 2017Microsoft Technology Licensing, LlcEfficient garbage collection and exception handling in a hardware accelerated transactional memory system
US9658953Mar 3, 2015May 23, 2017Rambus Inc.Single command, multiple column-operation memory device
US9710396 *Oct 1, 2014Jul 18, 2017Intel CorporationSharing virtual memory-based multi-version data between the heterogeneous processors of a computer platform
US20080162885 *Dec 28, 2006Jul 3, 2008Cheng WangMechanism for software transactional memory commit/abort in unmanaged runtime environment
US20080162886 *Dec 28, 2006Jul 3, 2008Bratin SahaHandling precompiled binaries in a hardware accelerated software transactional memory system
US20090327636 *Jun 27, 2008Dec 31, 2009Microsoft CorporationCompressed transactional locks in object headers
US20100083257 *Oct 1, 2008Apr 1, 2010Microsoft CorporationArray object concurrency in stm
US20100106753 *Oct 24, 2008Apr 29, 2010Microsoft CorporationCyclic commit transaction protocol
US20100306512 *Aug 13, 2010Dec 2, 2010Cheng WangCompiler technique for efficient register checkpointing to support transaction roll-back
US20100332538 *Jun 30, 2009Dec 30, 2010Microsoft CorporationHardware accelerated transactional memory system with open nested transactions
US20100332753 *Jun 26, 2009Dec 30, 2010Microsoft CorporationWait loss synchronization
US20100332771 *Jun 26, 2009Dec 30, 2010Microsoft CorporationPrivate memory regions and coherence optimizations
US20100332807 *Jun 26, 2009Dec 30, 2010Microsoft CorporationPerforming escape actions in transactions
US20100332808 *Jun 26, 2009Dec 30, 2010Microsoft CorporationMinimizing code duplication in an unbounded transactional memory system
US20110047362 *Aug 19, 2009Feb 24, 2011International Business Machines CorporationVersion Pressure Feedback Mechanisms for Speculative Versioning Caches
US20110145498 *Dec 15, 2009Jun 16, 2011Microsoft CorporationInstrumentation of hardware assisted transactional memory system
US20110145553 *Dec 15, 2009Jun 16, 2011Microsoft CorporationAccelerating parallel transactions using cache resident transactions
US20110153957 *Dec 21, 2009Jun 23, 2011Ying GaoSharing virtual memory-based multi-version data between the heterogenous processors of a computer platform
US20120110254 *Jul 27, 2011May 3, 2012International Business Machines CorporationObject persistency
US20120117317 *Jun 17, 2010May 10, 2012Rambus Inc.Atomic memory device
US20130346378 *Jun 21, 2012Dec 26, 2013Microsoft CorporationMemory compaction mechanism for main memory databases
US20150019825 *Oct 1, 2014Jan 15, 2015Ying GaoSharing virtual memory-based multi-version data between the heterogeneous processors of a computer platform
Classifications
U.S. Classification1/1, 707/999.203
International ClassificationG06F17/30
Cooperative ClassificationG06F12/0253, G06F9/467
European ClassificationG06F9/46T2
Legal Events
DateCodeEventDescription
Mar 3, 2009ASAssignment
Owner name: INTEL CORPORATION, CALIFORNIA
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:HUDSON, RICHARD L.;ADL-TABATABAI, ALI-REZA;SAHA, BRATIN;REEL/FRAME:022340/0049;SIGNING DATES FROM 20071217 TO 20080211
Nov 21, 2012FPAYFee payment
Year of fee payment: 4
Jan 13, 2017REMIMaintenance fee reminder mailed
Jun 2, 2017LAPSLapse for failure to pay maintenance fees
Jul 25, 2017FPExpired due to failure to pay maintenance fee
Effective date: 20170602