Source: http://www.google.com/patents/US7451300?dq=6,977,809
Timestamp: 2017-03-24 06:33:23
Document Index: 715536989

Matched Legal Cases: ['arts 400', 'art 400', 'art 500', 'arts 400', 'arts 400', 'arts 400', 'arts 400']

Patent US7451300 - Explicit control of speculation - Google PatentsSearch Images Maps Play YouTube News Gmail Drive More »Sign inPatentsDescribed are methods and systems that allow partial speculation (e.g., speculation within constraints). With partial speculation, after a fault is detected for example, speculation remains enabled for processor registers and other memories private to a microprocessor, while speculation normally permitted...http://www.google.com/patents/US7451300?utm_source=gb-gplus-sharePatent US7451300 - Explicit control of speculationAdvanced Patent SearchTry the new Google Patents, with machine-classified Google Scholar results, and Japanese and South Korean patents.Publication numberUS7451300 B1Publication typeGrantApplication numberUS 10/620,862Publication dateNov 11, 2008Filing dateJul 15, 2003Priority dateJul 15, 2003Fee statusPaidAlso published asUS8078853Publication number10620862, 620862, US 7451300 B1, US 7451300B1, US-B1-7451300, US7451300 B1, US7451300B1InventorsH. Peter Anvin, David DunnOriginal AssigneeTransmeta CorporationExport CitationBiBTeX, EndNote, RefManPatent Citations (4), Non-Patent Citations (5), Referenced by (6), Classifications (8), Legal Events (7) External Links: USPTO, USPTO Assignment, EspacenetExplicit control of speculation
US 7451300 B1Abstract
Described are methods and systems that allow partial speculation (e.g., speculation within constraints). With partial speculation, after a fault is detected for example, speculation remains enabled for processor registers and other memories private to a microprocessor, while speculation normally permitted for certain other operations is suspended. Accordingly, while the fault is dispatched, some speculation is permitted as opposed to suspending all speculation. As such, microcode that makes use of speculation can be written.
1. In a computer system comprising a microprocessor, a method of providing partial speculative operation in lieu of suspending speculation, said method comprising:
operating in a first mode of speculative operation, said first mode permitting speculation of a first set of speculative operations;
experiencing an event during said operating;
in response to said event, restoring a state of said microprocessor to a state committed to memory prior to said event;
subsequent to said restoring, suspending a non-null first subset of said first set of speculative operations, wherein speculative operations in said first subset are not permitted during said suspending; and
exiting said first mode and entering a second mode of speculative operation in response to said event, said second mode permitting speculation of a non-null second subset of said first set, wherein said first subset comprises input/output (I/O) writes, main memory reads, and main memory writes, wherein said first mode permits speculation for handling non-architectural faults, wherein said second subset comprises operations that involve memory that is private to said microprocessor, and wherein said second mode permits speculation for handling architectural faults.
2. The method of claim 1 wherein said second subset comprises speculative operations that are invisible external to said microprocessor.
3. The method of claim 1 wherein said event is selected from the group consisting of a fault, and a direct memory access request.
4. The method of claim 1 further comprising suspending speculative operation in response to a second event.
5. The method of claim 1 further comprising returning to said first mode after said event is handled.
counting the number of instructions executed in said first mode prior to said event; and
returning to said first mode upon executing the same number of instructions after entering said second mode.
7. The method of claim 1 wherein said microprocessor comprises a combination of translation software and host hardware, said translation software running directly on said host hardware, said translation software for interpreting and translating a sequence of non-native instructions into a sequence of native instructions, wherein said interpreting is permitted during said second mode.
8. A method providing partial speculative operation, said method comprising:
executing forward from a speculation boundary representing a memory state of a microprocessor, said executing according to a full speculation mode that permits a set of speculative operations;
experiencing an event during said executing;
rolling back to said speculation boundary and restoring said memory state in response to said event;
subsequent to said rolling back, suspending a non-null first subset of said set of speculative operations, wherein said first subset does not include all of said speculative operations and wherein speculative operations in said first subset are not permitted during said suspending; and
subsequent to said suspending, executing forward from said speculation boundary according to a partial speculation mode that permits a non-null second subset of said set of speculative operations, wherein said partial speculation mode is used in lieu of suspending said set of speculative operations in entirety, wherein said first subset comprises input/output (I/O) writes, main memory reads, and main memory writes, wherein said full speculation mode permits handling non-architectural faults, wherein said second subset comprises operations that involve memory that is private to said microprocessor, and wherein said partial speculation mode permits handling architectural faults.
9. The method of claim 8 wherein said second subset of speculative operations comprises speculative memory operations that are invisible external to said microprocessor.
10. The method of claim 8 wherein said event is selected from the group consisting of a fault, and a direct memory access request.
detecting a second event during operation in said partial speculation mode; and
suspending speculative operation in response to said second event.
handling said event; and
returning to said full speculation mode after said event is handled.
counting the number of instructions executed in said full speculation mode prior to said event;
executing the same number of instructions after entering said partial speculation mode; and
returning to said full speculation mode after executing said same number of instructions.
14. The method of claim 8 wherein said microprocessor comprises a combination of translation software and host hardware, said translation software running directly on said host hardware, said translation software for interpreting and translating a sequence of non-native instructions into a sequence of native instructions, wherein said interpreting is permitted during said partial speculation mode.
a microprocessor coupled to said main memory;
wherein said computer system implements a first mode of speculative operation, a second mode of partial speculative operation, and a third mode in which said speculative operations are suspended in entirety, wherein operation in said first mode permits speculation of a set of speculative operations up to and beyond a commit point at which a state of said microprocessor is committed to memory and wherein operation in said second mode begins after a rollback operation that restores said state, and wherein in said second mode a non-null first subset of said set of speculative operations are suspended leaving enabled a non-null second subset of said set of speculative operations, wherein said first mode permits speculative operations comprising operations that involve memory that is private to said microprocessor, input/output (I/O) writes, main memory reads, and main memory writes, wherein said first mode permits speculation for non-architectural faults, wherein said second mode permits speculative operations comprising operations that is private to said microprocessor, and wherein said second mode permits speculation for handling architectural faults.
16. The computer system of claim 15 wherein said second mode permits speculative operations that are invisible external to said microprocessor.
17. The computer system of claim 15 wherein a transition from said first mode to said second mode occurs in response to an event that is selected from the group consisting of a fault, and a direct memory access request.
18. The computer system of claim 17 wherein a transition back to said first mode occurs after said event is handled.
19. The computer system of claim 17 wherein the number of instructions executed in said first mode prior to said event are counted, wherein a transition back to said first mode occurs after the same number instructions are executed in said second mode.
20. The computer system of claim 15 wherein said microprocessor is a microprocessor comprising a combination of translation software and host hardware, said translation software running directly on said host hardware, said translation software for interpreting and translating a sequence of non-native instructions into a sequence of native instructions, wherein said interpreting is permitted during said second mode. Description
Embodiments of the present invention relate to processors and microprocessors. More specifically, embodiments of the present invention relate to speculative execution of operations.
Speculative execution is known in the art of microprocessors. Should an event occur where speculation is not permitted, speculation is suspended while the event is handled. A fault provides one example of such an event.
When implementing a complex instruction set computer (CISC) instruction set, some operations require the execution of microcode of some sort. Generally, it is desirable for the microcode to have access to the speculation function. However, when speculation is suspended, this will not be the case.
Embodiments of the present invention provide methods and systems that allow partial speculation (e.g., speculation within constraints) in situations where speculation is not conventionally permitted.
FIG. 1 is a block diagram of an example of a computer system architecture that can be used with embodiments of the present invention.
FIG. 2 is a block diagram of another example of a computer system architecture that can be used with embodiments of the present invention.
FIG. 3 illustrates the use of controlled (partial) speculation according to an embodiment of the present invention.
FIG. 4 is a flowchart of a method providing partial speculation according to an embodiment of the present invention.
FIG. 5 is a flowchart of another method providing partial speculation according to an embodiment of the present invention.
It should be borne in mind, however, that all of these and similar terms are to be associated with the appropriate physical quantities and are merely convenient labels applied to these quantities. Unless specifically stated otherwise as apparent from the following discussions, it is appreciated that throughout the present invention, discussions utilizing terms such as “operating,” “exiting,” “entering,” “permitting,” “suspending,” “returning,” “counting,” “experiencing,” “rolling back,” “detecting,” “handling” or the like, refer to the action and processes (e.g., flowcharts 400 and 500 of FIGS. 4 and 5, respectively) of a computer system or similar intelligent electronic computing device, that manipulates and transforms data represented as physical (electronic) quantities within the computer system's registers and memories into other data similarly represented as physical quantities within the computer system memories or registers or other such information storage, transmission or display devices.
Aspects of the present invention may be practiced on a computer system that includes, in general, a central processing unit (CPU) for processing information and instructions, random access (volatile) memory (RAM) for storing information and instructions, read-only (non-volatile) memory (ROM) for storing static information and instructions, a data storage device such as a magnetic or optical disk and disk drive for storing information and instructions, an optional user output device such as a display device (e.g., a monitor) for displaying information to the computer user, an optional user input device including alphanumeric and function keys (e.g., a keyboard) for communicating information and command selections to the processor, and an optional user input device such as a cursor control device (e.g., a mouse) for communicating user input information and command selections to the processor. The computer system may also include a device for providing a physical communication link between the computer system and a network, using either a wired or a wireless communication interface.
FIG. 1 is a block diagram of an example of a computer system 100 that can be used with embodiments of the present invention. In the present embodiment, computer system 100 includes a microprocessor 103 coupled to main memory 101 and to an input/output (I/O) device 106. Main memory 101 functions as the primary workspace of a computer system and can include the operating system software and application software used by the computer system. I/O device 106 can be any of a variety of peripheral devices other than main memory.
FIG. 2 is a block diagram of another example of a computer system 200 that can be used with embodiments of the present invention. Relative to the architecture of FIG. 1, computer system 200 introduces a bus interface 202 and a north bridge 204 between main memory 101, I/O device 106 and microprocessor 103.
Referring to both FIGS. 1 and 2, microprocessor 103 is generally described as a complex instruction set computer (CISC) microprocessor. Microprocessor 103 includes CPU core 105, which includes a CPU register 102. CPU register 102 represents an instance of microprocessor memory that can be referred to as “private memory.” As used herein, private memory refers to memory that is not subject to direct memory access (DMA) and that is hidden from input/output (I/O) bus(es). Private memory also refers to memory that is not observable outside of the microprocessor 103, either physically or logically. There can also be instances of private memory other than or in addition to CPU register 102.
It is appreciated that computer systems 100 and 200 can include additional components as described above, and that there can be paths between components different from or in addition to the paths illustrated in FIGS. 1 and 2.
An I/O interface boundary is represented in FIGS. 1 and 2. The position of the I/O interface boundary can be different than that shown. The I/O interface boundary is used here as an abstraction, to illustrate that a memory operation that results in the I/O interface boundary being crossed is externally visible (relative to microprocessor 103) while a memory operation that does not result in the I/O interface boundary being crossed is not externally visible (relative to microprocessor 103).
For the purpose of explanation, the discussion herein refers to an “abstract machine.” In this context, an abstract machine is a theoretical construct implementing the formal definition of an instruction set architecture (ISA) as visible to operating system and application software, for example a variant of the x86 (80×86) instruction set architecture.
In one embodiment, microprocessor 103 is an x86 processor (e.g., a microprocessor that implements the x86 ISA using a combination of hardware circuits and microcode). In another embodiment, microprocessor 103 is a processor that transfers to software those functions that are keyed to determining what instructions (micro-instructions) to execute and when. In one example of the latter embodiment, conventional x86 (80×86) instructions are converted into microarchitecture instructions, for example Very Long Instruction Word (VLIW) instructions using “Code Morphing™ software.”
One implementation of Code Morphing™ software utilizes an interpreter module and a translator module. Among other functions, the interpreter module interprets ISA (e.g., x86) instructions one at a time, similar to that of conventional processors. The translator module is invoked when critical and/or frequently used ISA instruction sequences are detected. In general, the translator module recompiles the ISA instructions into native instructions that can reduce the number of instructions executed and that can schedule the instructions to execute more efficiently within the microprocessor.
As used herein, a “translation” refers to a microarchitecture instruction or sequence of microarchitecture instructions that perform the same function as some set of ISA-specified instructions. A translation can be viewed as having a beginning state and an ending state (the ending state is, in essence, the beginning state of the next translation). The beginning and ending states may be referred to as “commit points.” At a commit point, the “architecturally visible” resources of the translating processor and of the abstract machine should be the same.
Embodiments of the present invention introduce methods and systems thereof that allow partial speculation (e.g., speculation within constraints). With partial speculation, after certain types of events are detected, speculation remains enabled for CPU registers and other memories private to a microprocessor, while speculation normally permitted for certain other operations is suspended. Accordingly, while the event is dispatched, some speculation is permitted as opposed to suspending all speculation.
FIG. 3 illustrates the use of controlled (e.g., partial) speculation according to an embodiment of the present invention. Execution begins at a point identified as a “speculation boundary.” A speculation boundary refers to a memory state of the microprocessor (e.g., microprocessor 103 of FIGS. 1 and 2) that is present at a particular point in time.
In the example of FIG. 3, in step 1, execution proceeds forward from the speculation boundary 310 in a first mode referred to as full speculation mode. Operations can be roughly categorized into three categories: register, memory, and I/O. In full speculation mode, register operations can be speculated as long as their original state can be recovered. Memory operations can be speculated, but in the event of a DMA request, speculation is constrained. Speculation of I/O operations is permitted in some instances and constrained in others.
Specifically, in one embodiment of full speculation mode, speculation is permitted for register operations, operations that involve memory that is private to the microprocessor 103 of FIGS. 1 and 2 (e.g., memory hidden from an I/O bus or memory protected against DMA), I/O writes but not I/O reads, and main memory reads and writes. Generally, speculation is not permitted in the event of a DMA request, although there may be exceptions. Also, speculation permits the presence of non-architectural faults (exceptional conditions that do not correspond to observable events in the abstract machine mentioned above).
In step 2 of FIG. 3, some type of event is identified. An event can be a fault such as an attempt to access a memory page that does not exist, or an attempt to access a segment descriptor that is not valid. An event can instead be a DMA request or an I/O read. In the presence of these kinds of events, full speculation mode may interfere with the externally visible behavior of microprocessor 103 (FIGS. 1 and 2), and so for some events such as those mentioned above, full speculation mode should be suppressed.
In step 3 of FIG. 3, roll back to the speculation boundary 310 occurs, restoring the memory state that existed at that point.
In step 4 of FIG. 3, execution proceeds forward from the speculation boundary 310 in a second mode referred to as partial speculation mode. In one particular implementation, the second mode is known as the XPROMOTE mode.
In partial speculation mode, speculation is permitted for a non-null subset of the operations permitted in full speculation mode. Specifically, in one embodiment of partial speculation mode, speculation is permitted for register operations and for operations that involve memory that is private to the microprocessor 103 of FIGS. 1 and 2 (e.g., memory hidden from an input/output bus or memory protected against DMA). In partial speculation mode, speculation is permitted, for example, for the benefit of correctly handling “architectural faults” (exceptional conditions that do correspond to observable events in the abstract machine mentioned above).
In an embodiment in which microprocessor 103 is a microprocessor that utilizes a translator module and an interpreter module as described above, interpretation of non-native instructions can be performed in full or partial speculation modes, while translations are executed in full speculation mode.
In one embodiment, a speculation boundary corresponds to a commit point. An example of microcode according to such an embodiment is illustrated by the following:
load_ss( );
[1. load stack segment]
load_cs( );
[2. load code segment]
cmit ( );
[3. speculation boundary]
load_ds( );
[4. load data segment]
cmit ( ).
[5. speculation boundary]
In the example above, it is assumed that the ISA definition is such that the final state after a failure to load the code segment at line 2 would contain the stack segment as it was prior to entering this microcode sequence, whereas after a failure to load the data segment on line 4 the final state would contain the stack and code segments loaded at lines 1 and 2. In this example, if the speculation system cannot be used, additional tests would need to be added to verify that the code segment load on line 2 would complete successfully before the stack segment load on line 1 is attempted.
Thus, in response to an event, partial speculation mode permits some speculative operations to be performed, in lieu of suspending all speculative operations in response to the event. Note that in some situations, all speculative operations may still be suspended. For example, should another event occur during operation in partial speculation mode, all speculative operations may be suspended. Thus, according to the embodiments of the present invention, at least three speculation modes are permitted: full speculation, partial speculation, and all speculation suspended.
It is appreciated that other types of full and partial speculation modes can be defined. That is, for example, a full speculation mode or a partial speculation mode can be defined that includes operations other than those mentioned herein. Similarly, different levels of partial speculation modes can be defined. For example, the highest level of partial speculation could permit operations that are a subset of the operations permitted with full speculation. The next level of partial speculation could be a different subset of the operations permitted with full speculation. Alternatively, the next level of partial speculation could be a smaller subset of the larger subset of operations associated with the highest level of partial speculation.
In step 5 of FIG. 3, execution in partial speculation mode continues until the event is handled or until some other condition is satisfied. For example, in step 1, a count can be made of the number of instructions executed in full speculation mode. When the same number of instructions are executed in step 4 in partial speculation mode, then a return to full speculation mode can be made.
Speculation boundary 311 corresponds to a memory state that exists during the execution of step 5. In one embodiment, speculation boundary 311 corresponds to another commit point, subsequent to the commit point associated with speculation boundary 310.
FIG. 4 is a flowchart 400 of a method providing partial speculative operation according to an embodiment of the present invention. FIG. 5 is a flowchart 500 of another method providing partial speculative operation according to an embodiment of the present invention. Although specific steps are disclosed in flowcharts 400 and 500, such steps are exemplary. That is, embodiments of the present invention are well suited to performing various other steps or variations of the steps recited in flowcharts 400 and 500. It is appreciated that the steps in flowcharts 400 and 500 may be performed in an order different than presented, and that not all of the steps in flowcharts 400 and 500 may be performed.
Referring first to FIG. 4, in step 410, operations are executed in full speculation mode. Operations are executed forward from a speculation boundary (e.g., speculation boundary 310 of FIG. 3). The speculation boundary represents a state of the microprocessor (e.g., microprocessor 103 of FIGS. 1 and 2).
In step 420 of FIG. 4, an event (e.g., a fault, an I/O read, or a DMA request) is detected.
In step 430, the initial microprocessor state is restored by rolling back to the speculation boundary (e.g., speculation boundary 310 of FIG. 3).
In step 440 of FIG. 4, operations are executed from the speculation boundary in partial speculation mode. Once the event is handled, or once some other type of condition is satisfied, execution can return to full speculation mode. Alternatively, speculation may be suspended in entirety should another event occur during partial speculation mode.
Referring now to FIG. 5, in step 510, operations are executed while in a first mode of speculative operation (e.g., a full speculation mode) that permits a first set of speculative operations.
In step 520, an event is experienced. The event is of a type such that execution in the first mode of speculative operation is no longer permissible. Full speculation mode may interfere with the externally visible behavior of microprocessor 103 (FIGS. 1 and 2), and so full speculation mode is suppressed for some events such as DMA requests, I/O reads and faults.
In step 530 of FIG. 5, in response to the event, the first mode of operation is exited and a second mode of operation is entered. In the second mode (e.g., a partial speculation mode), a second set of speculative operations is permitted, the second set being a subset of the first set. The second set of speculative operations include those operations that are limited to memory that is private to the microprocessor (e.g., memory hidden from input/output buses or memory protected against DMA), such as CPU register 102 of FIGS. 1 and 2.
In step 540 of FIG. 5, after the event is handled (or after some other condition is satisfied), execution can return to the first mode of operation (e.g., to full speculation mode).
In summary, according to the various embodiments of the present invention, a partial speculation mode of operation is introduced. The partial speculation mode is in addition to a full speculation mode and a mode in which speculation is suspended in entirety. While in partial speculation mode, processor register operations can be speculated. Furthermore, in partial speculation mode, memory operations under exclusive control and use of a microprocessor can be speculated. As such, microcode can be written that makes use of the speculation system.
Patent CitationsCited PatentFiling datePublication dateApplicantTitleUS5881280 *Jul 25, 1997Mar 9, 1999Hewlett-Packard CompanyMethod and system for selecting instructions for re-execution for in-line exception recovery in a speculative execution processorUS6854048 *Aug 8, 2001Feb 8, 2005Sun MicrosystemsSpeculative execution control with programmable indicator and deactivation of multiaccess recovery mechanismUS6925552 *Jun 19, 2001Aug 2, 2005Hewlett-Packard Development Company, L.P.Method and system with multiple exception handlers in a processorUS20020092002 *Apr 18, 2001Jul 11, 2002Babaian Boris A.Method and apparatus for preserving precise exceptions in binary translated code* Cited by examinerNon-Patent CitationsReference1 *"BOA: The Architecture of a Binary Translation Processor"; E. Altman et al.; Dec. 2000.2 *"Checkpointe Repair for Out-of-order Execution Machines"; Wen-mei Hwu and Yale Patt; 1987; ACM.3 *"The Technology Behind Crusoe Processors"; Alexander Klaiber; Jan. 2000.4 *"The Transmeta Code Morphing Software: Using Speculation, Recovery, and Adaptive Retranslation to Address Real-Life Challenges"; James Dehnert et al.; Mar. 2003; IEEE.5 *"Webster's II New College Dictionary"; 2001; Houghton Mifflin.* Cited by examinerReferenced byCiting PatentFiling datePublication dateApplicantTitleUS8327188 *Nov 13, 2009Dec 4, 2012Oracle America, Inc.Hardware transactional memory acceleration through multiple failure recoveryUS8739164 *Feb 24, 2010May 27, 2014Advanced Micro Devices, Inc.Automatic suspend atomic hardware transactional memory in response to detecting an implicit suspend condition and resume thereofUS9411600 *Dec 8, 2013Aug 9, 2016Intel CorporationInstructions and logic to provide memory access key protection functionalityUS20110119528 *Nov 13, 2009May 19, 2011Sun Microsystems, Inc.Hardware transactional memory acceleration through multiple failure recoveryUS20110209151 *Feb 24, 2010Aug 25, 2011Jaewoong ChungAutomatic suspend and resume in hardware transactional memoryUS20150160998 *Dec 8, 2013Jun 11, 2015H. Peter AnvinInstructions and logic to provide memory access key protection functionality* Cited by examinerClassifications U.S. Classification712/244International ClassificationG06F15/00Cooperative ClassificationG06F9/30181, G06F9/3863, G06F9/3842European ClassificationG06F9/30X, G06F9/38E2, G06F9/38H2Legal EventsDateCodeEventDescriptionJan 20, 2004ASAssignmentOwner name: TRANSMETA CORPORATION, CALIFORNIAFree format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:ANVIN, H. PETER;DUNN, DAVID;REEL/FRAME:014894/0638;SIGNING DATES FROM 20031107 TO 20031126Mar 26, 2009ASAssignmentOwner name: TRANSMETA LLC, CALIFORNIAFree format text: MERGER;ASSIGNOR:TRANSMETA CORPORATION;REEL/FRAME:022454/0522Effective date: 20090127Owner name: TRANSMETA LLC,CALIFORNIAFree format text: MERGER;ASSIGNOR:TRANSMETA CORPORATION;REEL/FRAME:022454/0522Effective date: 20090127Sep 22, 2009ASAssignmentOwner name: INTELLECTUAL VENTURE FUNDING LLC, NEVADAFree format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:TRANSMETA LLC;REEL/FRAME:023268/0771Effective date: 20090128Owner name: INTELLECTUAL VENTURE FUNDING LLC,NEVADAFree format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:TRANSMETA LLC;REEL/FRAME:023268/0771Effective date: 20090128Apr 24, 2012FPAYFee paymentYear of fee payment: 4Sep 29, 2015ASAssignmentOwner name: INTELLECTUAL VENTURES HOLDING 81 LLC, NEVADAFree format text: MERGER;ASSIGNOR:INTELLECTUAL VENTURE FUNDING LLC;REEL/FRAME:036711/0160Effective date: 20150827Oct 6, 2015ASAssignmentOwner name: INTELLECTUAL VENTURES HOLDING 81 LLC, NEVADAFree format text: CORRECTIVE ASSIGNMENT TO CORRECT THE ASSIGNOR S NAME PREVIOUSLY RECORDED AT REEL: 036711 FRAME: 0160. ASSIGNOR(S) HEREBY CONFIRMS THE MERGER;ASSIGNOR:INTELLECTUAL VENTURES FUNDING LLC;REEL/FRAME:036797/0356Effective date: 20150827Apr 25, 2016FPAYFee paymentYear of fee payment: 8RotateOriginal ImageGoogle Home - Sitemap - USPTO Bulk Downloads - Privacy Policy - Terms of Service - About Google Patents - Send FeedbackData provided by IFI CLAIMS Patent Services