Patent Grant
10585670
This invention relates generally to digital circuitry. More particularly, this invention relates to improved processor designs.
Processors are required to handle multiple tasks that are either dependent or totally independent. The internal state of such processors usually consists of registers that might hold different values at each particular instant of program execution. At each instant of program execution, the internal state image is called the architecture state of the processor.
When code execution is switched to run another function (e.g., another thread, process or program), then the state of the machine/processor has to be saved so that the new function can utilize the internal registers to build its new state. Once the new function is terminated then its state can be discarded and the state of the previous context will be restored and execution resumes. Such a switch process is called a context switch and usually includes 10's or hundreds of cycles especially with modern architectures that employ large number of registers (e.g., 64, 128, 256) and/or out of order execution.
In thread-aware hardware architectures, it is normal for the hardware to support multiple context states for a limited number of hardware-supported threads. In this case, the hardware duplicates all architecture state elements for each supported thread. This eliminates the need for context switch when executing a new thread. However, this still has multiple draw backs, namely the area, power and complexity of duplicating all architecture state elements (i.e., registers) for each additional thread supported in hardware. In addition, if the number of software threads exceeds the number of explicitly supported hardware threads, then the context switch must still be performed. This becomes common as parallelism is needed on a fine granularity basis requiring a large number of threads. The hardware thread-aware architectures with duplicate context-state hardware storage do not help non-threaded software code and only reduces the number of context switches for software that is threaded. However, those threads are usually constructed for coarse grain parallelism, and result in heavy Software overhead for initiating and synchronizing, leaving fine grain parallelism, such as function calls and loops parallel execution, without efficient threading initiations/auto generation. Such described overheads are accompanied with the difficulty of auto parallelization of such codes using sate of the art compiler or user parallelization techniques for non-explicitly/easily parallelized/threaded software codes.
A unified architecture for dynamic generation, execution, synchronization and parallelization of complex instructions formats includes a virtual register file, register cache and register file hierarchy. A self-generating and synchronizing dynamic and static threading architecture provides efficient context switching.
The invention is more fully appreciated in connection with the following detailed description taken in conjunction with the accompanying drawings, in which:
Like reference numerals refer to corresponding parts throughout the several views of the drawings.
One aspect of the invention reduces context switch penalty. A context switch penalty occurs because of the time it takes to save the architecture state (e.g., data registers, control registers, program counters, etc.) The state of the previous context has to be restored before resuming execution. This means that many loads/stores of a large number of registers need to occur for something as common as an involved function call. Disclosed is an architecture state structure to do a gradual self context-switch as well as an instant context switch on the architecture state. Also, the concepts of a virtual register file and a register cache are introduced as possible implementation components. The virtual register file or register cache also provide support for virtually larger number of threads or contexts in the hardware than possible using traditional hardware thread support. A multi hierarchal register file support provides larger bandwidth to the register file.
The techniques can also be combined with threading support. One part of the architecture state will undergo an instant hardware/software supported context switch where all the architecture state is saved quickly/instantly by the hardware using a LIFO (Last-In First-Out) circuit. The use of a LIFO circuit allows for lower complexity and efficient speed and area implementations, as opposed to register file or random access memory implementations. Each subsequent context switch that belongs to this category is saved on top of the old context in the LIFO. This technique is well suited for recursive functions calls or nested parallelized loops where the context of one call in the recursion will naturally be entered and exited in a LIFO manner.
Another way of doing this quick saving of the architecture state is to save the register file content as one block in memory or cache (e.g., one cache line or block). A register batch is a series of subsequent register numbers (e.g., registers 0 to 7 might be a subset of a larger register set 0-64) that can be stored as a one cache line of size 64 bytes when a context switch involving those 8 registers occurs. The register file has dedicated wide buses 101 and 102 that directly carry all of its content either in the same cycle or in a small number of cycles, as opposed to typical usage of loads and stores to save and restore each individual register. One possible implementation of the register file to cache transfer is to use the buses 102 and 101 to connect to the fill buffers that are commonly used to fill cache lines as a back door path to move registers directly to cache. One alternative implementation can use write/read combining buffers that are typically used to accumulate partial stores and loads data into a buffer before writing them on the bus to the memory as a single transaction, instead of each forming a partial bus transaction. Such a combining buffer can have a side door bus connection through 101 and 102 to combine the series of registers into one write combining buffer that can then transfer the whole cache line worth of registers into the cache or memory while it can use the read combining buffer to do the opposite transfer. The use of a specialized local memory with a LIFO circuit or random access memory buffer is also another implementation choice. The LIFO circuit is simpler and has less implementation constraints, but imposes a strict order of saving and restoring data (last in first out). On the other hand, a random access memory, such as using a direct bus to processor cache has the flexibility of using local memory, but imposes hardware implementation constraints, while allowing flexible saving and restoring of contexts in random order.
Another part of the architecture state may be saved and restored gradually as the new context is replacing the old context. In other words, the individual registers are swapped/read in and out by the hardware upon the use of that particular register in the new or old context. This gradual context switch is suitable for global variables and variables that are passed from one function to another through the context switch. It also fits those variables that are passed through nested loops if the loops are threaded, such that the inner loop is assigned to a different thread than the outer loop. It can also be applied to the cases where different iterations of the loop are assigned to different threads and these iterations pass several variables from one iteration to the other (loop carried dependency). In all those cases it is advantageous to perform a gradual context switch for the registers because the number of registers that are commonly used between threads (the registers that passes data between the contexts) is large, thus those registers can be shared and do not need to undergo a context switch, while the remaining registers can be swapped as needed gradually.
The invention may also utilize virtual registers to allow for the containment of a larger set of registers than those directly supported by the instruction set architecture. The extra registers are part of the hardware supported context switch or hardware/software threads. The concept of a register cache or register hierarchy is also applicable for such scenarios. A virtual register file is a register file architecture where the instruction set registers visible to the architecture are extended and are still visible using the virtual register file storage. This facilitates keeping multiple copies of the same architecture register that belong to different context switches or threads. This also enables larger or variable numbers of registers than those directly accessible using a traditional physical register file. Those copies of the architecture registers are visible to the hardware in the case the hardware is generating the threads/contexts (hardware-threads) and they can also be overloaded with software threads if the software is generating them (software-threads).
It is also possible to include in this hierarchy a register cache where registers are cached in and out of this structure based on their relevancy to current context and their immediate access needs. One way to implement this virtual register file and register cache is by providing tags to the register locations such that they are accessed by the tags that include the actual register number in addition to other information, such as context ID number or static thread number and possibly the memory address where they should be saved for the context switch. Other alternative techniques are also described here in where an index map 202 uses position-based information about each of the architecture registers. The position (location) of the register copy in the hierarchy is looked up as part of the decoding phase of the register read access of the register file 203. Other mechanisms include passing the location of the register as part of the score board mechanism from the producer instruction of the register to its consumer instructions. Consumer instructions need to read the register so that they know which copy of that architecture register they need to access, but in the location/position based schemes, no tags are needed because the register is accessed by its register number and the location where the particular register copy is physically located among the multiple copies of that register in the multi-hierarchy register file.
The mechanism of gradual context switch can use similar mechanisms to current context switch of loading and storing the individual registers with the following differences. An individual register is hardware swapped/read when a new context attempts to use it and the local copy belongs to the old context. At that time the register belonging to the old context is swapped with the global register copy in 200 that belongs to the new context which is brought into the local register file 201. In one implementation, multiple registers that carry the same register number can coexist, but with different context ID tags. One implementation of the tag scheme can resemble a virtual register file where the same registers from different contexts are present. A virtual register file is interesting as it allows for a large virtual register file to be implemented as a hierarchy of multi level register-files with different bandwidth and capacity variations.
The following example illustrates different scenarios where functions are presented. Assume that different function calls within a single program/task are called at subsequent times.
The old local variables in the Local register file as a whole need to be saved if the old context is not needed, it makes sense here to use instant saving for contexts, other cases where the whole context needs to be saved are when a new independent process is invoked by the operating system.
On the other hand, if not all of the registers of the old context need to be saved, then only those that need to be saved are gradually swapped with the new context register values. This is the case where function 1 and 2 coexist together in the same local register file and share the same global registers in the global register file. This is the case for fine grain threads. In such case, when a particular register in a certain context needs to be accessed, its context ID is checked with the one that exists in the local register file. If they match, then it can be used, else it needs to be brought/read from a higher storage hierarchy (such as the global register file or the register cache) and may be swapped with the one that is in the local hierarchy storage (e.g., the temporary local register)
At the call of the Function, the new variables that are to be written within the function scope are assigned to new register copies (with a new context/thread ID compared to the external scope of the function). Those new register name copies can be assigned either by a hardware management unit (HMU) or by a compiler/programmer that generates code for this architecture. In case of the HMU, the HMU unit upon entering the function code (the one between the call and return instructions) will assign a new context/thread ID number to each register name that is being written within the function scope, thus generating copies of the register names. Upon reaching the return instruction this context/thread ID becomes free for reassignment and all the register name copies can be reused again. There is no overhead in creating and synchronizing these temporary contexts because the hardware automatically manages the assigning and freeing of these temporary copies of register names.
The compiler can handle the management of the register names in different contexts if the instruction architecture allows for extending the register name with a context/thread ID number. This way the instructions that write into a specific register name will also specify the context/thread that the instruction writes to and reads from. Consider a typical instruction with 3 sources (S1,S2,S3) and one destination (Dest) as encoded below
Dest/S1←ADD (S2, S3)
In this example, the registers and their association to threads will be formatted as:
Thy, Rx←ADD (Thz:Ri, Thw:Rk)
This shows how the instruction architecture allows for specifying the context/thread ID i.e., “Thy where y is the thread ID” alongside register Rx with register name x. The compiler or the programmer can specify the context/thread number that the register names belong to. When a code for a function is compiled the compiler can increment the context/thread ID number using a special instruction to increment the thread ID counter; then this counter is decremented upon exiting the function call using a decrement instruction. Another mechanism that the instruction architecture can use is to implement a free thread selector instruction. The compiler/programmer uses this instruction to poll the hardware to find a free context/thread ID which it can use. Upon returning from the function it can uses another instruction such as a context/thread free instruction. The following illustrates these 2 methods:
The reason for having the increment before the function call and the decrement after the return is to allow for passing the values between the caller and callee. The increment creates the new context/thread number and the decrement frees it.
An alternative method that does the same task uses an instruction that selects a free context/thread number and another instruction to free that context/thread number.
To reduce the encoding space for the context/thread number associated with each register name, the instruction architecture can specify that a register is associated with the parent thread or with the current child thread; this can be encoded with one bit (we will call the parent/child bit: “P/C” bit). Each new generated thread will specify its parent thread (the thread that it was spun out of). The parent ID number will be kept along with the other thread state. A hybrid scheme can be used where the instruction can specify one/more sources from the current child or parent thread using the parent/child bit and one/more sources from another non-related thread using an explicit thread number along with that source register name. The following instruction set architecture illustrates such hybrid scheme:
P/C:Rx←ADD (P/C:Ri, P/C:Rj, Thw:Rk)
The “P/C” bit specifies if the register belongs to the parent thread or the child thread. This scheme can be generalized where more bits can be designated to encode active threads within a higher level context. The following illustrates this more general scheme. A high level context defines few threads within its state. Processor architecture allows for small size of stored states that the instruction set can abbreviate. Assuming that the processor hardware can support a total of N threads, the instruction set can support an abbreviation of those threads that allows intercommunication of M threads through the registers in the instruction set encodings, where M<N. This will allow for a larger number of threads to be supported by the instruction set architecture than the abbreviated encoding bits allows. For example, let us assume that the hardware can support 128 threads (N=128). One can define the instruction set encoding to have an encoding for only 4 threads (M=4), such that those threads' registers can be simultaneously accessed by 4 active threads out of the 128 threads. Those 4 threads can rotate among the 128 threads depending on the active region of the program. Few bits (T1 . . . Tlog M) can be used to encode M threads in the instruction. In this example 2 bits T1T2 are used to encode 4 threads.
T1T2:Rx←ADD (T1T2:Ri, T1T2:Rj, Thw:Rk)
Mapping the active threads within a program region to the overall set of threads supported by the hardware can be done though mapping or assignment instructions as the following example shows
Map (T1T2=00), TH=0001101
Map (T1T2=01), TH=1001000
Map (T1T2=10), TH=1010101
Map (T1T2=11), TH=0111100
01:Rx←ADD (01:Ri, 10:Rj,1000110:Rk)
In the above example of code the instructions map the hardware threads to the abbreviated encoding represented by the 2 bits T1T2 of the mapping instructions. By way of example, the add instruction encodes only 2 abbreviated bits for the threads of each source and the destination. The third source, however, explicitly encodes the thread of its source. The decision of the number of bits to encode in the instruction set to abbreviate the threads is an implementation decision that can vary from one architecture to another, also including a third source or having its thread explicitly encoded is an implementation choice.
To implement the pipeline of a processor that executes such instructions or micro operations (microcode implementation of the instructions), this pipeline will store those maps and use them to access the correct thread state when it executes an instruction that encodes the abbreviated thread bits. Those mapping states can expand a register allocation algorithm for mapping single thread variables to registers, where the compiler can allocate a larger set of threads to the limited number of mapping states and then perform the register allocation within each thread. This way the mapping states can be reallocated for new threads through out the program using live ranges of threads similar to live ranges of registers.
Map (T1T2=00), TH=0001101
Map (T1T2=01), TH=1001000
Map (T1T2=10), TH=1010101
Map (T1T2=11), TH=0111100
01:R5←ADD (01:R2, 10:R3, 1000110:R10)
01:R8←MUL (01:R4, 01:R5, 1000110:R12)
Map (T1T2=10), TH=1011111
01:R5←ADD (01:R2, 10:R3, 1000110:R10)
01:R8←MUL (01:R4, 01:R5, 1000110:R12)
If the processor is an out of order processor, it can also allow for renaming of those abbreviation maps to allow for more of those active region threads to be executed simultaneously. For example, in such an out of order processor, the above code will be decoded to rename those abbreviated bits internally in the actual micro operation encodings to the full thread number. In such an out of order machine temporary speculative registers are also implemented to keep those renamed registers and states.
The general scheme described enables fine grain threads to communicate, cooperate and synchronize execution on register level execution without the need to go through memory, while at the same time having the instruction set encodings very compact by providing register association to threads, while minimizing instruction encoding space. All the schemes described above require the compiler to insert instructions to manage the threads and set the extension bits, can be performed by a hardware management unit that executes similar actions to the instructions and manage the setting of those extension bits (as described throughout the invention).
We generalize the above mechanisms to handle fine grain threads beyond function calls, to include threads across loop boundaries and creating threads between the body of the loop and the code outside a loop body. Consider the following code:
Using the compiler or the hardware management unit, the thread that represents the inner loop body (instructions 1 and 2) and the thread that represents the instructions outside the inner loop body can be mapped into hardware supported threads.
The following implementation, by way of example, represents one scheme where those fine grain threads can be live in the register file/register cache and be swapped in and out into higher level register file hierarchies as well as memory hierarchies.
The assumption is that a compiler will be designed to use some convention that saves context depending on the number of registers used in the called function. So it can save a number of registers in an incremental way. For example, if the design convention is to use register batches in increments of 8, then if a function needs to use a number of registers that is between 1 and 8 registers it will save registers 1 thru 8 of the old context (and will restore them when it restores the old context). If it needs to use a number of registers between 1 and 16 it will then save registers 1 to 16 and so on and so forth to the full extent of saving the whole registers supported by the architecture. One other scheme that allows for establishing a virtual register file is the aliasing of the registers of different contexts/threads that need a smaller number of registers than that provided by the instruction set architecture. For example, a small function call or a worker thread might only need to use a subset of all the registers e.g., 8 registers (register 0 to 7) out of the 32 registers available by the instruction set. If this is the case, then the hardware/compiler will alias this 8 logical register batch on top of another free physical register batch, the register batch that the thread gets mapped to does not need to be with the same register numbers; i.e., registers 0-7 can be mapped onto physical registers 8-15 or 16-23 or 24-31 that are available in another context physical state storage.
In instruction set or microinstruction encoding, to allow the aliasing scheme described above, the reference to a thread-register pair can be a continuous encoding of bits, where the top 4 bits will be the hardware thread number (indicating which batch of 8 registers the thread references) and the lower 3 bits will indicate individual register in the register batch 0-7.
As an example, assume that the software needs to perform the following high level threaded task of adding certain registers in different threads and write the result in register 2 in software thread 1, shown as 403 in
Th1:R2←ADD (Th0:R13, Th3:R2,Th6:R3)
Then the mapping of the software threads to hardware threads will be done either by the compiler or the hardware management unit. Such mapping ensures that software threads which need more than 8 registers reserve more than just one hardware-thread storage, thus no other software thread can use those reserved hardware threads to map onto. The actual instruction encoding of the task will be written as follows,
0100010←ADD (0001101, 0110010, 1100011) which decodes to the following:
HWTh4:R2←ADD (HWTh1:R5,HWTh6:R2,Th12:R3)
Note that software thread 0 register 13 was encoded as hardware thread 1 (401) register 5 (0001 101, first 4 bits are hardware thread number and last 3 bits are register number) because the mapping of software thread was aliased on 4 small state hardware threads 0,1,2,3 each of which has a batch of only 8 registers. Alternatively the same encoding can be read as hardware thread 0 register 13 (00 01101, the first 2 bits is the number of large state hardware thread (one with 32 register state) and the last 5 bits are the register number among the 32 registers)
Another scheme that can be implemented on top of previous register cache scheme is one that provides an automatic store load mechanism between this register cache and the memory cache to allow the register cache to spill out and reload registers automatically upon context switches and thread context swapping which is illustrated in
The following code illustrates the scheme and how the hardware described in
In the above code the compiler wants to save to the memory stack, registers RO thru R7 of thread 0 that will be overwritten by threads 1, 4 and 6. In this scheme we allocate the memory region in the stack to accommodate register batch (0-7) but the hardware do not really perform the store of the registers of thread 0 to the memory/memory cache when threads 1, 4 and 6 are encountered. This is because the multi-context register file cache is able to provide storage 501 to the extra 8 registers (0-7) that those threads need without destroying registers 0-8 of the original thread (thread 0). As long as the multi-context register file cache can accommodate those registers, it only updates the tag array in the register cache with the stack memory address that the store instructions intended to perform. Notice that when thread 8 is encountered (“function foo”), because the ways of the register cache are all occupied for register batch 0-7 then the stores of registers 0-7 for thread 0 has to happen and in fact it is similar to the eviction process in a typical cache where the registers 0-7 of thread 0 are evicted to the real stack memory/cache hierarchy storage 500 while the register file cache thereafter, contains values for register 0-7 of thread 8 in the storage area 502.
The mechanism for context switch can also facilitate other techniques, such as the dynamic self generation and synchronization of threads. Concurrent execution of different parts of a single task or program currently requires the implementation of an out-of-order “Super scalar” processor architecture. However, out-of-order execution requires plenty of hardware investment and complexity. The following are typical implementation components that are needed for such concurrent execution using an out-of-order micro-architecture:
Few architectures have capitalized on the super scalar nature of the out-of-order machines and their ability to dispatch multiple independent streams of instructions to allow multiple software threads to simultaneously execute in the machine. This simultaneous multi-threading requires duplicating the architecture state of the machine for each hardware supported-thread and partitioning the micro architecture resources between threads and sharing the memory structures like caches between those threads.
Despite the fact that those machines are out-of-order, they do not initiate, self dispatch, synchronize or enable concurrency between threads by the out-of-order hardware itself. Rather, all those tasks are left to the software, which initiates/generates and dispatches the threads when their dispatch condition/dependency is met (e.g. using barriers). The software synchronizes them when there is common control or dependencies between them (using locks for example). The software also determines the concurrency between them. The software mentioned earlier could be the actual master thread code or the compiler that tries to statically parallelize non-threaded code. Usually those threads are implemented using coarse-grain parallelism leaving fine grain parallelism without efficient threading initiations because of the difficulty of automatic parallelization of such codes.
The following discussion illustrates that with a new paradigm of hardware/software, automatic parallelization is achieved even without using the elaborate out of order micro-architecture support. The new hardware generates, synchronizes, parallelizes and concurrently executes those fine/coarse grain static and dynamic threads by dynamically detecting that the control conditions and/or the dependencies are resolved and/or by allowing for the cross reference of registers between threads also by disambiguating memory references across those threads. This is done by having the hardware monitor either a control condition associated with triggering the thread or the write back of cross referenced register values on which the current thread depends on.
The initiation/generation of the thread dynamically by hardware is triggered when all its dependency registers and/or control conditions, particularly those of cross reference nature (e.g., inter-thread registers) are satisfied. This can be monitored through the explicit list of sources that this thread is dependent on. These hardware initiated dynamic threads can be thought of or actually can be things like a function call or a method or subroutine or even a loop instance that can be encapsulated in a form of a repeated function call. This function call has a parameter list on which its execution is dependent. Those parameter lists or registers are monitored for their write back stage occurrence. Once each parameter/register is written back after its updating instruction has executed, a flag is set. When all the flags of those parameters/registers are set, then the function/thread can be dynamically dispatched by the hardware. The allowance for cross referencing of the registers or virtual registers and/or memory references among the different threads (both the hardware generated as well as the software generated) establishes a way to generate, synchronize, parallelize and concurrently execute those threads using a natural dependency resolving method such as the one used to create consistent execution of programs using registers to communicate dependencies.
The lazy gradual context switch mentioned earlier also helps to allow the new state of those dynamically generated or software static threads to be built/swapped with other existing dynamic/static threads as illustrated earlier.
The lead counter 601 for a specific register keeps incrementing as a new instant of the same register is being assigned as a destination to a new instruction. Each time a register is reassigned as a destination to new allocated instructions 603, this bit field of that register is incremented (in the front end of the machine) and attached to the hardware instructions 605. Each subsequent instruction using this register as a source 606 will use the new incremented register number extended field. Whenever that register commits to final architecture state, then that register bit field lag counter 602 at the front end is incremented. The reason to use and increment the lag counter is to determine if a particular register value needs to be read from the speculative reorder buffer or from the retired register file by comparing (at the instruction register read stage) the register extended field of the hardware instruction with the lag counter of that register from the lag counter pointer. The lag counter 602 gets incremented at retirement pipeline stage 604 This mechanism can also apply to individual instructions and not only to function's calls or threads.
The lead counter and lag counter table shown in
In the following paragraph a preferred method is described to unify automatic/dynamic threading generation and synchronization along with the handling of context switches described earlier. In addition, the concept of physically-segmented architecturally-unified register file is disclosed with a register hierarchy that is well suited to such an implementation.
The architecture may also include an instruction matrix/block/bucket architecture (matrix, block or bucket are used exchangeably) where instructions are part of an “Ultra Large Instruction Matrix” referred to in a previous invention by the same inventor as “ULIM Architecture” in PCT/US2007/066536, which is incorporated herein by reference. The instruction matrix/bucket/block is a collection of instruction that might be totally dependent on each other or totally independent or something in between (some instructions depend on others while some are independent with respect to others). Usually the instruction matrix/block encapsulates instructions in a matrix format where dependent instructions must occupy a column within the matrix and independent instructions occupy rows or columns. The matrix dimensions (rows, columns) can be selected from few possible configurations that the architecture maps to its hardware execution units. The Matrix/Block/bucket architecture is a concept that allows the passing of dependencies on the level of an instruction block/Bucket identity instead of individual sources. Thus, the architecture efficiently removes complexities associated with CAM (content addressable Match) matching sources and destinations in a large scale concurrent instruction execution architecture. It is possible to design the disclosed inventions without the explicit use of the ULIM architecture or the even instruction buckets/blocks, by using instead a virtual identifier that serves a similar role to the bucket/block role such that it tracks and resolves dependencies on a source group level without really forming a matrix or block but by using grouping of simple instructions. This is an implementation advantage over the current schemes that use individual source dependency tracking and resolution per single instruction.
Within an instruction bucket and across the buckets, instructions can be assembled as VLIW or SIMD or MIMD. Then the buckets are dispatched and executed as dynamic threads. In addition, the static software threads can share the same mechanisms described for dynamic threads with the difference that they are generated based on the software application threads.
In contrast to the typical implementation of out of order hardware of
In this example, the instruction bucket 806 is determined to satisfy its dependency sources and thus it is ready to be dispatched and so is bucket 808 and 809. Those buckets can execute in single cycle if the underlying hardware allows that or they can be staged in execution units 802 over multiple consecutive cycles in a pipelined or non pipelined fashion. After their execution is finished their results are written into instruction matrix retirement register file 803. They are written as a group of registers representing the bucket using the write back ports 805. Those bucket destination registers stay in the bucket retirement buffer until the bucket as a whole can update the architecture state in the original sequential order of the program.
One possible implementation for this concept is described in with 3 components:
1—The front end
2—The Scheduler and Execution
3—The Back end retirement
The front end includes: Speculative Thread Bucket-pointers, Bucket Sources and destinations lists. The scheduler and execution buckets include a bucket dispatch selector and the virtual register match and read, including the possibility of a register hierarchy and a register cache. The Back end is where executed buckets are logged and exception ordering is enforced before retirement. The register hierarchy/cache also serves as an intermediate storage for the executed bucket results until they are non-speculative and can update the architecture state similar to 803 shown in
The following discloses one possible implementation of the front end, the dispatch stage and the backend where executed buckets are logged. Those are shown in
The process starts by fetching a new thread Matrix/bucket/block, and then the new thread bucket is assigned into a vacant bucket slot in the bucket buffer. Each of the thread allocation pointers in the thread allocation pointer array 852 composes an interval of buckets that the thread is allowed physically to place its blocks/buckets of instruction in it. Each of those threads keeps allocating buckets into the bucket buffer array inside its corresponding interval of contiguous space in round-robin fashion. The buckets/blocks inside each thread space get assigned a new number 852 that is incremented each time a new bucket/block gets assigned. For each valid source in the bucket 850, The valid sources for each bucket has a valid read bit “Rv” indicating that this source is needed for the instructions inside this bucket. By the same convention, each destination register that is to be written back by instructions in this bucket has a valid bit “Wv” set in the bucket and it has a field in a destination inheritance vector 853. When a new bucket is to be fetched into the bucket buffer it inherits the destination inheritance vector from the previous allocated bucket pointed at by the thread bucket allocation pointer 852. The inheritance vector is copied from the previously allocated bucket and then it overwrites those valid destination fields that correspond to the registers which will be updated by those bucket instructions. The valid destinations will be labeled with the current bucket number, while the invalid destinations are copied from the corresponding inheritance vector inside the bucket. Then the thread bucket pointer is updated for the new fetched bucket by incrementing its pointer (it wraps around within its interval).
In the bucket dispatch and execute stage, whenever a bucket is executed without any exception handling, then the bucket execution flag (containing the bucket number) 854 is set and broadcasted through out the bucket buffer and is latched/monitored within each bucket that has a source with that bucket number as a source. It is also possible to pass other related information along the bucket number, such as information about virtual registers locations. When all the execution flags of the sources buckets are set within a bucket, then that bucket ready bit 855 is set and the bucket is ready to be dispatched and executed. When the bucket executes without any exception and it is ready to update the architecture state in the sequential order of the program, then it retires the bucket and the retirement thread pointer 857 is incremented to the next bucket in the array. The retired bucket location can be assigned to a new bucket.
Those closely related threads can all coexist inside the Matrix/bucket/block buffer; each thread will occupy an interval of consecutive buckets that belongs to that thread. The allocation pointer of that thread moves inside this interval of buckets in a round robin fashion fetching new instruction buckets and allocating them inside the thread interval in the described round robin fashion. With such interval sectioning, the whole bucket buffer is divided dynamically with different or equal interval lengths of buckets.
The concept of inheritance vector is introduced here for the instruction bucket as well as for the thread. Each instruction matrix/block/bucket writes into particular registers among the architectural registers. Each new bucket upon allocation stage updates this inheritance vector writing the thread and bucket number of its own into this vector leaving the fields for the registers that it does not write into un-updated. This bucket inheritance vector B_iv 856 is forwarded from each bucket to the next one in program order. In
This concept scales from a bucket buffer managing a small number of closely coupled threads into hardware circuits that manage multiple bucket buffers and threads as shown by way of implementation example in
This global front-end fetches only the headers of the threads/blocks in program order and generates dynamic thread and/or bucket inheritance vectors 901 (Tiv and/or Biv). Each time a new thread is allocated, those inheritance vectors are forwarded by keeping the old fields that the current thread bucket will not write to or update as shown 903. Those inheritance vectors are distributed to a large number of engines/cores or processors 904 each of which might include a local front-end and a fetch unit (which will fetch and store the actual instructions produce the dependency vector for each bucket) and a local matrix/block/bucket buffer with local register files 905. The local front-ends then fetch the actual instructions and use the information from the inheritance vectors obtained from the global front end to fill the dependency information for the instruction sources of the instructions that are brought into those engines for execution.
One interesting observation is that the register files allow cross communication among the cores/engines. An early request (to reduce the access latency) of the registers that are needed from cross engines can be placed as soon as the instruction buckets of the thread are fetched and allocated in the local bucket buffer at that time the source dependency information is populated such that cross engine threads references can be issued at that time probably long before the actual instructions are dispatched for execution. In any case, the instruction will not be dispatched until the cross referenced source is forwarded and arrived. This cross referenced source can be stored in the local multi-threaded register file or register cache. Although this cross referenced source can be stored in a buffer similar to the load store buffer (it can reuse the load store buffer physical storage and dependency check mechanisms but as a register load instead of memory load). Many topologies can be used to connect the register files across the engines/cores, which may be a ring topology or cross bar topology or mesh routed interconnect.
The following discussion can illustrate how register file segmentation can be used inside an engine and also across engines. When the bucket is dispatched, its sources are sent to both (simultaneously or sequentially) to the register file and the register cache. If the register file is physically unified and has direct support for threading, then the operand is read directly from the corresponding thread register section. If the register file is a virtual register, including a physically segmented register file that uses tags, then a tag match has to be done as a part of the virtual register read. If the tag matches, then the read happens from the segmented register file.
To allow for the option of keeping the instruction scheduling as composed by compiler auto parallelization or VLIW or SMID/MIMD composition without allowing the hardware to rearrange the section buckets independently, a locking mechanism is employed through the use of a bit or a flag that locks the 4 buckets together as a super bucket. If this bit or flag is set, then all the buckets within the super bucket (in this case 4 buckets) will execute in parallel within the same cycle. If the flag is not set, then those buckets are not locked to execute together and can be independently executed at various times.
Increased parallelism that results from threading or out-of-order execution or VLIW architectures puts huge pressure on the limited bandwidth register file. Usually register files are designed as a unified resource to allow access to all registers. Segmented register files have been designed before, but they have required handling of cross reads/writes at the architecture/software level, which prevents them from being utilized as a unified set of resources and adds overhead to the cross reads/writes.
Disclosed is register architecture that supports software threads, hardware generated threads, VLIW execution, SIMD & MIMD execution as well as emulation of out-of-order super-scalar execution. Although it is physically segmented, it looks as a unified architecture resource. This segmented register is part of the virtual register file which might include a register hierarchy and a register cache as well as mechanisms to store and check register tags. The tag access can be eliminated if we use a location based scheme that takes advantage of the dependency inheritance vector. The scheme works such that when the executed bucket number is broadcasted during dispatch stage all the sources of subsequent instructions perform a CAM (content addressable match) which compares their sources buckets with the just dispatched/executed bucket to set the ready flag for that source. Here the physical location of where that bucket executed can also be propagated along with the register number so that any ambiguity is resolved. For example in
The following is a description of an implementation of a unified dynamic execution architecture capable of issuing SIMD/MIMD, VLIW, ULIB bucket instructions as well as Dynamic and Static threading. The architecture also supports emulating a super scalar out-of-order implementation without the explicit support of out-of-order components. The invention may also encompass a physically segmented, architecturally unified register file and a possible register cache hierarchy.
The disclosed techniques allow for both software initiated threads (static threads) as well as hardware generated threads (dynamic threads) to be executed using one unified method and implementation. As mentioned earlier, fine grain parallelism is hard to identify at the software static optimization level and thus the dynamic threading is a way that the hardware can generate this fine level parallelism by assigning dynamic thread contexts to software buckets, such as function calls, methods subroutines/procedures, independent object codes or parallel loops. This is accomplished with the disclosed implementation and method by reserving a few of the threads and their bit identification fields to the dynamic threads. For example, in the above implementation, the hardware dynamic threads can be assigned a subset thread group out of the “m” threads available. The hardware can use those allocated thread reservations to dynamically generate and/or issue hardware threads. For example, upon a function call or subroutine call (as indicated by an assembly “Call” instruction), the hardware can assign a new hardware thread to such call and eventually can claim back the thread reservation after the return function. The same can be said about loops where a hardware thread can be generated at the entrance of a loop (as indicated by an assembly “Loop” instruction) and can be reclaimed after the loop reaches its end instruction. Other instructions can also be used for possible hardware threading opportunities that map directly to software threading-applicable events, such as Object oriented method executions or object associated codes or any high level or object oriented programming thread opportunities. In all cases the synchronization of those threads can be resolved through register/bucket cross referencing and control flags, which can be tracked and resolved by the earlier described mechanisms.
Again the thread header encapsulates the destination registers of each bucket within the loop body 1004 as well as the code outside the loop body. The hardware or the compiler in this case is allocating a thread T1 to the code before the loop body, and as an example only one thread to the loop body T2 (multiple threads can be assigned to the loop body by splitting the loop into multiple iterations to the extent where each loop iteration can be assigned to a thread, the amount of loop threading is a dynamic decision that can be decided at run time or based on compiler analysis) while the code after the loop is assigned to thread T3.
Note that the inheritance vector 1005 generated by the buckets of the loop body feeding back to the loop body itself T2 is slightly different from that inheritance vector 1005 forwarded to the thread outside the loop body T3. This is because T3 needs the last copy of the registers iterated on by the loop, this last copy is indicated in the inheritance vector 1002 by n. When the last iteration of the loop is reached then all the buckets in that last iteration carries a flag n that is set as a part of the bucket number (i.e., most significant bit).
T3 registers that depend on the loop body of T2 will depend on this last iteration n of the iterative loop of T2. This is what will also be recorded in the forwarded inheritance vector for T3. The assumption here is that T2 does not have any control path internally that changes the update of the loop registers to be at a different iteration instead of the last iteration, predication can be used to resolve such control path if it exists internal to the loop body. The identifier n can be carried and forwarded as a part of the inheritance vector as in 1003. It basically refers to the buckets that compose the last iteration of the loop. In addition, these dynamic threads can be assigned to branching code (the code that follows a branch or a control change).
The technique can be used to issue 2 threads, one along each of the 2 possibilities of a branch. In such a case, one of the threads commits and the other is thrown away once the branch is resolved architecturally. To take care of the case where the 2 different control paths affect different registers, the inheritance forwarding vector will specify the flag condition F that the inheritance will embed into its bucket number field 1101. In this case, each source in the dependent buckets on this control path will specify the condition flag within the inheritance vector 1102 for those source registers that are impacted by the variable path of control. The flag will be broadcasted with the bucket number that executes/resolves that flag to all dependent buckets during the CAM dispatch match. This is illustrated in
Another innovation is the inclusion of a flag field within each architecture register, such that each architecture or physical register has a flag field as part of the visible state. This allows for a simple predication mechanism for conditional execution of an instruction and the ability to easily create delay slots for branch instructions. For example, in a loop, the test instruction that tests the loop end condition has to be preceding the branch instruction with no other flag modifying instructions in between. Using the register flag field, and by specifying that this branch depends on the flag of a particular register (the destination of the test instruction in this example), the test condition could be placed at the beginning of the loop while the actual branch can be at the end of the loop. Therefore, by the time the branch instruction is at the front end of the machine, the test instruction has already been executed and the branch can execute at the front end stage rather than at the execution stage, thus removing bubbles. Those register flags also facilitate simple instruction predication or thread predication, where instructions or instructions in a particular thread can be predicated based upon the result of a particular instruction that does not need to be preceding it immediately in the execution sequence. This is illustrated in
Moreover as shown in
The handling of memory cross referencing by threads is another key element in the thread auto generation and auto synchronization. Those references are made using memory accesses by loads and stores.
In
This mechanism also serves also as a coherency scheme for the memory architecture among those engines/cores/processors. This scheme starts by an address request from one of the address calculation units in one segment/core/processor. For example, assume the address is requested by segment 1 (1211). It can obtain and calculate its address using address registers that belong to its own segment and or from registers across other segments using the address interconnect bus 1200. After calculating the address it creates the reference address of either 32-bit address or 64-bit address that is used to access caches and memory. This address is usually fragmented into a tag field and a set and line fields. This particular segment/engine/core will store the address into its load store buffer and/or L1 and/or L2 address arrays 1202, at the same time it will create a compressed version of the tag (with smaller number of bits than the original tag field of the address) by using a compression technique. More the different segments/engines/cores/processors will use the set field or a subset of the set field as an index to identify which segment/core/processor the address is maintained in. This indexing of the segments by the address set field bits ensures exclusiveness of ownership of the address in a particular segment/core/engine even though the memory data that corresponds to that address can live in another or multiple other segments/engines/cores/processors. Even though the address CAM/tag arrays 1202/1206 are shown in each segment to be coupled with the data arrays 1207, they might be only coupled in physical proximity of placement and layout or even by the fact that both belongs to a particular engine/core/processor, but there is no relation between addresses kept in the address arrays and the data in the data arrays inside one segment. After the compressed address tag is formed, the set's field bits are used to identify the particular address CAM array 1202 that the request will be addressed to. Let us assume that it turned out that those set field bits identified segment/engine/core/processor N as the one that owns that address scope, then the compressed tag is sent to that segment/engine/core/processor (segment N) L1 CAM and/or corresponding L2 CAM arrays that will then perform Content address match (CAM) between the incoming compressed tag and the compressed tags it stores in its array. Since this is a compressed tag the CAM array width is minimal and thus we can afford to build a Cam array that has a similar number of entries to the data array (usually CAM arrays are very expensive and power hungry). After the CAM match is done it can result in hit or a miss or multiple hits (a good compression technique should reduce the number of multiple hits) Then in a case of hit/multiple hits the Loc array (location array) 1203 corresponding to the CAM hit entry in segment N is read to identify the location of the memory data that belongs to this address CAM hit. This location is sent back to the requesting address calculation unit in requesting segment (in this example segment 1). That address calculation unit request buffer 1204 sends the full address to the Address/Tag array of that location 1206 using the address bus of the interconnect 1205. Then a tag look up and compare is performed to ensure a confirmed/unique hit. Then if the hit is confirmed the data is returned using the data bus of interconnect 1205. If a miss happened in either the CAM or the complete Tag array, a request to the main memory is put on behalf of the requesting segment. It is possible also to cut the latency more and send the full address to the segment that owns that address scope (using the set field bits as an index) as described before, and at that segment the compressed tag is formed and accesses the CAM array first while the full address is held there till the result of the CAM is checked and the location array 1203 is read to identify the entry numbers in the tag array 1206 that was a hit in the compressed tag 1202. Then the full compare is done on the full address using comparators as opposed to the CAM. The implementation of the CAM array 1202 does not really need to be performing a CAM, since this compare is to be done on few bits that are obtained from the full tag and compressed, the CAM array can be implemented as a direct indexed memory array (RAM) or register file, for example if the compressed tag is formed as an 8-bit word then the whole CAM array of each segment can be constructed as a 256 entry RAM array, when the 8-bit compressed tag comes it directly gets decoded to read one of the 256 entries of the Location array 1202 (in reality for such case of 8-bit compressed tag, the CAM array does not need to exist as a physical array), it actually only need to be used as the decoder for the location array 1203.
Next we will describe a scheme that defines memory latency reduction by issuing memory loads a head of time without increasing register pressure by defining transient storage variables called “Temp” and “Chain”. Temp is used only once to allow an instruction to refer to a location in memory and prefetch it to a particular location in the cache buffer, This is different from typical schemes of data prefetching to the cache because with Temps and chains there is a direct 1 to 1 mapping between the Temp prefetched value and its consuming instruction; similar to what a register assignment might achieve, On the contrary, in typical cache prefetching schemes the memory data is prefetched into an address location in the cache, the consuming instruction can only reference this prefetched data by its memory address. Which Is not known to the scheduler of the consuming instruction, thus the consumer instruction has no control over finding the data when it executes. In the case of the new Temp and chain schemes described here, the memory data is brought into the cache buffer (loaded into the cache) and is assigned a name “e.g. Temp0”, the consuming instruction of this loaded data can now refer explicitly the Temp 0 name and expect to find it in the Temp 0 location with absolute guarantee when it executes, Because the Temp number is indicated as a source of dependency in the consuming instruction, thus the scheduler will not issue that instruction until the Temp is valid (the data was actually loaded from higher level caches or memory) similar to what happens when a memory value is loaded into a register. This has an extra benefit beside precise prefetching (1 to 1 mapping) and precise scheduling of the consuming instruction which is allowing for variable latency distributed caches as shown in
To prevent destruction of the Temp and Chain before their consumer instructions freed them, the compiler will ensure that it will not reassign that register until its consumer instruction consumes it.
There are a few differences between a register assignment and Temp assignment; the Temp is used to bring the needed data into a transient location in the Cache buffer that get automatically de-allocated upon the consumption of that value by the consuming instruction (the instruction that references that transient location), this will insure that the live range of this temp is short and thus it is used very efficiently. One way the Temp can be assigned in a program is through using a label that goes with the load address calculation instruction (or with the address calculation instruction bucket) i.e:
The labels for the temps that are to be used within a code segment or function must be allocated before they are used. So if the compiler is intending to use 10 Temp locations for prefetching its data, it should use an allocate instruction/routine that allocates those Temp locations in the cache/buffer. After each instruction consumes its Temp, the Temp location will be free. The hardware can reallocate those Temp locations/labels for another function through a context switch; this is possible by making the cache/buffer that stores the Temp data allocated with thread ID tagging. The hardware will assign a new thread ID and new Temp locations upon encountering the Label allocate instruction of the new function. If there is no space to occupy for a new thread in the cache/buffer, then during the execution of the allocate instruction/routine, the temp locations that are not free (because their instructions did not consume them yet) will get saved/stored in memory with the rest of the old thread context that is being switched. Those Temp data need to be restored and loaded back when that old thread context is brought back to continue execution. This will take care of unexpected executions of context switch (e.g. upon a call to an exception handler or a system call).
Chains are similar to Temps with 2 differences: the chain is a sequence of locations as oppose to just one, secondly the whole chain is labeled with one label no matter how many elements “locations” it has. Chain needs to be allocated using an allocation instruction/routine similar to the temp. Similarly, upon executing this allocate instruction if there is no new thread space for that chain in the cache/buffer that can be assigned to the new thread chain then that particular chain elements are checked to see which ones are already freed (because their consuming instructions used them) the ones that are not freed will be saved to memory and the new thread chain can use that space.
Chains allows to create a 1 to 1 mapping between a list of prefetching/loading instructions and the consuming instructions to allow obtaining an effect similar to having a register with a variable name number e.g. R(i). This is useful in accessing arrays inside loops where the chain can start prefetching the values inside the loop long before the consuming instruction in the loop need them, But without creating a register pressure. A cache structure or cache buffer can be used to store those Temp and chain elements.
The scheme uses a qualifier in the Temp assigning instruction 1503 (the prefetch/load instruction). This temp assigning/prefetch instruction brings the data into the transient location in the cache it does not perform any ordering checks on the address (finding out id the address of the load matches that of a store that did not execute yet, This order check is done to prevent the load from bringing data from memory that is not yet updated by a store that precedes the load in sequential execution). The ordering check will be performed when the consuming instruction 1504 executes, at that point if the ordering check finds that the address of the prefetch is loading from the same address of the preceding store the consuming instruction 1504 will use a bypass mechanism to get the store value instead of the Temp value. The bypass mechanism can be implemented along the order checking process performed as part of the execution phase of the consuming instruction 1504 by inspecting the store buffer for a matching address and if one is found for an earlier store that was executed after the temp instruction loaded data from memory then the value of that store will be bypassed to the consuming instruction instead of the temp value. The consuming instruction itself can be executed speculatively ahead of the store instruction by using the same thread control speculation that we discussed in
We showed throughout this invention description by way of example the implementation schemes using Temp, chains and instruction buckets but the schemes that we described can be applied to loads or single instructions in general.
Also the synchronization and coherency schemes that we illustrated does not only apply to distributed caches or separate address register files, they can also be used with centralized caches among different processors and they can also be used partially or by trivial modifications to the schemes.
An embodiment of the present invention relates to a computer storage product with a computer-readable medium having computer code thereon for performing various computer-implemented operations. The media and computer code may be those specially designed and constructed for the purposes of the present invention, or they may be of the kind well known and available to those having skill in the computer software arts. Examples of computer-readable media include, but are not limited to: magnetic media such as hard disks, floppy disks, and magnetic tape; optical media such as CD-ROMs, DVDs and holographic devices; magneto-optical media; and hardware devices that are specially configured to store and execute program code, such as application-specific integrated circuits (“ASICs”), programmable logic devices (“PLDs”) and ROM and RAM devices. Examples of computer code include machine code, such as produced by a compiler, and files containing higher-level code that are executed by a computer using an interpreter. For example, an embodiment of the invention may be implemented using Java, C++, or other object-oriented programming language and development tools. Another embodiment of the invention may be implemented in hardwired circuitry in place of, or in combination with, machine-executable software instructions.
The foregoing description, for purposes of explanation, used specific nomenclature to provide a thorough understanding of the invention. However, it will be apparent to one skilled in the art that specific details are not required in order to practice the invention. Thus, the foregoing descriptions of specific embodiments of the invention are presented for purposes of illustration and description. They are not intended to be exhaustive or to limit the invention to the precise forms disclosed; obviously, many modifications and variations are possible in view of the above teachings. The embodiments were chosen and described in order to best explain the principles of the invention and its practical applications, they thereby enable others skilled in the art to best utilize the invention and various embodiments with various modifications as are suited to the particular use contemplated. It is intended that the following claims and their equivalents define the scope of the invention.
100011 This application is a continuation of U.S. application Ser. No. 15/357,943 filed Nov. 21, 2016 (U.S. Pat. No. 9,965,281), which is a continuation of U.S. application Ser. No. 14/194,589 filed Feb. 28, 2014 (U.S. Pat. No. 9,501,280), which is a continuation of U.S. application Ser. No. 12/514,303 entered Jan. 5, 2010 (U.S. Pat. No. 8,677,105), which is a national stage of International Application No. PCT/US2007/084710 filed Nov. 14, 2007, which claims priority to U.S. Provisional Application Nos. 60/865,813, 60/865,816, 60/865,818, and 60/865,820, each filed Nov. 14, 2006, which are hereby incorporated by reference.
| Number | Name | Date | Kind |
|---|---|---|---|
| 727487 | Swan | May 1903 | A |
| 4075704 | O'Leary | Feb 1978 | A |
| 4245344 | Richter | Jan 1981 | A |
| 4356550 | Katzman et al. | Oct 1982 | A |
| 4414624 | Summer, Jr. et al. | Nov 1983 | A |
| 4524415 | Mills, Jr. et al. | Jun 1985 | A |
| 4527237 | Frieder et al. | Jul 1985 | A |
| 4577273 | Hopper et al. | Mar 1986 | A |
| 4597061 | Cline et al. | Jun 1986 | A |
| 4600986 | Scheuneman et al. | Jul 1986 | A |
| 4633434 | Scheuneman | Dec 1986 | A |
| 4682281 | Woffinden et al. | Jul 1987 | A |
| 4727487 | Masui et al. | Feb 1988 | A |
| 4816991 | Watanabe et al. | Mar 1989 | A |
| 4835680 | Hogg et al. | May 1989 | A |
| 4920477 | Colwell et al. | Apr 1990 | A |
| 4930066 | Yokota | May 1990 | A |
| 4943909 | Huang | Jul 1990 | A |
| 5197130 | Chen et al. | Mar 1993 | A |
| 5294897 | Notani et al. | Mar 1994 | A |
| 5317705 | Gannon et al. | May 1994 | A |
| 5317754 | Blandy et al. | May 1994 | A |
| 5339398 | Shah et al. | Aug 1994 | A |
| 5404470 | Miyake | Apr 1995 | A |
| 5469376 | Abdallah | Nov 1995 | A |
| 5471593 | Branigin | Nov 1995 | A |
| 5509130 | Trauben et al. | Apr 1996 | A |
| 5517651 | Huck et al. | May 1996 | A |
| 5524090 | Iwamura | Jun 1996 | A |
| 5548742 | Wang et al. | Aug 1996 | A |
| 5559986 | Alpert et al. | Sep 1996 | A |
| 5574878 | Onodera et al. | Nov 1996 | A |
| 5581725 | Nakayama | Dec 1996 | A |
| 5590084 | Miyano et al. | Dec 1996 | A |
| 5634068 | Nishtala et al. | May 1997 | A |
| 5649136 | Shen et al. | Jul 1997 | A |
| 5675759 | Shebanow et al. | Oct 1997 | A |
| 5699537 | Sharangpani et al. | Dec 1997 | A |
| 5710902 | Sheaffer et al. | Jan 1998 | A |
| 5724565 | Dubey et al. | Mar 1998 | A |
| 5751982 | Morley | May 1998 | A |
| 5752260 | Liu | May 1998 | A |
| 5754818 | Mohamed | May 1998 | A |
| 5761476 | Martell | Jun 1998 | A |
| 5787494 | Delano et al. | Jul 1998 | A |
| 5793941 | Pencis et al. | Aug 1998 | A |
| 5802602 | Rahman et al. | Sep 1998 | A |
| 5806085 | Berliner | Sep 1998 | A |
| 5813031 | Chou et al. | Sep 1998 | A |
| 5819088 | Reinders | Oct 1998 | A |
| 5829028 | Lynch et al. | Oct 1998 | A |
| 5835951 | McMahan | Nov 1998 | A |
| 5852738 | Bealkowski et al. | Dec 1998 | A |
| 5860146 | Vishin et al. | Jan 1999 | A |
| 5864657 | Stiffler | Jan 1999 | A |
| 5872985 | Kimura | Feb 1999 | A |
| 5881277 | Bondi et al. | Mar 1999 | A |
| 5901294 | Tran et al. | May 1999 | A |
| 5903750 | Yeh et al. | May 1999 | A |
| 5905509 | Jones et al. | May 1999 | A |
| 5911057 | Shiell | Jun 1999 | A |
| 5918251 | Yamada et al. | Jun 1999 | A |
| 5956753 | Glew et al. | Sep 1999 | A |
| 5974506 | Sicola et al. | Oct 1999 | A |
| 5978906 | Tran | Nov 1999 | A |
| 5983327 | Achilles et al. | Nov 1999 | A |
| 6016533 | Tran | Jan 2000 | A |
| 6016540 | Zaidi et al. | Jan 2000 | A |
| 6021484 | Park | Feb 2000 | A |
| 6065105 | Zaidi et al. | May 2000 | A |
| 6073230 | Pickett et al. | Jun 2000 | A |
| 6075938 | Bugnion et al. | Jun 2000 | A |
| 6085315 | Fleck et al. | Jul 2000 | A |
| 6088780 | Yamada et al. | Jul 2000 | A |
| 6092172 | Nishimoto et al. | Jul 2000 | A |
| 6101577 | Tran | Aug 2000 | A |
| 6108769 | Chinnakonda et al. | Aug 2000 | A |
| 6115809 | Mattson, Jr. et al. | Sep 2000 | A |
| 6134634 | Marshall, Jr. et al. | Oct 2000 | A |
| 6138226 | Yoshioka et al. | Oct 2000 | A |
| 6157998 | Rupley, II et al. | Dec 2000 | A |
| 6167490 | Levy et al. | Dec 2000 | A |
| 6170051 | Dowling | Jan 2001 | B1 |
| 6178482 | Sollars | Jan 2001 | B1 |
| 6185660 | Mulla et al. | Feb 2001 | B1 |
| 6205545 | Shah et al. | Mar 2001 | B1 |
| 6209085 | Hammond et al. | Mar 2001 | B1 |
| 6212542 | Kahle et al. | Apr 2001 | B1 |
| 6212613 | Belair | Apr 2001 | B1 |
| 6216215 | Palanca et al. | Apr 2001 | B1 |
| 6226732 | Pei et al. | May 2001 | B1 |
| 6247097 | Sinharoy | Jun 2001 | B1 |
| 6253316 | Tran et al. | Jun 2001 | B1 |
| 6256727 | McDonald | Jul 2001 | B1 |
| 6256728 | Witt et al. | Jul 2001 | B1 |
| 6260131 | Kikuta et al. | Jul 2001 | B1 |
| 6260138 | Harris | Jul 2001 | B1 |
| 6269439 | Hanaki | Jul 2001 | B1 |
| 6272616 | Fernando et al. | Aug 2001 | B1 |
| 6272662 | Jadav et al. | Aug 2001 | B1 |
| 6275917 | Okada | Aug 2001 | B1 |
| 6282583 | Pincus et al. | Aug 2001 | B1 |
| 6282638 | Dowling | Aug 2001 | B1 |
| 6308323 | Douniwa | Oct 2001 | B1 |
| 6321298 | Hubis | Nov 2001 | B1 |
| 6327650 | Bapst et al. | Dec 2001 | B1 |
| 6332189 | Baweja et al. | Dec 2001 | B1 |
| 6339822 | Miller | Jan 2002 | B1 |
| 6341324 | Caulk, Jr. et al. | Jan 2002 | B1 |
| 6345357 | Sato | Feb 2002 | B1 |
| 6360311 | Zandveld et al. | Mar 2002 | B1 |
| 6408367 | Achilles et al. | Jun 2002 | B2 |
| 6437789 | Tidwell et al. | Aug 2002 | B1 |
| 6449671 | Patkar et al. | Sep 2002 | B1 |
| 6457120 | Sinharoy | Sep 2002 | B1 |
| 6473833 | Arimilli et al. | Oct 2002 | B1 |
| 6490673 | Heishi et al. | Dec 2002 | B1 |
| 6502187 | Miyagawa | Dec 2002 | B1 |
| 6529928 | Resnick et al. | Mar 2003 | B1 |
| 6542984 | Keller et al. | Apr 2003 | B1 |
| 6557083 | Sperber et al. | Apr 2003 | B1 |
| 6557095 | Henstrom | Apr 2003 | B1 |
| 6594755 | Nuechterlein et al. | Jul 2003 | B1 |
| 6604187 | McGrath et al. | Aug 2003 | B1 |
| 6609189 | Kuszmaul et al. | Aug 2003 | B1 |
| 6615340 | Wilmot, II | Sep 2003 | B1 |
| 6658549 | Wilson et al. | Dec 2003 | B2 |
| 6668316 | Gorshtein et al. | Dec 2003 | B1 |
| 6681395 | Nishi | Jan 2004 | B1 |
| 6704860 | Moore | Mar 2004 | B1 |
| 6721874 | Le et al. | Apr 2004 | B1 |
| 6728866 | Kahle et al. | Apr 2004 | B1 |
| 6775761 | Wang et al. | Aug 2004 | B2 |
| 6829698 | Arimilli et al. | Dec 2004 | B2 |
| 6850531 | Rao et al. | Feb 2005 | B1 |
| 6882177 | Reddy et al. | Apr 2005 | B1 |
| 6907600 | Neiger et al. | Jun 2005 | B2 |
| 6912644 | O'Connor et al. | Jun 2005 | B1 |
| 6920530 | Musumeci | Jul 2005 | B2 |
| 6944744 | Ahmed et al. | Sep 2005 | B2 |
| 6948172 | D'Souza | Sep 2005 | B1 |
| 6950927 | Apisdorf et al. | Sep 2005 | B1 |
| 6954846 | Leibholz et al. | Oct 2005 | B2 |
| 6985591 | Graunke | Jan 2006 | B2 |
| 6988183 | Wong | Jan 2006 | B1 |
| 7007108 | Emerson et al. | Feb 2006 | B2 |
| 7020879 | Nemirovsky et al. | Mar 2006 | B1 |
| 7047322 | Bauman et al. | May 2006 | B1 |
| 7111145 | Chen et al. | Sep 2006 | B1 |
| 7117347 | Col et al. | Oct 2006 | B2 |
| 7139855 | Armstrong et al. | Nov 2006 | B2 |
| 7143273 | Miller et al. | Nov 2006 | B2 |
| 7149872 | Rozas et al. | Dec 2006 | B2 |
| 7150021 | Vajjhala et al. | Dec 2006 | B1 |
| 7171535 | Naoi | Jan 2007 | B2 |
| 7203824 | Bean et al. | Apr 2007 | B2 |
| 7206925 | Jacobson et al. | Apr 2007 | B1 |
| 7213106 | Koster et al. | May 2007 | B1 |
| 7213248 | Arimilli et al. | May 2007 | B2 |
| 7231106 | Basavanhally et al. | Jun 2007 | B2 |
| 7257695 | Jiang et al. | Aug 2007 | B2 |
| 7278030 | Chen et al. | Oct 2007 | B1 |
| 7284092 | Nunamaker et al. | Oct 2007 | B2 |
| 7290261 | Burky et al. | Oct 2007 | B2 |
| 7313775 | Casey et al. | Dec 2007 | B2 |
| 7343476 | Floyd et al. | Mar 2008 | B2 |
| 7373637 | Dewitt et al. | May 2008 | B2 |
| 7380096 | Rozas et al. | May 2008 | B1 |
| 7383427 | Yamazaki | Jun 2008 | B2 |
| 7398347 | Pechanek et al. | Jul 2008 | B1 |
| 7406581 | Southwell et al. | Jul 2008 | B2 |
| 7418579 | Guibert et al. | Aug 2008 | B2 |
| 7418582 | Iacobovici et al. | Aug 2008 | B1 |
| 7441110 | Puzak et al. | Oct 2008 | B1 |
| 7493475 | Colavin | Feb 2009 | B2 |
| 7539879 | Terechko et al. | May 2009 | B2 |
| 7546420 | Shar et al. | Jun 2009 | B1 |
| 7577820 | Wentzlaff et al. | Aug 2009 | B1 |
| 7613131 | Decasper et al. | Nov 2009 | B2 |
| 7617384 | Coon et al. | Nov 2009 | B1 |
| 7627735 | Espasa | Dec 2009 | B2 |
| 7634637 | Lindholm et al. | Dec 2009 | B1 |
| 7647483 | Bates et al. | Jan 2010 | B2 |
| 7680988 | Nickolls et al. | Mar 2010 | B1 |
| 7681019 | Favor | Mar 2010 | B1 |
| 7707397 | Henry et al. | Apr 2010 | B2 |
| 7707578 | Zedlewski et al. | Apr 2010 | B1 |
| 7711929 | Burky et al. | May 2010 | B2 |
| 7716460 | Stempel et al. | May 2010 | B2 |
| 7743238 | Biles | Jun 2010 | B2 |
| 7757065 | Jourdan et al. | Jul 2010 | B1 |
| 7770161 | Mitran et al. | Aug 2010 | B2 |
| 7783868 | Ukai | Aug 2010 | B2 |
| 7783869 | Grandou et al. | Aug 2010 | B2 |
| 7809925 | Mejdrich et al. | Oct 2010 | B2 |
| 7848129 | Deshpande et al. | Dec 2010 | B1 |
| 7856530 | Mu | Dec 2010 | B1 |
| 7861055 | Pong | Dec 2010 | B2 |
| 7861060 | Nickolls et al. | Dec 2010 | B1 |
| 7877582 | Gschwind et al. | Jan 2011 | B2 |
| 7913058 | Rozas et al. | Mar 2011 | B2 |
| 7925869 | Kelsey et al. | Apr 2011 | B2 |
| 8044951 | Brown et al. | Oct 2011 | B1 |
| 8046775 | Kang et al. | Oct 2011 | B2 |
| 8082420 | Comparan et al. | Dec 2011 | B2 |
| 8108545 | Arimilli et al. | Jan 2012 | B2 |
| 8108625 | Coon | Jan 2012 | B1 |
| 8145844 | Bruce | Mar 2012 | B2 |
| 8145880 | Cismas et al. | Mar 2012 | B1 |
| 8145882 | Kishore et al. | Mar 2012 | B1 |
| 8200949 | Tarjan et al. | Jun 2012 | B1 |
| 8219996 | Morris | Jul 2012 | B1 |
| 8230423 | Frigo et al. | Jul 2012 | B2 |
| 8239656 | Rozas et al. | Aug 2012 | B2 |
| 8301847 | Dantzig et al. | Oct 2012 | B2 |
| 8316435 | Varadhan et al. | Nov 2012 | B1 |
| 8327115 | Abdallah | Dec 2012 | B2 |
| 8438366 | Akizuki et al. | May 2013 | B2 |
| 8522253 | Rozas et al. | Aug 2013 | B1 |
| 8539486 | Cain, III et al. | Sep 2013 | B2 |
| 8645965 | Zimmer et al. | Feb 2014 | B2 |
| 8756329 | Reynolds et al. | Jun 2014 | B2 |
| 8868838 | Glasco et al. | Oct 2014 | B1 |
| 8930674 | Avudaiyappan et al. | Jan 2015 | B2 |
| 9021240 | Alexander et al. | Apr 2015 | B2 |
| 9047178 | Talagala et al. | Jun 2015 | B2 |
| 9135003 | Suh et al. | Sep 2015 | B2 |
| 9575762 | Abdallah | Feb 2017 | B2 |
| 9811342 | Abdallah et al. | Nov 2017 | B2 |
| 9811377 | Abdallah et al. | Nov 2017 | B2 |
| 9823930 | Abdallah et al. | Nov 2017 | B2 |
| 9858080 | Abdallah | Jan 2018 | B2 |
| 10140138 | Abdallah et al. | Nov 2018 | B2 |
| 10198266 | Abdallah | Feb 2019 | B2 |
| 20010004755 | Levy | Jun 2001 | A1 |
| 20010016901 | Topham | Aug 2001 | A1 |
| 20010032303 | Pechanek et al. | Oct 2001 | A1 |
| 20010049782 | Hsu et al. | Dec 2001 | A1 |
| 20020029308 | Babaian et al. | Mar 2002 | A1 |
| 20020062435 | Nemirovsky et al. | May 2002 | A1 |
| 20020069326 | Richardson et al. | Jun 2002 | A1 |
| 20020082824 | Neiger et al. | Jun 2002 | A1 |
| 20020083312 | Sinharoy | Jun 2002 | A1 |
| 20020099913 | Steely et al. | Jul 2002 | A1 |
| 20020125585 | Slamowitz | Sep 2002 | A1 |
| 20020126657 | Frouin et al. | Sep 2002 | A1 |
| 20020129085 | Kubala et al. | Sep 2002 | A1 |
| 20020174321 | John et al. | Nov 2002 | A1 |
| 20020188833 | Henry et al. | Dec 2002 | A1 |
| 20030035422 | Hill | Feb 2003 | A1 |
| 20030065887 | Maiyuran et al. | Apr 2003 | A1 |
| 20030088752 | Harman | May 2003 | A1 |
| 20030093776 | Hilton | May 2003 | A1 |
| 20030101322 | Gardner | May 2003 | A1 |
| 20030101444 | Wu et al. | May 2003 | A1 |
| 20030126408 | Vajapeyam et al. | Jul 2003 | A1 |
| 20030131335 | Hamlin | Jul 2003 | A1 |
| 20030149862 | Kadambi | Aug 2003 | A1 |
| 20030154363 | Soltis, Jr. | Aug 2003 | A1 |
| 20030163642 | Borkenhagen et al. | Aug 2003 | A1 |
| 20030169626 | Burk et al. | Sep 2003 | A1 |
| 20030200396 | Musumeci | Oct 2003 | A1 |
| 20030200412 | Peinado et al. | Oct 2003 | A1 |
| 20030202530 | Jenkins et al. | Oct 2003 | A1 |
| 20030225938 | Glasco et al. | Dec 2003 | A1 |
| 20030226001 | Moyer et al. | Dec 2003 | A1 |
| 20030229864 | Watkins | Dec 2003 | A1 |
| 20030233394 | Rudd et al. | Dec 2003 | A1 |
| 20040034762 | Kacevas | Feb 2004 | A1 |
| 20040044850 | George et al. | Mar 2004 | A1 |
| 20040064668 | Kjos et al. | Apr 2004 | A1 |
| 20040073909 | Arimilli et al. | Apr 2004 | A1 |
| 20040078538 | Dutt et al. | Apr 2004 | A1 |
| 20040093483 | Nguyen et al. | May 2004 | A1 |
| 20040098567 | Hansen et al. | May 2004 | A1 |
| 20040103251 | Alsup | May 2004 | A1 |
| 20040117593 | Uhlig et al. | Jun 2004 | A1 |
| 20040117594 | Vanderspek | Jun 2004 | A1 |
| 20040122887 | Macy | Jun 2004 | A1 |
| 20040138857 | Souza et al. | Jul 2004 | A1 |
| 20040139441 | Kaburaki et al. | Jul 2004 | A1 |
| 20040143727 | McDonald | Jul 2004 | A1 |
| 20040158822 | Sandham et al. | Aug 2004 | A1 |
| 20040172523 | Merchant et al. | Sep 2004 | A1 |
| 20040187123 | Tremblay et al. | Sep 2004 | A1 |
| 20040193857 | Miller et al. | Sep 2004 | A1 |
| 20040202158 | Takeno et al. | Oct 2004 | A1 |
| 20040205296 | Bearden | Oct 2004 | A1 |
| 20040215886 | Cargnoni et al. | Oct 2004 | A1 |
| 20040216105 | Burky et al. | Oct 2004 | A1 |
| 20040216120 | Burky et al. | Oct 2004 | A1 |
| 20040225872 | Bonanno et al. | Nov 2004 | A1 |
| 20050005085 | Miyanaga | Jan 2005 | A1 |
| 20050027961 | Zhang | Feb 2005 | A1 |
| 20050044547 | Gipp | Feb 2005 | A1 |
| 20050055504 | Hass et al. | Mar 2005 | A1 |
| 20050060457 | Olukotun | Mar 2005 | A1 |
| 20050066131 | Biles et al. | Mar 2005 | A1 |
| 20050108480 | Correale, Jr. et al. | May 2005 | A1 |
| 20050108715 | Kanai et al. | May 2005 | A1 |
| 20050114603 | Buti et al. | May 2005 | A1 |
| 20050120191 | Akkary et al. | Jun 2005 | A1 |
| 20050120194 | Kissell | Jun 2005 | A1 |
| 20050132145 | Dybsetter et al. | Jun 2005 | A1 |
| 20050154867 | Dewitt, Jr. et al. | Jul 2005 | A1 |
| 20050204118 | Jen et al. | Sep 2005 | A1 |
| 20050210457 | Guilford | Sep 2005 | A1 |
| 20050216920 | Tewari et al. | Sep 2005 | A1 |
| 20050251639 | Vishin et al. | Nov 2005 | A1 |
| 20050251649 | Yamazaki | Nov 2005 | A1 |
| 20050262270 | Latorre et al. | Nov 2005 | A1 |
| 20050289299 | Nunamaker et al. | Dec 2005 | A1 |
| 20050289530 | Robison | Dec 2005 | A1 |
| 20060004964 | Conti et al. | Jan 2006 | A1 |
| 20060026381 | Doi et al. | Feb 2006 | A1 |
| 20060026408 | Morris et al. | Feb 2006 | A1 |
| 20060036516 | Glebe | Feb 2006 | A1 |
| 20060080380 | Aizu et al. | Apr 2006 | A1 |
| 20060094446 | Duan | May 2006 | A1 |
| 20060095720 | Biles et al. | May 2006 | A1 |
| 20060143390 | Kottapalli | Jun 2006 | A1 |
| 20060161421 | Kissell | Jul 2006 | A1 |
| 20060161921 | Kissell | Jul 2006 | A1 |
| 20060179257 | Chu et al. | Aug 2006 | A1 |
| 20060179281 | Jensen et al. | Aug 2006 | A1 |
| 20060179289 | Floyd et al. | Aug 2006 | A1 |
| 20060190707 | McIlvaine et al. | Aug 2006 | A1 |
| 20060212687 | Chen et al. | Sep 2006 | A1 |
| 20060230243 | Cochran et al. | Oct 2006 | A1 |
| 20060230253 | Codrescu et al. | Oct 2006 | A1 |
| 20060230409 | Frigo et al. | Oct 2006 | A1 |
| 20060236074 | Williamson et al. | Oct 2006 | A1 |
| 20060236080 | Doing et al. | Oct 2006 | A1 |
| 20060242365 | Ali et al. | Oct 2006 | A1 |
| 20060242384 | Ahmed et al. | Oct 2006 | A1 |
| 20060256641 | Johnstone | Nov 2006 | A1 |
| 20060277365 | Pong | Dec 2006 | A1 |
| 20060282839 | Hankins et al. | Dec 2006 | A1 |
| 20070006231 | Wang et al. | Jan 2007 | A1 |
| 20070074005 | Abernathy | Mar 2007 | A1 |
| 20070186050 | Luick | Aug 2007 | A1 |
| 20070198665 | De Matteis et al. | Aug 2007 | A1 |
| 20070214343 | Lindholm et al. | Sep 2007 | A1 |
| 20070226722 | Chou | Sep 2007 | A1 |
| 20070262270 | Huang et al. | Nov 2007 | A1 |
| 20080016507 | Thomas et al. | Jan 2008 | A1 |
| 20080040724 | Kang et al. | Feb 2008 | A1 |
| 20080046666 | Termaine et al. | Feb 2008 | A1 |
| 20080052432 | Wilson et al. | Feb 2008 | A1 |
| 20080077813 | Keller et al. | Mar 2008 | A1 |
| 20080091880 | Vishin | Apr 2008 | A1 |
| 20080104598 | Chang | May 2008 | A1 |
| 20080109611 | Liu et al. | May 2008 | A1 |
| 20080126643 | Higuchi | May 2008 | A1 |
| 20080126771 | Chen et al. | May 2008 | A1 |
| 20080148237 | Jiang et al. | Jun 2008 | A1 |
| 20080184211 | Nickolls et al. | Jul 2008 | A1 |
| 20080195844 | Shen et al. | Aug 2008 | A1 |
| 20080215865 | Hino et al. | Sep 2008 | A1 |
| 20080225987 | Fazzi et al. | Sep 2008 | A1 |
| 20080235500 | Davis et al. | Sep 2008 | A1 |
| 20080250227 | Linderman et al. | Oct 2008 | A1 |
| 20080250232 | Nakashima | Oct 2008 | A1 |
| 20080256278 | Thomas et al. | Oct 2008 | A1 |
| 20080256330 | Wang et al. | Oct 2008 | A1 |
| 20080270758 | Ozer et al. | Oct 2008 | A1 |
| 20080270774 | Singh et al. | Oct 2008 | A1 |
| 20080282037 | Kusachi et al. | Nov 2008 | A1 |
| 20080320476 | Wingard et al. | Dec 2008 | A1 |
| 20090019264 | Correale, Jr. et al. | Jan 2009 | A1 |
| 20090031104 | Vorbach et al. | Jan 2009 | A1 |
| 20090070554 | Wang et al. | Mar 2009 | A1 |
| 20090113170 | Abdallah | Apr 2009 | A1 |
| 20090119457 | Latorre et al. | May 2009 | A1 |
| 20090138659 | Lauterbach | May 2009 | A1 |
| 20090138670 | Mutlu et al. | May 2009 | A1 |
| 20090150647 | Mejdrich et al. | Jun 2009 | A1 |
| 20090150890 | Yourst | Jun 2009 | A1 |
| 20090157980 | Bruce | Jun 2009 | A1 |
| 20090158017 | Mutlu et al. | Jun 2009 | A1 |
| 20090164733 | Kim et al. | Jun 2009 | A1 |
| 20090164766 | Suggs et al. | Jun 2009 | A1 |
| 20090165007 | Aghajanyan | Jun 2009 | A1 |
| 20090172344 | Grochowski et al. | Jul 2009 | A1 |
| 20090240919 | Alexander et al. | Sep 2009 | A1 |
| 20090241084 | Malley et al. | Sep 2009 | A1 |
| 20090249026 | Smelyanskiy et al. | Oct 2009 | A1 |
| 20090251476 | Jiao et al. | Oct 2009 | A1 |
| 20090282101 | Lim et al. | Nov 2009 | A1 |
| 20090287912 | Sendag | Nov 2009 | A1 |
| 20090307450 | Lee | Dec 2009 | A1 |
| 20090313462 | Emma et al. | Dec 2009 | A1 |
| 20090328053 | Dice | Dec 2009 | A1 |
| 20100058033 | Abernathy et al. | Mar 2010 | A1 |
| 20100064121 | Alexander et al. | Mar 2010 | A1 |
| 20100082912 | Lesartre et al. | Apr 2010 | A1 |
| 20100088443 | Riocreux et al. | Apr 2010 | A1 |
| 20100100690 | Rajamani et al. | Apr 2010 | A1 |
| 20100100704 | Hill et al. | Apr 2010 | A1 |
| 20100100707 | Mejdrich et al. | Apr 2010 | A1 |
| 20100115167 | Tardieux et al. | May 2010 | A1 |
| 20100115244 | Jensen et al. | May 2010 | A1 |
| 20100138607 | Hughes et al. | Jun 2010 | A1 |
| 20100154042 | Miyamoto et al. | Jun 2010 | A1 |
| 20100161948 | Abdallah | Jun 2010 | A1 |
| 20100169578 | Nychka et al. | Jul 2010 | A1 |
| 20100169611 | Chou et al. | Jul 2010 | A1 |
| 20100205603 | Merten et al. | Aug 2010 | A1 |
| 20100211746 | Tsukishiro | Aug 2010 | A1 |
| 20100280996 | Gross, IV et al. | Nov 2010 | A1 |
| 20100286976 | Gao et al. | Nov 2010 | A1 |
| 20100299671 | Kinsey | Nov 2010 | A1 |
| 20100306503 | Henry et al. | Dec 2010 | A1 |
| 20100325394 | Golla et al. | Dec 2010 | A1 |
| 20100332805 | Blasco et al. | Dec 2010 | A1 |
| 20110010521 | Wang et al. | Jan 2011 | A1 |
| 20110055479 | West et al. | Mar 2011 | A1 |
| 20110067016 | Mizrachi et al. | Mar 2011 | A1 |
| 20110082980 | Gschwind et al. | Apr 2011 | A1 |
| 20110082983 | Koktan | Apr 2011 | A1 |
| 20110093857 | Sydow et al. | Apr 2011 | A1 |
| 20110119660 | Tanaka | May 2011 | A1 |
| 20110153955 | Herrenschmidt et al. | Jun 2011 | A1 |
| 20110225588 | Pollock et al. | Sep 2011 | A1 |
| 20120005462 | Hall et al. | Jan 2012 | A1 |
| 20120023318 | Xing et al. | Jan 2012 | A1 |
| 20120042105 | Maeda et al. | Feb 2012 | A1 |
| 20120042126 | Krick et al. | Feb 2012 | A1 |
| 20120066483 | Boury et al. | Mar 2012 | A1 |
| 20120089812 | Smith | Apr 2012 | A1 |
| 20120096204 | Auerbach et al. | Apr 2012 | A1 |
| 20120198209 | Abdallah et al. | Aug 2012 | A1 |
| 20120246450 | Abdallah et al. | Sep 2012 | A1 |
| 20120246657 | Abdallah et al. | Sep 2012 | A1 |
| 20120278593 | Clark et al. | Nov 2012 | A1 |
| 20130019047 | Podvalny et al. | Jan 2013 | A1 |
| 20130036296 | Hickey et al. | Feb 2013 | A1 |
| 20130046934 | Nychka et al. | Feb 2013 | A1 |
| 20130086417 | Sivaramakrishnan et al. | Apr 2013 | A1 |
| 20130097369 | Talagala et al. | Apr 2013 | A1 |
| 20130138888 | Barreh et al. | May 2013 | A1 |
| 20130238874 | Avudaiyappan et al. | Sep 2013 | A1 |
| 20130283286 | Lee et al. | Oct 2013 | A1 |
| 20130304991 | Boettcher et al. | Nov 2013 | A1 |
| 20130311759 | Abdallah et al. | Nov 2013 | A1 |
| 20130339671 | Williams, III et al. | Dec 2013 | A1 |
| 20130346699 | Walker | Dec 2013 | A1 |
| 20140032844 | Avudaiyappan et al. | Jan 2014 | A1 |
| 20140032845 | Avudaiyappan et al. | Jan 2014 | A1 |
| 20140032856 | Avudaiyappan et al. | Jan 2014 | A1 |
| 20140075168 | Abdallah | Mar 2014 | A1 |
| 20140108730 | Avudaiyappan et al. | Apr 2014 | A1 |
| 20140123145 | Barrow-Williams et al. | May 2014 | A1 |
| 20140156947 | Avudaiyappan et al. | Jun 2014 | A1 |
| 20140181833 | Bird et al. | Jun 2014 | A1 |
| 20140281242 | Abdallah et al. | Sep 2014 | A1 |
| 20140281411 | Abdallah | Sep 2014 | A1 |
| 20140281412 | Abdallah et al. | Sep 2014 | A1 |
| 20140281416 | Abdallah et al. | Sep 2014 | A1 |
| 20140281426 | Abdallah et al. | Sep 2014 | A1 |
| 20140281427 | Abdallah | Sep 2014 | A1 |
| 20140281428 | Abdallah et al. | Sep 2014 | A1 |
| 20140281436 | Abdallah | Sep 2014 | A1 |
| 20140282592 | Abdallah et al. | Sep 2014 | A1 |
| 20140282601 | Abdallah | Sep 2014 | A1 |
| 20140317387 | Abdallah et al. | Oct 2014 | A1 |
| 20140344554 | Abdallah | Nov 2014 | A1 |
| 20140373022 | Chan et al. | Dec 2014 | A1 |
| 20150039859 | Abdallah | Feb 2015 | A1 |
| 20150046683 | Abdallah | Feb 2015 | A1 |
| 20150046686 | Abdallah | Feb 2015 | A1 |
| 20150186144 | Abdallah | Jul 2015 | A1 |
| 20160041908 | Avudaiyappan et al. | Feb 2016 | A1 |
| 20160041913 | Avudaiyappan et al. | Feb 2016 | A1 |
| 20160041930 | Avudaiyappan | Feb 2016 | A1 |
| 20160154653 | Abdallah et al. | Jun 2016 | A1 |
| 20160210145 | Abdallah | Jul 2016 | A1 |
| 20160210176 | Abdallah | Jul 2016 | A1 |
| 20160371188 | Abdallah et al. | Dec 2016 | A1 |
| Number | Date | Country |
|---|---|---|
| 1214666 | Apr 1999 | CN |
| 1305150 | Jul 2001 | CN |
| 1451115 | Oct 2003 | CN |
| 1214666 | Aug 2005 | CN |
| 1713137 | Dec 2005 | CN |
| 1774709 | May 2006 | CN |
| 1841314 | Oct 2006 | CN |
| 1841332 | Oct 2006 | CN |
| 1848095 | Oct 2006 | CN |
| 1881223 | Dec 2006 | CN |
| 101114218 | Jan 2008 | CN |
| 101151594 | Mar 2008 | CN |
| 101241428 | Aug 2008 | CN |
| 101344840 | Jan 2009 | CN |
| 101449256 | Jun 2009 | CN |
| 101582025 | Nov 2009 | CN |
| 101627365 | Jan 2010 | CN |
| 101916180 | Dec 2010 | CN |
| 102105864 | Jun 2011 | CN |
| 0596636 | May 1994 | EP |
| 0706133 | Apr 1996 | EP |
| 2616928 | Jul 2013 | EP |
| 2343270 | May 2000 | GB |
| 2000330790 | Nov 2000 | JP |
| 20010050794 | Jun 2001 | KR |
| 20010053622 | Jun 2001 | KR |
| 20100003309 | Jan 2010 | KR |
| 200707284 | Mar 1995 | TW |
| 539996 | Jul 2003 | TW |
| 544626 | Aug 2003 | TW |
| 200401187 | Jan 2004 | TW |
| 200405201 | Apr 2004 | TW |
| 591530 | Jun 2004 | TW |
| 200422949 | Nov 2004 | TW |
| I233545 | Jun 2005 | TW |
| I281121 | May 2007 | TW |
| 200813766 | Mar 2008 | TW |
| 200844853 | Nov 2008 | TW |
| 200941339 | Oct 2009 | TW |
| I315488 | Oct 2009 | TW |
| 200949690 | Dec 2009 | TW |
| I329437 | Aug 2010 | TW |
| I331282 | Oct 2010 | TW |
| I352288 | Nov 2011 | TW |
| 201227520 | Jul 2012 | TW |
| 201241744 | Oct 2012 | TW |
| 201305819 | Feb 2013 | TW |
| 9750031 | Dec 1997 | WO |
| 9919793 | Apr 1999 | WO |
| 0125921 | Apr 2001 | WO |
| 2004114128 | Dec 2004 | WO |
| 2007027671 | Mar 2007 | WO |
| 2008021434 | Feb 2008 | WO |
| 2008061154 | May 2008 | WO |
| 2009012296 | Jan 2009 | WO |
| 2009101563 | Aug 2009 | WO |
| 2010049585 | May 2010 | WO |
| 2012135031 | Oct 2012 | WO |
| 2012135050 | Oct 2012 | WO |
| Entry |
|---|
| Abandonment from U.S. Appl. No. 14/212,203, mailed Jul. 26, 2018, 2 pages. |
| Abandonment from U.S. Appl. No. 15/354,857, mailed Jul. 30, 2018, 2 pages. |
| Final Office Action from U.S. Appl. No. 14/360,280, dated Jul. 24, 2018, 24 pages. |
| First Examination Report from foreign counterpart Indian Patent Application No. 51/KOLNP/2012, dated Jul. 30, 2018, 7 pages. |
| Non-Final Office Action from U.S. Appl. No. 15/853,323, dated Aug. 28, 2018, 115 pages. |
| Notice of Allowance from U.S. Appl. No. 15/408,311, dated Aug. 28, 2018, 138 pages. |
| Notice of Allowance from U.S. Appl. No. 13/824,013, dated Jul. 23, 2018, 15 pages. |
| Notice of Allowance from U.S. Appl. No. 14/216,493, dated Aug. 1, 2018, 14 pages. |
| Notice of Allowance from U.S. Appl. No. 15/408,255, dated Jul. 25, 2018, 136 pages. |
| Abandonment from U.S. Appl. No. 13/824,013, mailed Mar. 3, 2015, 1 page. |
| Advisory Action from U.S. Appl. No. 12/296,919, dated Aug. 26, 2011, 3 pages. |
| Advisory Action from U.S. Appl. No. 14/214,280, dated May 15, 2017, 3 pages. |
| Advisory Action from U.S. Appl. No. 14/360,282, dated Jan. 23, 2018, 2 pages. |
| Barham P., et al., “Xen and the Art of Virtualization,” Proceedings of the ACM Symposium on Operating Systems Principles, XP002298786, Oct. 2003, pp. 164-177. |
| Communication pursuant to Article 94(3) EPC for European Application No. 070864410, dated Mar. 16, 2012, 4 pages. |
| Communication pursuant to Article 94(3) EPC for European Application No. 070864410, dated Nov. 14, 2012, 4 pages. |
| Communication pursuant to Article 94(3) EPC for European Application No. 07811845, dated Apr. 16, 2014, 5 pages. |
| Communication pursuant to Article 94(3) EPC for European Application No. 07811845, dated Dec. 21, 2015, 3 pages. |
| Communication pursuant to Article 94(3) EPC for European Application No. 07811845, dated Feb. 3, 2014, 5 pages. |
| Communication pursuant to Article 94(3) EPC for European Application No. 07811845, dated Feb. 16, 2011, 6 pages. |
| Communication pursuant to Article 94(3) EPC for European Application No. 07811845, dated Jan. 27, 2012, 7 pages. |
| Communication pursuant to Article 94(3) EPC for European Application No. 12150513, dated Apr. 16, 2013, 5 pages. |
| Communication pursuant to Article 94(3) EPC for European Application No. 12150513, dated Dec. 21, 2015, 4 pages. |
| Communication pursuant to Article 94(3) EPC for European Application No. 12150513, dated May 9, 2014, 8 pages. |
| Communication pursuant to Article 94(3) EPC for European Application No. 12174228, dated Jun. 11, 2013, 3 pages. |
| Communication pursuant to Article 94(3) EPC for European Application No. 12764627, dated Oct. 4, 2016, 4 pages. |
| Communication pursuant to Article 94(3) EPC for European Application No. 12788989.7, dated Jun. 22, 2017, 6 pages. |
| Communication pursuant to Rules 161(2) and 162 EPC for Application No. 12763717, dated Nov. 22, 2013, 3 pages. |
| Communication pursuant to Rules 70(2) and 70a(2) EPC for Application No. 12763717, dated Oct. 10, 2014, 1 page. |
| Communication pursuant to Rules 70(2) and 70a(2) EPC for European Application No. 11876314.3, dated Jul. 1, 2016, 1 page. |
| Cooperman, “Cache Basics,” Winter 2003, downloaded from http://www.ccs.neu.edu/course/com3200/parent/NOTES/cache-basics.html on Sep. 24, 2015, 3 pages. (no publication month available). |
| Corrected Notice of Allowance from U.S. Appl. No. 13/475,708, dated Feb. 14, 2018, 27 pages. |
| Corrected Notice of Allowance from U.S. Appl. No. 13/475,708, dated Feb. 26, 2018, 31 pages. |
| Corrected Notice of Allowance from U.S. Appl. No. 15/357,943, dated Feb. 13, 2018, 4 pages. |
| Decision to Grant a Patent for European Application No. 07811845, dated Jun. 16, 2016, 2 pages. |
| Decision to Grant a Patent for European Application No. 12150513, dated Jun. 16, 2016, 2 pages. |
| Decision to Grant a Patent for European Application No. 12174228, dated Dec. 13, 2013, 5 pages. |
| Decision to Grant a Patent for Korean Application No. KR1020137027843, dated Apr. 29, 2016, 2 pages. |
| Decision to Grant a Patent for Korean Patent Application No. 20137027842, dated Mar. 31, 2016, 2 pages. |
| Decision to grant a patent from foreign counterpart Korean Patent Application No. 10-2014-7016774, dated Jul. 25, 2016, 2 pages. |
| Decision to Grant a Patent from foreign counterpart Korean Patent Application No. 20137033565, dated Apr. 29, 2016, 2 pages. |
| Decision to Grant a Patent from foreign counterpart Korean Patent Application No. 20137033566, dated Apr. 29, 2016, 2 pages. |
| Decision to Grant a Patent from foreign counterpart Korean Patent Application No. KR1020157029107, dated Apr. 25, 2017, 2 pages. |
| Examination Report for European Application No. 12763717, dated Nov. 28, 2016, 5 pages. |
| Extended European Search Report for Application No. 07811845.2, dated Nov. 2, 2009, 7 pages. |
| Extended European Search Report for Application No. 07864410, dated Feb. 19, 2010, 8 pages. |
| Extended European Search Report for Application No. 11876314.3, dated Jun. 14, 2016, 6 pages. |
| Extended European Search Report for Application No. 12150513, dated Jun. 19, 2012, 8 pages. |
| Extended European Search Report for Application No. 12174228, dated Oct. 16, 2012, 4 pages. |
| Extended European Search Report for Application No. 12174229, dated Jul. 4, 2014, 10 pages. |
| Extended European Search Report for Application No. 12788989, dated May 12, 2016, 9 pages. |
| Extended European Search Report for Application No. 12789667, dated Feb. 26, 2016, 7 pages. |
| Extended European Search Report for Application No. 14769411.1, dated Apr. 5, 2017, 8 pages. |
| Extended European Search Report for Application No. 14769450.9, dated Feb. 21, 2017, 16 pages. |
| Extended European Search Report for Application No. 14770976.0, dated Jul. 3, 2017, 9 pages. |
| Extended European Search Report for Application No. 16196777.3, dated Mar. 20, 2017, 6 pages. |
| Extended European Search Report for Application No. EP11826042, dated Jan. 24, 2016, 6 pages. |
| Extended European Search Report for Application No. EP11876128, dated Jun. 21 2016, 8 pages. |
| Extended European Search Report for Application No. EP11876130, dated Jun. 1, 2016, 7 pages. |
| Mogul J.C., et al., “Potential Benefits of Delta Encoding and Data Compression for HTTP,” Oct. 1, 1997, ACM, SIGCOMM '97, pp. 181-194. |
| Nagarajan et al., “A Design Space Evaluation of Grid Processor Architectures,” 34th ACM/IEEE International Symposium, Piscataway, NJ, Dec. 1-5, 2001, pp. 40-51. |
| Nanda, et al., “The Misprediction Recovery Cache,” International Journal of Parallel Programming—Special issue: MICRO-29, 29th annual IEEE/ACM intemational symposium on microarchitecture, Plenum Press, New York, NY, Aug. 1998, vol. 26 (4), pp. 383-415. |
| Non-Final Office Action from U.S. Appl. No. 12/296,919, dated Apr. 7, 2011, 8 pages. |
| Non-Final Office Action from U.S. Appl. No. 12/296,919, dated Jun. 14, 2010, 7 pages. |
| Non-Final Office Action from U.S. Appl. No. 12/296,919, dated Mar. 7, 2012, 7 pages. |
| Non-Final Office Action from U.S. Appl. No. 12/514,303, dated Jun. 27, 2013, 7 pages. |
| Non-Final Office Action from U.S. Appl. No. 12/514,303, dated May 10, 2012, 9 pages. |
| Non-Final Office Action from U.S. Appl. No. 13/428,438, dated Apr. 24, 2014, 15 pages. |
| Non-Final Office Action from U.S. Appl. No. 13/428,438, dated May 1, 2015, 12 pages. |
| Non-Final Office Action from U.S. Appl. No. 13/428,440, dated Jun. 18, 2014, 16 pages. |
| Non-Final Office Action from U.S. Appl. No. 13/428,440, dated May 4, 2015, 13 pages. |
| Non-Final Office Action from U.S. Appl. No. 13/428,452, dated Apr. 23, 2015, 11 pages. |
| Non-Final Office Action from U.S. Appl. No. 13/428,452, dated Apr. 28, 2014, 21 pages. |
| Non-Final Office Action from U.S. Appl. No. 13/475,708, dated Feb. 11, 2015, 27 pages. |
| Non-Final Office Action from U.S. Appl. No. 13/475,708, dated Feb. 12, 2016, 37 pages. |
| Non-Final Office Action from U.S. Appl. No. 13/475,739, dated May 21, 2015, 14 pages. |
| Non-Final Office Action from U.S. Appl. No. 13/475,739, dated Sep. 2, 2014, 15 pages. |
| Non-Final Office Action from U.S. Appl. No. 13/691,609, dated Jan. 15, 2014, 5 pages. |
| Non-Final Office Action from U.S. Appl. No. 13/691,609, dated Sep. 5, 2013, 11 pages. |
| Non-Final Office Action from U.S. Appl. No. 13/824,013, dated Feb. 7, 2018, 141 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/194,589, dated Nov. 19, 2015, 12 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/212,203, dated Mar. 24, 2017, 68 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/212,203, dated Sep. 8, 2016, 52 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/212,533, dated Apr. 20, 2017, 116 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/212,533, dated Sep. 22, 2016, 52 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/213,115, dated Oct. 19, 2015, 24 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/213,115, dated Sep. 22, 2014, 19 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/213,135, dated May 14, 2015, 23 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/213,135, dated May 31, 2016, 14 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/213,218, dated Apr. 22, 2015, 22 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/213,218, dated Feb. 2, 2016, 17 pages. |
| Non-final Office Action from U.S. Appl. No. 14/213,692, dated Aug. 24, 2015, 30 pages. |
| Non-final Office Action from U.S. Appl. No. 14/213,692, dated Jun. 13, 2016, 17 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/213,730, dated Jan. 7, 2016, 27 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/213,854, dated Apr. 29, 2016, 13 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/213,854, dated Jun. 19, 2015, 23 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/214,045, dated Apr. 1, 2016, 61 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/214,045, dated Dec. 19, 2016, 88 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/214,176, dated Jan. 6, 2017, 36 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/214,176, dated Mar. 25, 2016, 25 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/214,280, dated Jan. 6, 2017, 14 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/214,280, dated Jun. 16, 2016, 12 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/214,280, dated Sep. 18, 2015, 18 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/215,633, dated Oct. 22, 2015, 18 pages. |
| Non-final Office Action from U.S. Appl. No. 14/216,493, dated Apr. 4, 2016, 26 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/216,493, dated Mar. 29, 2017, 18 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/216,859, dated Jan. 28, 2016, 33 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/360,280, dated Dec. 14, 2017, 25 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/360,280, dated Feb. 23, 2017, 34 pages. |
| Non-Final Office Action from U.S. Appl. No. 15/408,323, dated Oct. 9, 2018, 144 pages. |
| Non-Final Office Action from U.S. Appl. No. 15/866,323, dated Oct. 1, 2018, 121 pages. |
| Notice of Allowance from U.S. Appl. No. 14/213,135, dated Oct. 3, 2018, 34 pages. |
| Notice of Allowance from U.S. Appl. No. 14/360,284, dated Oct. 12, 2018, 45 pages. |
| Notice of Allowance from U.S. Appl. No. 15/712,017, dated Oct. 3, 2018, 16 pages. |
| Notice of Allowance from U.S. Appl. No. 13/824,013, dated Sep. 19, 2018, 6 pages. |
| Notice of Allowance from U.S. Appl. No. 15/408,269, dated Sep. 24, 2018, 137 pages. |
| Second Office Action from foreign counterpart Chinese Patent Application No. 201480024528.0, dated Oct. 8, 2018, 3 pages. |
| Abandonment from U.S. Appl. No. 14/212,533, mailed Jun. 19, 2018, 3 pages. |
| Abandonment from U.S. Appl. No. 14/360,282, mailed May 25, 2018, 2 pages. |
| Advisory Action from U.S. Appl. No. 14/212,203, dated Apr. 5, 2018, 8 pages. |
| Communication pursuant to Article 94(3) EPC for Application No. 14770976.0, dated Mar. 16, 2018, 4 pages. |
| Communication pursuant to Article 94(3) EPC for Application No. 11876128.7, dated Feb. 5, 2018, 9 pages. |
| Communication pursuant to Article 94(3) EPC for Application No. 11876130.3, dated Feb. 5, 2018, 9 pages. |
| Communication pursuant to Article 94(3) EPC for Application No. 11876314.3, dated Feb. 5, 2018, 8 pages. |
| Communication pursuant to Article 94(3) EPC for Application No. 12789667.8, dated Feb. 21, 2018, 4 pages. |
| Corrected Notice of Allowance from U.S. Appl. No. 15/219,063, dated Jun. 28, 2018, 8 pages. |
| Corrected Notice of Allowance from U.S. Appl. No. 15/357,943, dated Apr. 2, 2018, 4 pages. |
| Non-Final Office Action from U.S. Appl. No. 15/712,017, dated May 7, 2018, 127 pages. |
| Non-Final Office Action from U.S. Appl. No. 15/862,496, dated Apr. 5, 2018, 151 pages. |
| Notice of Allowance from U.S. Appl. No. 14/216,493, dated Apr. 2, 2018, 22 pages. |
| Notice of Preliminary Rejection from foreign counterpart Korean Patent Application No. 10-2018-7003058, dated Jun. 4, 2018, 10 pages. |
| Office Action from foreign counterpart Chinese patent application No. 201280024012, dated Feb. 3, 2017, 20 pages. |
| Office Action from foreign counterpart Chinese patent application No. 201280024095, dated Feb. 4, 2017, 31 pages. |
| Office Action from foreign counterpart European Patent Application No. EP12764838, dated Oct. 4, 2016, 4 pages. |
| Office Action from foreign counterpart Taiwan Patent Application No. 20140109479, dated Nov. 28, 2016, 7 pages. |
| Partial European Search Report for Application No. 12174229, dated Oct. 10, 2012, 7 pages. |
| Partial Supplementary European Search Report for Application No. 14769450.9, dated Oct. 11, 2016, 8 pages. |
| Partial Supplementary European Search Report for Application No. EP14770976.0, dated Mar. 24, 2017, 7 pages. |
| Restriction Requirement from U.S. Appl. No. 12/296,919, dated Feb. 8, 2011, 4 pages. |
| Restriction Requirement from U.S. Appl. No. 12/514,303, dated Oct. 15, 2012, 4 pages. |
| Restriction Requirement from U.S. Appl. No. 14/360,282, dated Jul. 28, 2016, 4 pages. |
| Rixner, et al., “Register Organization for Media Processing,” HPCA-6—Proceedings of the 6th International Symposium on High-Performance Computer Architecture, Jan. 8-12, 2000, IEEE, Toulouse, France, pp. 375-386. |
| Rotenberg E., et al., “Trace Cache: a Low Latency Approach to High Bandwidth Instruction Fetching,” MICRO 29—Proceedings of the 29th annual ACM/IEEE international symposium on Microarchitecture, IEEE Computer Society, Apr. 11, 1996, 48 pages. |
| Santos, et al., “The 2D-VLIW Architecture,” Technical Report IC-06-006, Instituto de Computacao, Universidad Estadual de Campinas, Mar. 2006, 13 pages. |
| Sassone et al., “Dynamic Strands: Collapsing Speculative Dependence Chains for Reducing Pipeline Communication,” Microarchitecture, IEEE, 37th International Symposium on Portland, USA Dec. 2004, pp. 7-17, Piscataway, NJ, USA. |
| Search Report for Chinese Application No. CN201280024012, dated May 19, 2016, 2 pages. |
| Second Office Action from foreign counterpart China Patent Application No. 201180076248.0, dated Oct. 20, 2016, 25 pages. |
| Second Office Action from foreign counterpart China Patent Application No. 201480024463.X, dated Nov. 14, 2017, 34 pages. |
| Second Office Action from foreign counterpart China Patent Application No. CN201280034725, dated Apr. 14, 2016, 8 pages. |
| Second Office Action from foreign counterpart China Patent Application No. CN201280034739, dated Jun. 23, 2016, 44 pages. |
| Second Office Action from foreign counterpart Chinese Patent Application No. 201280024054.0, dated Dec. 26, 2016, 11 pages. |
| Second Office Action with search report from foreign counterpart Chinese Patent Application No. 201180076244, dated Nov. 18, 2016, 21 pages (Translation available only for Office Action). |
| Summons to attend Oral Proceedings for European Application No. 070864410, mailed Apr. 3, 2013, 3 pages. |
| Sun, et al., “Modeling of FPGA Local/Global Interconnect Resources and Derivation of Minimal Test Configuration,” Proceedings of the 17th IEEE International Symposium on Defect and Fault Tolerance in VLSI Systems (DFT'02), IEEE Computer Society, Nov. 6-8, 2002, 9 pages. |
| Third Office Action and Search report from foreign counterpart China Patent Application No. 201180076248.0, dated May 2, 2017, 27 pages. |
| Third Office Action from foreign counterpart China Patent Application No. 201280024054.0, dated Jul. 28, 2017, 8 pages. |
| Third Office Action from foreign counterpart Chinese Patent Application No. 201180076244.2, dated May 2, 2017, 20 pages. |
| Third Office Action from foreign counterpart Chinese Patent Application No. 201280024012.7, dated Nov. 6, 2017, 8 pages. |
| Third Office Action from foreign counterpart Chinese Patent Application No. 201280034739, dated Dec. 27, 2016, 18 pages. |
| Wallace S., et al.,“Multiple Branch and Block Prediction,” Third International symposium on High-Performance Computer Architecture, IEEE, Feb. 1997, pp. 94-103. |
| Written Opinion for Application No. PCT/US2007/066536, dated Jul. 30, 2008, 5 pages. |
| Ye, et al., “A New Recovery Mechanism in Superscalar Microprocessors by Recovering Critical Misprediction,” IEICE Transactions on Fundamentals of Electronics, Communications and Computer Sciences, The Institute of Electronics, Information and Communication Engineers, Dec. 1, 2011, vol. E94-A (12), pp. 2639-2648. |
| Yeh, et al., “Increasing the Instruction Fetch Rate via Multiple Branch Prediction and a Branch Address Cache,” ICS 93, Proceedings of the 7th International Conference on Supercomputing, ACM, New York, NY, Jul. 19-23, 1993, pp. 67-76. |
| Notice of Allowance from U.S. Appl. No. 14/213,854, dated Oct. 7, 2016, 19 pages. |
| Notice of Allowance from U.S. Appl. No. 14/214,045, dated Apr. 18, 2017, 88 pages. |
| Notice of Allowance from U.S. Appl. No. 14/214,045, dated Oct. 6, 2017, 137 pages. |
| Notice of Allowance from U.S. Appl. No. 14/214,176, dated May 10, 2017, 88 pages. |
| Notice of Allowance from U.S. Appl. No. 14/214,176, dated Oct. 19, 2017, 25 pages. |
| Notice of Allowance from U.S. Appl. No. 14/214,280, dated Jun. 29, 2017, 86 pages. |
| Notice of Allowance from U.S. Appl. No. 14/215,633, dated Jun. 30, 2017, 83 pages. |
| Notice of Allowance from U.S. Appl. No. 14/215,633, dated Mar. 23, 2017, 17 pages. |
| Notice of Allowance from U.S. Appl. No. 14/215,633, dated May 23, 2016, 9 pages. |
| Notice of Allowance from U.S. Appl. No. 14/215,633, dated Oct. 4, 2017, 15 pages. |
| Notice of Allowance from U.S. Appl. No. 14/215,633, dated Sep. 29, 2016, 13 pages. |
| Notice of Allowance from U.S. Appl. No. 14/216,493, dated Aug. 4, 2017, 95 pages. |
| Notice of Allowance from U.S. Appl. No. 14/216,859, dated Dec. 1, 2017, 113 pages. |
| Notice of Allowance from U.S. Appl. No. 14/216,859, dated Jan. 24, 2017, 17 pages. |
| Notice of Allowance from U.S. Appl. No. 14/360,284, dated Jun. 14, 2017, 100 pages. |
| Notice of Allowance from U.S. Appl. No. 14/733,827, dated Sep. 22, 2017, 30 pages. |
| Notice of Allowance from U.S. Appl. No. 15/019,920, dated Dec. 6, 2017, 24 pages. |
| Notice of Allowance from U.S. Appl. No. 15/019,920, dated Jul. 14, 2017, 100 pages. |
| Notice of Allowance from U.S. Appl. No. 15/082,359, dated Mar. 21, 2018, 9 pages. |
| Notice of Allowance from U.S. Appl. No. 15/082,867, dated Dec. 22, 2017, 25 pages. |
| Notice of Allowance from U.S. Appl. No. 15/082,867, dated Jul. 7, 2017, 98 pages. |
| Notice of Allowance from U.S. Appl. No. 15/219,063, dated Mar. 19, 2018, 28 pages. |
| Notice of Allowance from U.S. Appl. No. 15/257,593, dated Oct. 11, 2017, 95 pages. |
| Notice of Allowance from U.S. Appl. No. 15/357,943, dated Jan. 16, 2018, 16 pages. |
| Notice of Final Rejection from foreign counterpart Korean Patent Application No. 10-2015-7029262, dated May 23, 2017, 7 pages. |
| Notice of Preliminary Rejection from foreign counterpart Korean Patent Application No. 10-2016-7017150, dated Apr. 20, 2017, 5 pages. |
| Notice on Grant of Patent Right for Invention from foreign counterpart China Application No. 201180076244.2, dated Aug. 28, 2017, 4 pages. |
| Notice on Grant of Patent Right for Invention from foreign counterpart Chinese Patent Application No. 201180076248.0, dated Feb. 27, 2018, 6 pages. |
| Notice on Grant of Patent Right for Invention from foreign counterpart Chinese Patent Application No. 201280024012.7, dated Mar. 12, 2018, 4 pages. |
| Notice on Grant of Patent Right for Invention from foreign counterpart Chinese Patent Application No. 201280024054.0, dated Dec. 1, 2017, 4 pages. |
| Notice on Grant of Patent Right for Invention from foreign counterpart Chinese Patent Application No. 201280024095.X, dated Nov. 7, 2017, 6 pages. |
| Notification of Reason for Refusal from Foreign Counterpart Korean Patent Application No. 10-2013-7027842, dated Sep. 18, 2015, 7 pages. |
| Notification of Reason for Refusal from foreign counterpart Korean Patent Application No. 10-2014-7016774, dated Jan. 28, 2016, 4 pages. |
| Notification of Reason for Refusal from foreign counterpart Korean Patent Application No. 10-2015-7029262, dated Oct. 17, 2016, 12 pages. |
| Notification of Reason for Refusal from foreign counterpart Korean Patent Application No. 10-2017-7002379, dated May 26, 2017, 6 pages. |
| Notification of Reason for Refusal from foreign counterpart Korean Patent Application No. 10-2017-7002473, dated May 26, 2017, 7 pages. |
| Notification of Reason for Refusal from foreign counterpart Korean Patent Application No. 20137027841, dated Sep. 18, 2015, 10 pages. |
| Notification of Reason for Refusal from foreign counterpart Korean Patent Application No. 20137033565, dated Sep. 30, 2015, 6 pages. |
| Notification of Reason for Refusal from foreign counterpart Korean Patent Application No. 20137033566, dated Sep. 30, 2015, 9 pages. |
| Notification of Reason for Refusal from foreign counterpart Korean Patent Application No. KR1020137027843, dated Sep. 30, 2015, 8 pages. |
| Notification of Reason for Refusal from foreign counterpart Korean Patent Application No. KR1020157029107, dated Oct. 13, 2016, 11 pages. |
| Notification of Reason for Refusal from Korean Application No. 10-2014-7016763, dated Apr. 29, 2016, 11 pages. |
| Notification of Reason for Refusal from Korean Application No. 10-2015-7028745, dated May 23, 2016, 8 pages. |
| Notification to Grant Patent Right for Invention from foreign counterpart China Patent Application No. 201180076245.7, dated Nov. 2, 2016, 3 pages. |
| Notification to Grant Patent Right for Invention from foreign counterpart China Patent Application No. CN201280034725, dated Aug. 12, 2016, 3 pages. |
| Notification to Grant Patent Right for Invention from foreign counterpart China Patent Application No. CN201310589048, dated May 5, 2016, 3 pages. |
| Nuth et al., “The Named-State Register File: Implementation and Performance,” High-Performance Computer Architecture, First IEEE Symposium, Jan. 22-25, 1995, 10 pages. |
| Office Action and Search Report from foreign counterpart Taiwan Patent Application No. 100142885, dated Jan. 23, 2017, 12 pages. |
| Office Action and Search Report from foreign counterpart Taiwan Patent Application No. 101117854, dated Mar. 30, 2017, 7 pages. |
| Office Action from foreign counterpart Chinese Patent Application No. 200780046679, dated May 21, 2013, 14 pages. |
| Communication pursuant to Article 94(3) EPC for Application No. 14769411.1, dated Dec. 7, 2018, 7 pages. |
| Communication pursuant to Article 94(3) EPC for Application No. 11876314.3, dated Oct. 19, 2018, 5 pages. |
| Communication pursuant to Article 94(3) EPC for Application No. 11876314.3, dated Sep. 24, 2018, 6 pages. |
| Non-Final Office Action from U.S. Appl. No. 15/354,742, dated Dec. 4, 2018, 54 pages. |
| Non-Final Office Action from U.S. Appl. No. 15/283,836, dated Dec. 27, 2018, 150 pages. |
| Notice of Allowance from U.S. Appl. No. 15/862,496, dated Nov. 2, 2018, 23 pages. |
| Notice of Allowance from U.S. Appl. No. 13/824,013, dated Nov. 13, 2018, 12 pages. |
| Notice of Allowance from U.S. Appl. No. 15/706,056, dated Dec. 28, 2018, 138 pages. |
| Office Action and Search Report from foreign counterpart Taiwan Patent Application No. 106127331, dated Nov. 23, 2018, 13 pages. |
| Extended European Search Report for Application No. EP12763717, dated Sep. 24, 2014, 5 pages. |
| Extended European Search Report for Application No. EP12764627, dated Jul. 10, 2014, 5 pages. |
| Extended European Search Report for Application No. EP12764838, dated Jul. 10, 2014, 5 pages. |
| Final Office Action from U.S. Appl. No. 12/296,919, dated Jun. 14, 2011, 7 pages. |
| Final Office Action from U.S. Appl. No. 12/296,919, dated Oct. 22, 2010, 7 pages. |
| Final Office Action from U.S. Appl. No. 12/514,303, dated Jan. 24, 2013, 11 pages. |
| Final Office Action from U.S. Appl. No. 13/428,438, dated Dec. 24, 2014, 17 pages. |
| Final Office Action from U.S. Appl. No. 13/428,440, dated Dec. 24, 2014, 19 pages. |
| Final Office Action from U.S. Appl. No. 13/428,452, dated Dec. 24, 2014, 20 pages. |
| Final Office Action from U.S. Appl. No. 13/475,708, dated Jun. 9, 2016, 35 pages. |
| Final Office Action from U.S. Appl. No. 13/475,708, dated May 8, 2015, 23 pages. |
| Final Office Action from U.S. Appl. No. 13/475,739, dated Feb. 4, 2015, 12 pages. |
| Final Office Action from U.S. Appl. No. 13/475,739, dated Nov. 23, 2015, 28 pages. |
| Final Office Action from U.S. Appl. No. 14/194,589, dated Apr. 19, 2016, 7 pages. |
| Final Office Action from U.S. Appl. No. 14/212,203, dated Dec. 13, 2016, 20 pages. |
| Final Office Action from U.S. Appl. No. 14/212,203, dated Sep. 12, 2017, 84 pages. |
| Final Office Action from U.S. Appl. No. 14/212,533, dated Jan. 4, 2017, 27 pages. |
| Final Office Action from U.S. Appl. No. 14/212,533, dated Sep. 8, 2017, 69 pages. |
| Final Office Action from U.S. Appl. No. 14/213,115, dated Feb. 3, 2015, 11 pages. |
| Final Office Action from U.S. Appl. No. 14/213,115, dated Mar. 7, 2016, 18 pages. |
| Final Office Action from U.S. Appl. No. 14/213,135, dated Oct. 26, 2015, 20 pages. |
| Final Office Action from U.S. Appl. No. 14/213,218, dated Jul. 6, 2016, 24 pages. |
| Final Office Action from U.S. Appl. No. 14/213,218, dated Jul. 22, 2015, 16 pages. |
| Final Office Action from U.S. Appl. No. 14/213,692, dated Jan. 20, 2016, 18 pages. |
| Final Office Action from U.S. Appl. No. 14/213,730, dated May 11, 2016, 14 pages. |
| Final Office Action from U.S. Appl. No. 14/213,854, dated Nov. 9, 2015, 19 pages. |
| Final Office Action from U.S. Appl. No. 14/214,045, dated Aug. 29, 2016, 14 pages. |
| Final Office Action from U.S. Appl. No. 14/214,176, dated Aug. 29, 2016, 17 pages. |
| Final Office Action from U.S. Appl. No. 14/214,280, dated Mar. 6, 2017, 12 pages. |
| Final Office Action from U.S. Appl. No. 14/214,280, dated Mar. 11, 2016, 18 pages. |
| Final Office Action from U.S. Appl. No. 14/214,280, dated Oct. 24, 2016, 20 pages. |
| Final Office Action from U.S. Appl. No. 14/216,493, dated Aug. 30, 2016, 21 pages. |
| Final Office Action from U.S. Appl. No. 14/216,493, dated May 22, 2017, 17 pages. |
| Final Office Action from U.S. Appl. No. 14/216,859, dated Jun. 9, 2016, 16 pages. |
| Final Office Action from U.S. Appl. No. 14/360,280, dated Aug. 10, 2017, 103 pages. |
| Final Office Action from U.S. Appl. No. 14/360,282, dated Feb. 16, 2017, 10 pages. |
| Final Office Action from U.S. Appl. No. 14/360,282, dated Oct. 4, 2017, 22 pages. |
| Final Office Action from U.S. Appl. No. 14/360,284, dated Mar. 1, 2017, 10 pages. |
| Final Office Action from U.S. Appl. No. 15/082,359, dated Jan. 31, 2018, 22 pages. |
| Final Office Action from U.S. Appl. No. 15/219,063, dated Nov. 20, 2017, 27 pages. |
| Final Office Action from U.S. Appl. No. 15/354,742, dated Nov. 29, 2017, 20 pages. |
| Final Office Action from U.S. Appl. No. 15/354,857, dated Nov. 28, 2017, 23 pages. |
| First Office Action and Search report from foreign counterpart China Patent Application No. 201180076248.0, dated Mar. 17, 2016, 25 pages. |
| First Office Action and Search Report from foreign counterpart China Patent Application No. 201480024463.X, dated Apr. 1, 2017, 31 pages. (Translation available only for office action). |
| First Office Action and Search report from foreign counterpart Chinese Patent Application No. 201180076244.2, dated Mar. 22, 2016, 18 pages (Translation available only for Office Action). |
| First Office Action and Search Report from foreign counterpart Chinese Patent Application No. 201480024528.0, dated Jan. 26, 2018, 19 pages. |
| First Office Action and Search Report from foreign counterpart Chinese Patent Application No. 201480024832.5, dated Feb. 6, 2018, 15 pages. (Translation available only for office action). |
| First Office Action from foreign counterpart China Patent Application No. 201180076245.7, dated Mar. 21, 2016, 10 pages. |
| First Office Action from foreign counterpart China Patent Application No. 201280024012.7, dated May 30, 2016, 21 pages. |
| First Office Action from foreign counterpart China Patent Application No. CN201280034725, dated Oct. 26, 2015, 26 pages. |
| First Office Action from foreign counterpart China Patent Application No. CN201280034739, dated Nov. 3, 2015, 39 pages. |
| First Office Action from foreign counterpart China Patent Application No. CN201310589048, dated Feb. 2, 2016, 8 pages. |
| First Office Action from foreign counterpart Chinese Patent Application No. 201280024054.0, dated May 30, 2016, 24 pages. |
| First Office Action from foreign counterpart Chinese patent application No. 201280024095, dated May 26, 2016, 32 pages. |
| Fourth Office Action and Search report from foreign counterpart China Patent Application No. 201180076248.0, dated Nov. 9, 2017, 38 pages. (Translation available only for office action). |
| Franklin, et al., “The Expandable Split Window Paradigm for Exploiting Fine-Grain Parallelism,” ACM SIGARCH Computer Architecture News—Special Issue: Proceedings of the 19th annual international symposium on Computer architecture (ISCA '92), Association for Computing Machinery (ACM), New York, NY, vol. 20 (2), May, 1992, pp. 58-67. |
| Garmany J., “The Power of Indexing: Oracle Tips by Burleson Consulting,” Burleson Enterprises, Inc., archived on Mar. 9, 2009, retrieved Sep. 17, 2015 via Internet: web.archive.org/web/20090309201136/http://dba-oracle.com/t_indexing.power.htm, 7 pages. |
| Grant of Patent for Korean Application No. 10-2014-7016763, dated Oct. 31, 2016, 2 pages. |
| Grant of Patent for Korean Application No. 10-2015-7028745, dated Nov. 30, 2016, 2 pages. |
| Hu, et al., “An Approach for Implementing Efficient Superscalar CISC Processors,” High Performance Computer Architecture, 2006, Twelfth International Symposium on Austin, Texas Feb. 11-15, 2006, pp. 40-51. |
| Intel “Programming on Intel® Platform,” The edition team of Intel® Software College course book, Shanghai Jiao Tong University Press, published Jan. 31, 2011, pp. 175-180. |
| Intention to Grant a patent for European Application No. 07811845, dated Mar. 31, 2016, 58 pages. |
| Intention to Grant a patent for European Application No. 12150513, dated Mar. 15, 2016, 59 pages. |
| Intention to grant from foreign counterpart European Patent Application No. 12788989.7, dated Feb. 23, 2018, 47 pages. |
| International Preliminary Report on Patentability and for Application No. PCT/US2007/084710, dated May 19, 2009, 4 pages. |
| International Preliminary Report on Patentability and Written Opinion for Application No. PCT/US2007/066536, dated Oct. 14, 2008, 6 pages. |
| International Preliminary Report on Patentability and Written Opinion for Application No. PCT/US2012/038711, dated Nov. 20, 2013, 5 pages. |
| International Preliminary Report on Patentability and Written Opinion for Application No. PCT/US2012/038713, dated Nov. 20, 2013, 5 pages. |
| International Preliminary Report on Patentability for Application No. PCT/US2011/051992, dated Mar. 28, 2013, 8 pages. |
| International Preliminary Report on Patentability for Application No. PCT/US2011/061940, dated Jun. 5, 2014, 6 pages. |
| International Preliminary Report on Patentability for Application No. PCT/US2011/061953, dated Jun. 5, 2014, 7 pages. |
| International Preliminary Report on Patentability for Application No. PCT/US2011/061957, dated Jun. 5, 2014, 7 pages. |
| International Preliminary Report on Patentability for Application No. PCT/US20121030383, dated Oct. 10, 2013, 6 pages. |
| International Preliminary Report on Patentability for Application No. PCT/US2012/030409, dated Oct. 10, 2013, 6 pages. |
| International Preliminary Report on Patentability for Application No. PCT/US2012/30360, dated Oct. 10, 2013, 6 pages. |
| International Preliminary Report on Patentability for Application No. PCT/US2014/024276, dated Sep. 24, 2015, 6 pages. |
| International Preliminary Report on Patentability for Application No. PCT/US2014/024608, dated Sep. 24, 2015, 8 pages. |
| International Preliminary Report on Patentability for Application No. PCT/US2014/024677, dated Sep. 24, 2015, 7 pages. |
| International Preliminary Report on Patentability for Application No. PCT/US2014/024722, dated Sep. 24, 2015, 6 pages. |
| International Preliminary Report on Patentability for Application No. PCT/US2014/024775, dated Sep. 24, 2015, 6 pages. |
| International Preliminary Report on Patentability for Application No. PCT/US2014/024828, dated Sep. 24, 2015, 8 pages. |
| International Search Report and Written Opinion for Application No. PCT/US2007/084710, dated May 22, 2008, 6 pages. |
| International Search Report and Written Opinion for Application No. PCT/US2011/051992, dated Mar. 28, 2012, 11 pages. |
| International Search Report and Written Opinion for Application No. PCT/US2011/061940, dated Jul. 20, 2012, 8 pages. |
| International Search Report and Written Opinion for Application No. PCT/US2011/061953, dated Jul. 24, 2012, 8 pages. |
| International Search Report and Written Opinion for Application No. PCT/US2011/061957, dated Jul. 20, 2012, 8 pages. |
| International Search Report and Written Opinion for Application No. PCT/US2012/030383, dated Oct. 25, 2012, 8 pages. |
| International Search Report and Written Opinion for Application No. PCT/US2012/030409, dated Oct. 12, 2012, 7 pages. |
| International Search Report and Written opinion for Application No. PCT/US2012/038711, dated Nov. 28, 2012, 7 pages. |
| International Search Report and Written Opinion for Application No. PCT/US2012/038713, dated Oct. 29, 2012, 7 pages. |
| International Search Report and Written Opinion for Application No. PCT/US2012/30360, dated Oct. 29, 2012, 7 pages. |
| International Search Report and Written Opinion for Application No. PCT/US2014/024276, dated Jul. 31, 2014, 7 pages. |
| International Search Report and Written Opinion for Application No. PCT/US2014/024608, dated Jul. 31, 2014, 9 pages. |
| International Search Report and Written Opinion for Application No. PCT/US2014/024677, dated Jun. 30, 2014, 9 pages. |
| International Search Report and Written Opinion for Application No. PCT/US2014/024722, dated Jun. 27, 2014, 7 pages. |
| International Search Report and Written Opinion for Application No. PCT/US2014/024775, dated Jun. 2, 2014, 7 pages. |
| International Search Report and Written Opinion for Application No. PCT/US2014/024828, dated Jul. 28, 2014, 9 pages. |
| International Search Report for Application No. PCT/US2007/066536, dated Jul. 30, 2008, 2 pages. |
| Jacobson, et al., “Path-based Next Trace Prediction,” MICRO 30—Proceedings of the 30th Annual IEEE/ACM International Symposium on Microarchitecture, Dec. 1-3, 1997, IEEE Computer Society, Washington, D.C., 1997, pp. 14-23. |
| Kozyrakis, et al., “A New Direction for Computer Architecture Research,” Computer, IEEE Computer Society Press, Los Alamitos, CA, Nov. 1, 1998, vol. 31 (11), pp. 24-32. |
| Non-Final Office Action from U.S. Appl. No. 14/360,282, dated Jun. 22, 2017, 97 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/360,282, dated Oct. 21, 2016, 13 pages. |
| Non-final Office Action from U.S. Appl. No. 14/360,284, dated Oct. 21, 2016, 32 pages. |
| Non-Final Office Action from U.S. Appl. No. 14/733,827, dated Apr. 28, 2017, 99 pages. |
| Non-Final Office Action from U.S. Appl. No. 15/082,359, dated Aug. 11, 2017, 108 pages. |
| Non-Final Office Action from U.S. Appl. No. 15/219,063, dated May 30, 2017, 102 pages. |
| Non-Final Office Action from U.S. Appl. No. 15/257,593, dated Apr. 7, 2017, 37 pages. |
| Non-final Office Action from U.S. Appl. No. 15/354,742, dated Aug. 25, 2017, 152 pages. |
| Non-Final Office Action from U.S. Appl. No. 15/354,857, dated Sep. 12, 2017, 111 pages. |
| Non-final Office Action from U.S. Appl. No. 15/357,943, dated Aug. 25, 2017, 111 pages. |
| Notice of Allowance and Search Report from foreign counterpart Taiwan Patent Application No. 103109479, dated Nov. 30, 2017, 4 pages. (Translation available only for Search report). |
| Notice of Allowance from foreign counterpart Chinese Patent Application No. 200780046679, dated Feb. 6, 2017, 8 pages. |
| Notice of Allowance from foreign counterpart Korean Patent Application No. 10-2015-7029262, dated Aug. 31, 2017, 3 pages. |
| Notice of Allowance from foreign counterpart Korean Patent Application No. 10-2016-7017150, dated Oct. 30, 2017, 3 pages. |
| Notice of Allowance from foreign counterpart Korean Patent Application No. 10-2017-7002379, dated Dec. 20, 2017, 3 pages. |
| Notice of Allowance from foreign counterpart Korean Patent Application No. 10-2017-7002473, dated Dec. 20, 2017, 6 pages. |
| Notice of Allowance from foreign counterpart Korean Patent Application No. 20137027841, dated Mar. 31, 2016, 2 pages. |
| Notice of Allowance from U.S. Appl. No. 12/296,919, dated Jul. 27, 2012, 6 pages. |
| Notice of Allowance from U.S. Appl. No. 12/514,303, dated Oct. 25, 2013, 12 pages. |
| Notice of Allowance from U.S. Appl. No. 13/428,438, dated Apr. 13, 2017, 62 pages. |
| Notice of Allowance from U.S. Appl. No. 13/428,438, dated Aug. 7, 2017, 42 pages. |
| Notice of Allowance from U.S. Appl. No. 13/428,438, dated Aug. 10, 2016, 9 pages. |
| Notice of Allowance from U.S. Appl. No. 13/428,438, dated Dec. 29, 2016, 9 pages. |
| Notice of Allowance from U.S. Appl. No. 13/428,438, dated Mar. 4, 2016, 14 pages. |
| Notice of Allowance from U.S. Appl. No. 13/428,438, dated Nov. 6, 2015, 9 pages. |
| Notice of Allowance from U.S. Appl. No. 13/428,440, dated Apr. 20, 2017, 46 pages. |
| Notice of Allowance from U.S. Appl. No. 13/428,440, dated Feb. 26, 2016, 10 pages. |
| Notice of Allowance from U.S. Appl. No. 13/428,440, dated Mar. 10, 2017, 52 pages. |
| Notice of Allowance from U.S. Appl. No. 13/428,440, dated Nov. 16, 2016, 9 pages. |
| Notice of Allowance from U.S. Appl. No. 13/428,440, dated Nov. 20, 2015, 9 pages. |
| Notice of Allowance from U.S. Appl. No. 13/428,452, dated Oct. 21, 2015, 9 pages. |
| Notice of Allowance from U.S. Appl. No. 13/475,708, dated Jun. 16, 2017, 51 pages. |
| Notice of Allowance from U.S. Appl. No. 13/475,708, dated Jun. 30, 2017, 53 pages. |
| Notice of Allowance from U.S. Appl. No. 13/475,708, dated Mar. 17, 2017, 55 pages. |
| Notice of Allowance from U.S. Appl. No. 13/475,708, dated Nov. 27, 2017, 24 pages. |
| Notice of Allowance from U.S. Appl. No. 13/475,708, dated Oct. 13, 2016, 17 pages. |
| Notice of Allowance from U.S. Appl. No. 13/475,739, dated Aug. 3, 2016, 11 pages. |
| Notice of Allowance from U.S. Appl. No. 13/475,739, dated Mar. 25, 2016, 25 pages. |
| Notice of Allowance from U.S. Appl. No. 13/691,609, dated Aug. 6, 2014, 11 pages. |
| Notice of Allowance from U.S. Appl. No. 13/691,609, dated Feb. 23, 2015, 16 pages. |
| Notice of Allowance from U.S. Appl. No. 14/194,589, dated Jul. 27, 2016, 7 pages. |
| Notice of Allowance from U.S. Appl. No. 14/213,115, dated Jun. 27, 2016, 9 pages. |
| Notice of Allowance from U.S. Appl. No. 14/213,115, dated Oct. 3, 2016, 20 pages. |
| Notice of Allowance from U.S. Appl. No. 14/213,135, dated Aug. 3, 2017, 103 pages. |
| Notice of Allowance from U.S. Appl. No. 14/213,135, dated Oct. 17, 2016, 17 pages. |
| Notice of Allowance from U.S. Appl. No. 14/213,218, dated Jun. 16, 2017, 89 pages. |
| Notice of Allowance from U.S. Appl. No. 14/213,692, dated Dec. 23, 2016, 19 pages. |
| Notice of Allowance from U.S. Appl. No. 14/213,692, dated Sep. 28, 2017, 112 pages. |
| Notice of Allowance from U.S. Appl. No. 14/213,730, dated Aug. 31, 2017, 96 pages. |
| Notice of Allowance from U.S. Appl. No. 14/213,730, dated Oct. 27, 2016, 16 pages. |
| Abandonment from U.S. Appl. No. 14/360,280, mailed Apr. 4, 2019, 2 pages. |
| Abandonment from U.S. Appl. No. 15/866,323, mailed Apr. 29, 2019, 2 pages. |
| Advisory Action from U.S. Appl. No. 15/408,323, dated May 20, 2019, 3 pages. |
| Advisory Action from U.S. Appl. No. 15/283,836, dated Jul. 29, 2019, 2 pages. |
| Allowance Decision of Examination from foreign counterpart Taiwan Patent Application No. 106127331, dated Apr. 9, 2019, 3 pages. |
| Communication pursuant to Article 94(3) EPC for European Application No. 14770976.0, dated Feb. 18, 2019, 4 pages. |
| Communication pursuant to Article 94(3) EPC for Application No. 12174229.0, dated Dec. 20, 2018, 5 pages. |
| Communication Pursuant to Article 94(3) EPC for Application No. 14769450.9, dated May 17, 2019, 12 pages. |
| Communication pursuant to Article 94(3) EPC for Application No. 11876130.3, dated Jan. 15, 2019, 11 pages. |
| Communication pursuant to Article 94(3) EPC for Application No. 11876130.3, dated Oct. 29, 2018, 7 pages. |
| Communication Pursuant to Article 94(3) EPC for European Application No. 16196777.3, dated Feb. 28, 2019, 5 pages. |
| Communication Pursuant to Article 94(3) EPC for European Application No. 12763717.1, dated Mar. 22, 2019, 7 pages. |
| Corrected Notice of Allowance from U.S. Appl. No. 15/354,742, dated Jun. 21, 2019, 38 pages. |
| Corrected Notice of Allowance from U.S. Appl. No. 15/354,742, dated May 22, 2019, 32 pages. |
| Final Office Action from U.S. Appl. No. 15/283,836, dated May 7, 2019, 14 pages. |
| Final Office Action from U.S. Appl. No. 15/408,323, dated Feb. 28, 2019, 18 pages. |
| Non-Final Office Action from U.S. Appl. No. 16/166,010, dated Jul. 31, 2019, 97 pages. |
| Non-Final Office Action from U.S. Appl. No. 15/806,189, dated May 1, 2019, 145 pages. |
| Notice of Allowance from U.S. Appl. No. 15/853,323, dated Jan. 15, 2019, 15 pages. |
| Notice of Allowance from foreign counterpart Korean Patent Application No. 10-2018-7003058, dated Dec. 31, 2018, 3 pages. |
| Notice of Allowance from U.S. Appl. No. 15/354,742, dated Mar. 26, 2019, 24 pages. |
| Notice of Preliminary Rejection from foreign counterpart Korean Patent Application No. 10-2017-7003623, dated Mar. 29, 2019, 5 pages. |
| Notice of Reason for Refusal from foreign counterpart Korean Patent Application No. KR20177020829, dated May 20, 2019, 11 pages. |
| Requirement for Restriction/Election from U.S. Appl. No. 15/884,280, dated Jun. 17, 2019, 5 pages. |
| Second Office Action from foreign counterpart Chinese Patent Application No. 201480024832.5, dated Apr. 2, 2019, 10 pages. |
| Number | Date | Country | |
|---|---|---|---|
| 20180293073 A1 | Oct 2018 | US |
| Number | Date | Country | |
|---|---|---|---|
| 60865813 | Nov 2006 | US | |
| 60865816 | Nov 2006 | US | |
| 60865818 | Nov 2006 | US | |
| 60865820 | Nov 2006 | US |
| Number | Date | Country | |
|---|---|---|---|
| Parent | 15357943 | Nov 2016 | US |
| Child | 15944655 | US | |
| Parent | 14194589 | Feb 2014 | US |
| Child | 15357943 | US | |
| Parent | 12514303 | US | |
| Child | 14194589 | US |
