DE60002200T2 - SWITCHING METHOD IN A MULTITHREAD PROCESSOR - Google Patents

Description

BACKGROUND OF THE INVENTION

Field of the Invention

The present invention relates pertaining to a processor or a computer architecture. In particular The present invention relates to multiple threading processor architectures and methods of operating and executing them.

Description of the stand of the technique

In many commercial computing applications passes a lot of time during pipeline stalling and idling, rather than during more productive execution of the programs due to cache misses and latency when accessing external cache memory or external memory the cache misses. The stalling and idling are as a result of frequent Cache misses particularly disadvantageous when operating databases, such as OLTP, DSS, data search, financial predictions, computer-aided mechanical and electronic design (MCAD / ECAD), web servers, database servers and the same. So when idle waiting for data wasted a lot of time, although a processor at a higher speed can work.

A technique to stall and Reducing idle is hardware multithreading, thereby processing processing while others To achieve idle cycles. Hardware multithreading requires a replication of some processor resources, for example the replication of constructed registers (architected registers) for every thread. The replica is used for most processor resources including the instruction and data caches, address translation buffers (translation look-aside buffers (TLB)), command fetching elements and dispatchers, branch units, execution units and the like, not needed.

Adverse duplication of resources is costly in terms of the use of integrated circuits and their performance. An example of a device that duplicates resources is shown in US 5,361,337 described. There is disclosed a system having multiple copies of state elements on a processor connected to a multiplexer to enable the processor to save the context of the current instructions and to resume execution of new instructions within one clock cycle. The duplication of state elements and the inclusion of many multiplexers increases the consumption of integrated circuits and reduces the performance.

Another example of a device where a high degree of duplication of resources is achieved is in "The M-Machine Multicomputer" by Fillo et al., Proceedings of Micro-28, November 29, 1995, pages 146-156. The device by Fillo contains four cache memories and four corresponding MAP execution clusters, each have a 64-bit triple output pipeline processor that is made up of two integer computing units, a floating point computing unit, associated register files and there is a 1 KW instruction cache.

Berekovic et al. describes in "To Algorithm-Hardware-System Approach to VLIW Multimedia Processors ", Journal of VLSI Signal Processing 20, pages 163-180 (1998) another processor architecture, that uses duplicate resources to achieve multithreading. The processor has three independent Instruction streams, three sets of instructions and decoder units, each being called a thread slot designated. Each thread slot is connected to a program counter, to form a logical processor. Command and functional units are shared among the logical processors.

Discussed in a similar way Byrd et al. in "Multithreaded Processor Architectures", IEEE Spectrum, V32, N8, August 1995 different techniques for multithreading, in which a multi-thread processor architecture overhangs when toggling Context reduced or eliminated by using multiple hardware contexts to disposal be put, that is, multiple sentences of registers for general tasks, status registers and program counters.

Gulati et al in "Performance study of a multithreaded superscalar microprocessor ", Proceedings International Symposium on High-Performance Computer Architecture, 1996 a processor that supports multithreading that but not by adding this supported by duplicate resources, but by adding new ones Multithreading resources. Gulati et al. teaches adding one Scheduling unit including scheduling logic logic), which maintains a command FIFO and the commands of the FIFO Analyzes from bottom to top and issues commands that are ready for execution are. Accordingly, additional Resources needed to achieve multithreading what the circuit size Power consumption and complexity increased, although Gulati et al. no Teach duplication of resources.

What is needed is an architecture which is multithreading without duplication or addition of Hardware resources achieved, so that circuit area and Performance can be saved. Accordingly, improved multithreading circuits and operating procedures needed, which are economical in their resources and costly overhang avoid, which reduces the processor performance.

Summary of the invention

A processor reduces the wasted cycle time, which results from stalling and idling and increases the percentage processing time by using both vertical multithreading as well as horizontal multithreading supported and implemented. The allows vertical multithreading an overlap or "hide" waiting times due to cache error rates. In vertical multithreading, multi-hardware threads share the same processor pipeline. A hardware thread is typical a process, a functionally reduced process (light weight process), a native thread or the like in an operating system, which supports multithreading. Horizontal multithreading increased the parallelism inside the processor circuit structure, for example inside a single integrated circuit die that is a single chip processor forms. About system parallelism in some processor embodiments further increase multiprocessor cores are manufactured on a single die. The Advantages of horizontal threading with a one-chip multiprocessor are achieved when the processor core size due to technological progress is reduced.

The processor structure described and the operating procedure can implemented in many structural variations. For example are two processor cores with an on-chip set associative L2 cache combined in one system. In another example, four Processor cores with a direct RAMBUS interface without an external one L2 cache combined. Countless variations are possible. In In some systems, each processor core is a vertical threaded one Pipeline.

In another aspect some embodiments a computer system can handle multithreading systems and processes be built from many different processor variations that a place of execution form a variety of execution threads, for example in a "1C2T" configuration contains a single processor-The two vertical threads. In a "4C4T" configuration becomes a multiprocessor of four processors on a single The manufactured, each of the four processors is vertically four-way threaded. Countless other "nCkT" structures and combinations can be found on one or more integrated circuits are implemented dependent of the manufacturing process used and the applications for which the Processor is intended. Different systems can include caches, which are configured optionally, for example as separate L1 cache memories and separate L2 caches or separate L1 caches and shared L2 caches, or separate L1 caches and shared L2 cache. In one aspect of some embodiments a processor freezes from multithreading systems and processes in response to a cache miss lock all State of a pipeline at execution of a thread. For each thread separately and independently leads from each other the processor executes the commands and manages the machine status. The functional properties of an independent thread state are determined by the Pipeline stored in the pipeline registers to the processor to allow execution of a blocked thread to move the pipeline for one to release the idle thread beforehand and to later release the execution of the deferred blocked thread in exactly the state of the blocked threads resume immediately before the Switching the thread was present.

In another aspect of embodiments from some multithreading systems and procedures a processor has a "four-dimensional" register structure in which Register data structures N times for vertical threading in combination with three-dimensional Memory circuit are available. The multidimensional memory is built up by a memory, such as a register file or a memory, constructed as a plurality of two-dimensional memory levels is.

In another aspect by some embodiments of multithreading systems and Method implements a processor of an N-bit flip-flop global Substitution. Converted to implement multiple machine states the processor the 1-bit flip-flops in the memory cells of the blocked vertical thread N-bit global flip-flop, where N is the number of vertical threads is.

In one aspect of some embodiments of processors and processor methods the processor improves the continuity efficiency and maintains an increased parallelism by introducing Multithreading in an existing and available processor core. The multithreading is implemented in two steps, which vertical and horizontal multithreading included. The processor core will be added, to multiple machine states to support. embodiments of the system which is the supplement of an existing processor core advantageously use, influence hundreds of man years of hardware and software development by the lifetime of a proven processor pipeline generation is extended.

In another aspect of some embodiments of multithreading systems and methods, a processor includes logic for tagging thread identification (TID) for use with processor blocks that are not blocked. The relevant unblocked blocks contain cache memory, addressum set buffer (TLB), a load buffer asynchronous interface, an external memory management unit (MMU) interface and other elements.

In a further aspect of the exemplary embodiments of multithreading systems and methods, a processor contains a cache memory, which is divided into a plurality of N cache sections is. Splitting the cache avoids interference, "Pollution" or a "crosstalk" between threads. A technique for dividing the cache memory uses the logic to store and communicate the thread identification (TID) bits. The cache memory uses the cache indexing logic. For example can the TID bits for the bit with the highest Meaning of the cache index are inserted.

In another aspect of the embodiments In multithreading systems and methods, a processor contains control logic for switching threads that have a fast switching operation threads in response to an L1 cache miss lock performs. The quick operation to switch threads implemented a or several different switching methods for threads. A first business to switch threads is "unconscious" (oblivious) switching of a thread every Nth cycle in which the individual flip-flops determine a thread switch locally without notifying the Surrender blocking. This "unconscious" technique avoids that Use an additional one global connection between threads for thread selection. A second Operation for switching threads is the "semi-unconscious" (semi-oblivious) Switching threads, for use with an existing "pipeline block" signal (if there is one). The pipeline block signal has two functions, first as a notification of pipeline blockage and second as a thread selection signal between the threads, so again the use of an additional Avoided global connection between threads for thread selection becomes. A third operation to switch threads is an "intelligent global schedule "thread switching, in which a decision based on a variety of signals to switch a thread, contains the following signals: (1) an L1 data cache miss blocking signal, (2) an instruction buffer empty signal, (3) an L2 cache miss signal, (4) a thread priority signal, (5) a thread time signal, (6) an interrupt signal or others Sources to trigger. In some embodiments, the thread selection signal becomes similar to that Distribution of a clock signal using a clock tree, so fast as possible sent out. In some systems, a processor routes a selection signal for threads, which is applied to the flip-flops by a scan enable (SE) signal of a scannable flip-flop overloaded becomes.

In an additional aspect of embodiments of multithreading systems and procedures a processor has anti-aliasing logic associated with an L1 cache that the L1 cache over anti-aliasing is shared by the threads. The L1 cache is a virtually indexed, physically marked cache, which is under the threads are shared. The anti-aliasing logic avoids Problems from multi-virtual address mapping to a virtual one Address result. The anti-aliasing logic explains either Duplicate L1 cache entries invalid or apply them the latest status.

Another aspect of some embodiments of the multithreading system and procedures a processor logic for obtaining very fast functionality for handling of exceptions during the execution of non-threaded programs by using a multi-thread functionality type as Response to an exception is called. The processor works during the execution through the multiple machine states while the multi-thread conditions carries or during he runs the non-threaded programs. The very fast treatment logic contains connect to an exception signal line to select logic threatening what causes an exception signal to switch to be carried out in thread and machine state. Switching in thread and Machine condition causes the processor to go without output the pipeline or the queue and without the inherent time penalty the operating system software, which stores the registers and restores to immediately enter the exception handling routine and to leave it again.

An additional aspect from some Multithreading systems and procedures is a thread reservation system or a thread locking system in which a thread path for use by a selected one Thread is reserved. Thread control logic can be a special thread choose, the one with priority compared to other threads. A thread with high priority can be linked to a company with strict time limits, which is an operation compared to other threads frequently and mostly accomplished becomes. The thread control logic controls the operation of switching of threads so that a specific hardware thread for use by the selected one Thread is reserved.

In another aspect of some embodiments of multithreading systems and methods, a processor includes logic support lightweight processes and native threads. The logic contains a block that blocks the marking of thread IDs and blocks the opening of cache memories since the lightweight processes and the native threads share the same virtual marking space.

In another additional Aspect of some embodiments the multithreading systems and methods contain some processors a thread reservation functionality.

Short description he characters

The features of the described exemplary embodiments are further elaborated in particular in the appended claims. however can the embodiments of the invention in terms of both the structure and the Best method of operation with reference to the following description and the accompanying drawings are understood.

1A and 1B are timing diagrams each showing the flow of execution of a single thread processor and a vertical multi-thread processor.

2A . 2 B and 2C FIG. 10 are timing diagrams each showing the flow of execution of a single-thread processor, a vertical multi-thread processor, and a vertical and horizontal multi-thread processor.

3 FIG. 12 is a schematic and functional block diagram illustrating a design configuration for a single processor vertically threaded processor suitable for implementing various multithreading techniques and systems that improve multithreading performance and functionality.

4A . 4B and 4C are diagrams illustrating an embodiment of a pulse-based high-speed flip-flop that can be used advantageously to achieve multithreading in an integrated circuit. 4A Figure 3 is a schematic block diagram illustrating the control and storage of circuit blocks using high speed multibit flip-flops. 4B Fig. 3 is a schematic circuit diagram showing a multibit bistable multivibrator (flip-flop) circuit. 4C Fig. 11 is a timing chart showing the timing of the multi-bit flip-flop.

5 Fig. 3 is a schematic block diagram illustrating N-bit "thread selectable" flip-flop replacement logic used to create vertically multi-threaded functionality in a processor pipeline while having the same circuit size as a single-threaded Pipeline is maintained.

6 Figure 11 is a schematic block diagram illustrating thread switch logic that very quickly generates a thread identification (TID) signal that identifies an active thread from a plurality of threads.

7A and 7B are schematic block diagrams each showing an example of a split cache and a diagram which is an example of an address technique for the split cache.

8th Figure 3 is a schematic block diagram showing suitable anti-aliasing logic for use with various processor implementations including a cache, such as an L1 cache and L2 cache or others.

9 Fig. 4 is a schematic functional block diagram showing a design configuration for a single-chip, dual processor, vertical-tread processor suitable for implementing various multi-thread techniques and system implementations that improve multi-thread performance and functionality.

10 Fig. 3 is a schematic functional block diagram showing an alternative design for a single processor vertically threaded processor configuration capable of implementing various multithreading techniques and system implementations that improve multithreading performance and functionality.

11 FIG. 5 is a schematic functional block diagram showing an alternate design for a single chip dual processor vertically threaded processor configuration suitable for implementing various multithreading techniques and system implementations that improve multithreading performance and functionality.

12 Figure 3 is a schematic block diagram showing a processor and processor architecture suitable for implementing various multithreading techniques and system implementations that improve multithreading performance and functionality.

13 Fig. 12 is a schematic perspective diagram showing a multidimensional register file.

14 Fig. 4 is a schematic circuit diagram showing a conventional implementation of register windows.

15 Fig. 10 is a schematic circuit diagram showing a plurality of bit cells of a register window of the multi-dimensional register file, which avoids wasting space of an integrated circuit by using the condition that only one window is read and only one window is written at a time.

16 shows a schematic circuit diagram illustrating a suitable bit storage circuit that stores a bit of the local register for the multi-dimensional register file with eight windows.

17A and 17B are schematic diagram and a schematic block slide, respectively grams showing the sharing of tabs under the windows next to each other.

18 Fig. 4 is a schematic circuit diagram showing an implementation of a multi-dimensional register file for registers shared by a plurality of windows.

The use of the same reference symbols in different drawings there are the same or identical parts on.

Description of the embodiments

Regarding the 1A and 1B represent two timing diagrams each of the execution flow 110 in a single thread processor and the execution flow 120 in a vertical multi-threaded processor. Processing applications, such as database applications, spend a significant amount of execution time in a locked state, waiting for the response from memory. 1A Fig. 3 is a highly schematic timing diagram showing the execution flow 110 of a single thread processor executing a database application. In one illustrative example, the single-thread processor is a four-way superscalar processor. Hatched areas 112 correspond to the periods of execution in which the single thread processor issues instructions. Free areas 114 correspond to periods of time in which the single-thread processor core is blocked and waiting for data or commands from memory or an external cache. A typical single-thread processor running a typical database application executes instructions 30% of the time, with 70% of the time in a blocked state. The 30% usage rate is an example of the inefficient use of resources by a single thread processor.

1B Fig. 3 is a highly schematic timing diagram showing the execution flow 120 of similar database applications by a multi-thread processor. Applications, such as database applications, have a high degree of inherent parallelism due to the focus on heavy use of the database application and the common database function in processing some independent transactions at the same time. The basic concept of using the multi-thread function uses processor resources efficiently if a thread is blocked by the execution of another thread while the blocked thread remains blocked. The execution flow 120 creates a first thread 120 , a second thread 124 , a third thread 126 and a fourth thread 128 , all of which are shown with hatching in the time diagram. If a thread is blocked, for example the first thread 122 , then another thread switches, for example the second thread 124 , to run in another unused or idle pipeline. Free areas 130 correspond to idle times when all threads are blocked. The entire use of the processor is significantly improved by multithreading. The illustrative technique of multithreading uses the simulation of built registers for each thread and is called "vertical multithreading".

Vertical multithreading is at Processing applications advantageous in which frequent cache misses lead to sensitive time penalties. If the cache misses cause a first thread to block, then allows vertical multithreading Cache a second thread that this is executing when the processor would otherwise remain idle. Thus takes over the second thread the execution on the pipeline. A context switch from the first thread to the second thread requires the storage of useful states of the first threads and assigning new states to the second thread. If the first thread starts again after the stalling, then will the saved states restored and the first thread goes into processing. The vertical multithreading is at the expense of processor resources, which is used to save and restore the thread states become.

Regarding the 2A . 2 B and 2C represent three highly schematic timing diagrams each of the execution flow 210 of a single thread processor, an execution flow 230 a vertical multi-thread processor and an execution stream 250 of a combined vertical and horizontal multi-thread processor. In 2A represent the hatched areas 212 Execution periods and free spaces 214 represent time periods in which the single-thread processor core idles as a result of blocking, which represents the inefficiency of a single-thread processor.

In 2 B contains the execution flow 230 execution of a first thread in a vertically threaded processor 232 and a second thread 234 , both of which are hatched in the timing diagram, and an idle time that is in a free area 240 is shown. An efficient command execution is shown when a thread blocks and in response to the blocking another thread switches to the state of processing on the otherwise unused or idle pipeline. In the free areas 240 an idle time occurs when all threads are blocked. For the vertical multi-thread, the processor maintains a separate processing state for T execution threads. Only one thread is active at a time. The vertical multi-thread processor switches execution to another thread in the event of a cache miss, for example an L1 cache miss.

A horizontally threaded processor, wel Using a technique called multiple chip processing, multi-processors are combined on one integrated circuit die. The multiple processors are threaded vertically to form a processor with both vertical and horizontal threading, which increases execution efficiency and reduces latency in a multiplicative manner. In 2C contains the execution flow 250 execution of a first thread in a vertically and horizontally threaded processor 252 , which runs on a first processor, a second thread 254 , which runs on the first processor, a first thread 256 that runs on a second processor and a second thread 258 that runs on the second processor. An idle time is due to the free area 260 for both the first and the second processor. The execution of the first thread 252 and the second thread 254 on the first processor represents vertical threading. Similarly, execution of the first thread represents 256 and the second thread 258 vertical threading on the second processor. In the descriptive embodiment, a single integrated circuit includes both the first processor and the second processor, with the multiple processors operating in parallel, so that the multithreading operation is a horizontal multithreading or an integrated circuit chip -Multiprocessing (CMP) in combination with the vertical multithreading of the first processor and the second processor. The combination of vertical multithreading and horizontal multithreading increases parallelism and performance of the processor and achieves execution efficiency that exceeds the efficiency of a processor that only uses vertical multithreading. The combination of vertical multithreading and horizontal multithreading also advantageously reduces the connection latency between the local (on-chip) multi-processor tasks by eliminating a great deal of signaling on connecting lines with high latency between the integrated circuit chips. Horizontal multithreading also takes advantage of processor speed and performance improvements inherent in the reduced circuit size in the development of silicon processing.

For each vertically threaded processor, efficient instruction execution is performed when one thread is blocked and in response to the block another thread switches to execution on an otherwise unused or idle pipeline. In the free areas 260 an idle time occurs when all threads are blocked.

The vertical multithreading is advantageously used to clear the blockages due to cache misses to overcome or to hide and thereby the execution by the processor to continue instead of executing to block. Vertical multithreading thus improves performance in commercial multi-processor and multithreading applications. The shortened vertical multithreading with advantage the time to switch contexts from the millisecond range in the nanosecond range. Vertical multithreading is very much from Advantage in all processing environments, including embedded, desktop and server applications and the like.

Horizontal multithreading or the circuit chip multiprocessing consequently increases the parallelism on the Chip by using the increasingly smaller processor core sizes.

Although the explanatory example is the execution of two opposite vertical multithreading processors, each showing opposite vertical Multithreading processor executes two threads, can in another example a different number of opposing ones execution processors run different numbers of threads. The number of threads which a processor executes, can be the same or different from the number of threads which antithetical and run in parallel on another processor.

With some processor designs, the vertical flows and horizontal multithreading in the fundamental design of the Processor, which has the advantage of being modular and flexible structures are created which are scalable promote the design. With other processor designs, multithreading flows into existing and mature processor designs to incorporate existing technological Influence basics and the performance of multi-processing and increase multithreading applications. A particularly suitable example of the processor design for conversion with multithreading functionality is a Ultra SPARC processor. In some designs, it becomes vertical and horizontal Multithreading by minimally converting an existing one Processor core achieved, the changes in the logical and physical design reduced and the entire revision the interconnection, the rework and the costs for a massive revision of the integrated circuits can be avoided.

In terms of 3 FIG. 2 is a schematic functional block diagram of a configuration for a single processor vertically threaded processor configuration 300 that is suitable for implementing various multithreading techniques and system implementations that improve multithreading performance and functionality. The single processor vertically threaded processor 300 has a single pipeline that is shared by a variety of machine states or threads, which maintains a variety of machine states at the same time. Is currently a thread active, i.e. not blocked, which is selected and delivers data to functional blocks connected to the pipeline. If the active thread is blocked, the pipeline immediately switches to an unblocked thread, if there is any unblocked thread at all, and begins executing the unblocked thread.

The single processor vertically threaded processor 300 contains a thread 0 machine state block 310 , which forms a machine state of a first thread (thread 0). The single processor vertically threaded processor 30 also includes a Thread 1 machine state block 312 , which forms a machine state of a second thread (thread 1), which maps the machine state of thread 0. The thread 0 machine state block 310 and Thread 1 machine state block 312 are fabricated in a single integrated circuit logic structure using a high-speed, multi-bit flip-flop design and a "four-dimensional register file structure", and Thread 0 and Thread 1 instructions using vertical threading to one shared processor pipeline 314 are fed. The multidimensional register file uses register file structures which exist N times for vertical threading in combination with a three-dimensional memory circuit. The three-dimensional memory is made by building a memory, such as a register file or a memory, as a plurality of two-dimensional memory layers.

The processor freezes in response to cache miss stalling 300 the overall pipeline state of a thread to be executed in the shared processor pipeline 314 on. The processor 300 issues instructions that manage the machine status of each thread separately and independently. The functional properties of an independent thread state are stored in the entire pipeline, which extends to the pipeline registers, to the processor 300 to allow the execution of a blocked thread to be frozen by freezing the active state in the pipeline 304 for a previously idle thread by enabling the previously idle thread in the pipeline while maintaining the state of the newly idle thread in the pipeline and later resuming execution of the deferred blocked thread to exactly the state of the blocked thread that immediately before switching the thread.

The shared processor pipeline 314 is connected to a dual load / store unit, which includes a thread 0 load / store unit 316 and a thread 1 load / store unit 318, which each perform the accesses for loading and storing the data of the instruction threads 0 and 1 , The load / store units generate a virtual address of all load and store operations when accessing a data cache, decouple the load errors from the pipeline via load buffers (not shown) and decouple the store via memory buffers. Up to one load or store operation is issued per cycle.

The shared processor pipeline 314 and the dual load / store unit are with a data storage interface 320 connected, which contains a shared data cache and a shared data storage management unit (DMMU). The shared data cache is used to cache data from both Thread 0 and Thread 1 instruction sequences. In an exemplary processor 300 the data cache is a write-through-non-allocating-16 kilobyte direct mapped 32-byte line cache. The data cache is virtually indexed and physically tagged using a tag array that has two ports so that tag updates resulting from line fills do not conflict with reading tags for incoming load commands. Special surveillance buses (snoops) of the data cache use the second marker connection, so that incoming charging instructions are processed without delay by the special surveillance bus. The shared data storage management unit (DMMU) converts the virtual to the physical address.

The dual load / store units are also equipped with an external cache control unit (ECU) 322 connected to an external cache bus 324 connected is. The external cache control unit 322 is also available with an Ultraport Architecture Connection (UPA) bus 326 via a memory interface unit (MIU 328 connected. The external cache control unit 322 and the memory interface unit (MIU) 328 are merged between thread 0 and thread 1 to provide the functions of cache miss processing and an interface to external devices to be used in combination via a shared instruction control block 330 a variety of execution threads to the thread 0 machine state block 310 and feed thread 1 machine state block 312. The unified external cache controller 322 and the memory interface unit (MIU) 328 include a thread identifier (TID) to identify and identify a transaction on the external cache bus 324 and the UPA bus 326 is accessed. In the processor 300 the TID is only internal to the processor 300 (integrated circuit chip) detected. Outside the integrated circuit chip, the hardware interacts with the processor 300 just like you with a single CPU interacts with a UPA bus and an external cache bus interface. In contrast, the software interacts with the processor outside of the integrated circuit chip 300 , as it interacts with two logical CPUs.

The command control block 330 contains an instruction cache (L1), a branch prediction unit, NFRAM, and an instruction memory management unit (IMMU), all of which are shared by the multiple threads, thread 0 and thread 1. In an exemplary processor, the instruction cache is a 16 kilobyte two-way set associative cache with 32 byte blocks. The instruction cache is physically indexed and physically marked. The set is pre-calculated as part of a "next field" so that only index bits of an address are needed to address the cache. The command memory management unit (IMMU) supports the address conversion from virtual to physical addresses of command program counters (PCs). In order to read the condition branches in advance, a dynamic branch prediction is implemented in hardware, which is based on a two-bit history of a branch. In an exemplary processor, a field to be filled next is associated with four instructions in the instruction cache, which points to the next line to be read in advance. Up to twelve instructions are stored in an instruction buffer and output to the pipeline.

The external cache control unit 322 manages the instruction cache (L1) and data cache misses and allows access to the external cache on every other cycle. Memory operations that fail in the data cache are healed by multiple byte data cache entries by two consecutive accesses to the external cache. Prefetching instructions that miss the instruction cache are cured by the multiple byte instruction cache inputs that use four consecutive parity-protected external cache accesses.

The external cache control unit 322 supports DMA accesses to the external cache and maintains data coherence between the external cache and main memory (not shown).

The memory interface unit (MIU) 328 controls transactions on the UPA bus 326 , The UPA bus 326 runs at a fraction (e.g. 1/3) of the processor clock.

The vertical improves with advantage Multithreading the processor performance when loading conventional Applications that have high cache miss rates with a high Miss penalty, low processor utilization (30% to 50% of OLTP) and latency periods, which are one way to control the Execute overlap to take advantage of the cache miss wait times.

Vertical multithreading is too for applications with sequential and parallel processing applications with frequent Context switching is an advantage.

Vertical multithreading throws in In terms of a processor some costs in terms of resources, which are used to save and restore the thread states. Change the cost yourself in dependence from the implementation of the multithreading resources. For example a software implementation typically causes an increase in time, that negates any gain in latency. In another example, the pipeline stages be duplicated while trying to share as many resources as possible this leads to high costs in the silicon area as a disadvantage.

An advantageous technique for implementation of vertical multithreading, as a high-speed multibit flip-flop design is called contains the design of pipeline registers (flops) with multiple memory bits. The individual bits of a flip-flop are assigned to a separate thread. When a first thread blocks, typically due to a cache miss, then the active bit of a flip-flop is removed from the pipeline path removed and another bit of the flip-flop becomes active. The states of the blocked threads are shown in a temporarily inactive bit of the individual flip-flops in a pipeline stage. The high-speed multibit flip-flop design sets the placement of a multibit flip-flop at the end of each Pipeline stages. The individual bits of the multibit flip-flop are individually accessible and controllable to switch from a first thread to one second thread to allow when the first thread blocks.

In terms of 4A FIG. 5 is a schematic block diagram of control and memory blocks of a circuit that uses high-speed multibit flip-flops. A multibit flip-flop block of memory 410 contains a memory head block 412 and a multibit flip-flop block 414 , The memory head block 412 routes time signals and thread selection signals to the multibit flip-flop block 414 to. Input signals in the memory block 412 contain a clock signal 14clk that is external to the multibit flip-flop memory block 410 is supplied, a combined scan enable and clock enable signal se_ce_1 and a thread identification signal (TID) tid_g, which the multibit flip-flop memory block 410 is externally supplied by the thread selection circuit. The memory head block 412 derives an internal flip-flop clock signal clk, the inverse of the internal flip-flop clock signal clk_1 and a scan clock signal sclk from the external clock 14clk and the scan enable and clock enable signals se_ce_1. The memory head block 412 gives an internal thread ID signal tid based on the thread identification signal (TID) tid_g out. The memory head block 412 operates one or more flip-flop cells in the multibit flip-flop block 414 , The multibit flip-flop block typically contains 414 one to 32 bistable multivibrator cells, although more cells could be used. The internal flip-flop clock signal clk, the inverse of the internal flip-flop clock signal clk_1, the scan clock signal sclk and the internal thread ID signal tid are obtained from the memory header 412 to the multibit flip-flop block 414 fed.

In addition to the internal flip-flop clock signal clk, the inverse of the internal flip-flop clock signal clk_1, the scan clock signal sclk and the internal thread ID signal tid, the multibit flip-flop block receives 414 also an input signal d and a scan chain input signal si.

In terms of 4B shows a schematic circuit diagram of a multiple bit bistable multivibrator (flip-flop) circuit. A conventional flip-flop is a single bit memory structure and is commonly used to reliably sample and store data. A flip-flop is typically a basic component of a semiconductor chip with a single phase clock and a determining major factor in the overall clock speed of a microcontroller or microprocessor. A new pulse-based multibit high-speed flip-flop 400 is used to speed up the functionality and performance of a processor.

A single cell of the pulse-based, multi-bit, high-speed flip-flop 400 contains an input stage with a push-pull gate driver stage 402 , The push-pull gate driver stage 402 works as a push-pull circuit to pulse with a short duration via an inverter 438 to a multibit memory circuit 428 and output an output line q. The push-pull gate driver stage 402 has four MOSFETs connected in series in a source-drain path between the VDD and VCC references, which is a p-channel MOSFET 418 , a p-channel MOSFET 420 , an n-channel MOSFET 422 and an n-channel MOSFET 424 contain. The p-channel MOSFET 418 and the n-channel MOSFET 424 have gate connections which are connected to the input signal d. The p-channel MOSFET 420 has a source-drain path between the p-channel MOSFET 418 and the knot 426 lies, and a gate terminal, which is connected to the inverse of the internal flip-flop clock signal clk_1. The n-channel MOSFET 422 has a source-drain path between the node 426 and the n-channel MOSFET 424 lies, and a gate terminal, which is connected to the internal flip-flop clock signal clk. If the inverse clock signal clk_1 and the input signal d have a low state at the same time, then the node becomes 426 through the p-channel MOSFET 418 and the p-channel 420 brought to a high state. If the internal flip-flop clock signal clk and the input signal d have a high state at the same time, then the node becomes 426 through the n-channel MOSFET 424 and the n-channel MOSFET 422 brought to a low state. Accordingly, the pulses with the short duration are caused by the operation of the p-channel MOSFET 420 and the n-channel MOSFET 422 which generates the data to be scanned at the input terminal d at the node 426 forward on instruction of the clock signal clk. When the internal flip-flop clock signal clk is output, the node stops 426 a value that is the inverse of the input signal d. The driving forces of the transistors 418 . 420 . 422 and 424 are selected for different functions during different conditions, such as data sampling and forwarding, thread switching and scanning.

The exemplary multibit memory circuit 428 contains two memory cells 430 and 440 , although other embodiments may include a single memory cell or multiple memory cells. A memory cell 430 or 440 contains a switch 432 respectively. 442 and a static storage element or latch 434 respectively. 444 , The toggle is used to select a particular latch corresponding to the thread identifier (TID) that is active during a short duration clock pulse. When the internal flip-flop clock signal clk is output, the inverse of the input signal d through the memory cell 430 or 440 , which is selected by the thread identifier (TID). In the exemplary system, the memory cell 430 stored when the TID value is 0, so the storage element 434 stores the inverse of the input signal d. In a similar way, the memory cell 440 stored so that the value of the input signal d is maintained when the TID value is 1. Other embodiments of a pulse-based multibit high-speed flip-flop 400 can be used which contain additional memory cells which, for example, use a multibit TID and a large number of switches, multiplexers or other functionally equivalent switches to select between the memory cells.

The multibit memory circuit 428 is with the knot 426 connected and thus connected to the data path from the node 426 connected to output line q, but is not in the data path between the node 426 and the output line q inserted. In particular, a single line forms the input connection and the output connection to the memory cells 430 and 440 so the multibit memory circuit 428 no delay between the nodes 426 and the inverter 438 generated. The connection of the multibit memory circuit 428 outside the path of the data flow prevents a delay in the data signal and thus increases the rate of propagation of the data signals. The resulting improvement in the data transfer rate increases the time available for signal processing in a computer system, which improves the system processing speed. In contrast, a conventional pipeline generally contains conventional memory elements or latches that are in the path of the data flow and thereby slow the propagation of a signal and reduce the time for signal processing in a processor, which leads to a reduction in processor processing speed.

The pulse with the short duration at the node 426 activates the static storage element or the latch 434 . 444 which is selected by the TID signal. The latches 434 and 444 are edge-triggered for sampling data in a narrow time window and can be set up for operation with both positive edges and negative edges of the pulse signals. The multibit, pulse-based, high-speed flip-flop 400 is connected to the bus select lines to determine which of a plurality of bits is active. Only one bit is active at any time and the active bit holds and drives an output signal via the inverter 438 on the output line q. If the active bit is switched with one of the inactive bits, the output signal of the latch changes 434 or 444 corresponding.

The bits of the pulse-based high-speed flip-flop 400 can optionally be made scannable.

In one example, the high-speed flip-flop 400 a master-slave flip-flop, which replaces a single-bit master-slave flip-flop. Other types of flip-flops known in electronics can be converted to multi-bit flip-flops for use in a multi-thread processor.

In terms of 4C represents a timing diagram of the timing of the multibit flip-flop 400 The clock and inverted clock signals clk and clk_1 generate a clock pulse 450 so that data present just before the clock transition or "edge" on output line d determines the initial state on line q after the clock has changed. The internal flip-flop clock signal clk is output by the clock pulse 450 to generate so that the knot 426 holds a value that is the inverse of the input signal d. During the clock pulse 450 becomes the inverse of the input signal d in the memory cell 430 or the memory cell 440 stored, as determined by the thread identifier (TID). The flip-flop 400 samples the signal in a short time window to generate an edge trigger function.

If the internal flip-flop clock signal clk is no longer output, then the signal at the node 426 through the memory cells 430 and 444 determined, this being determined by the TID control signal. After a suitable delay, which is sufficient for the sampling signal at the node 426 in the latch 434 or 444 save a second pulse 452 at the knot 426 output by the inverter 438 inverted and output on the output line q.

In the exemplary pulse-based high-speed flip-flop 400 are the latches 434 and 444 advantageously removed from the direct path of signal transmission and thus do not degrade the signal speed. The pulse-based high-speed flip-flop 400 has no response time, but has a relatively long hold time.

In contrast, a conventional flip-flop includes a memory element that is in the path of the data flow, slows signal propagation and shortens the amount of time required for signal processing, thereby reducing system operating speed. The described flip-flop 400 contains a storage element that is not in the direct path of signal propagation and is not an obstacle to system operating speed.

In terms of 5 Figure 4 shows a schematic block diagram of N-bit "thread selectable" flip-flop substitution logic 500 which is used in some multithreading systems and process configurations. A processor includes an implementation of total N-bit flip-flop substitutions to support multi-machine states. The processor design includes a logical replacement of the 1-bit flip-flops of the blocked vertical thread to N-bit total flip-flops, where N is the number of vertical threads. The flip-flop substitution logic 500 Advantageously converts the single bit flip-flop logic to multi-bit flip-flop logic without increasing the surface area of the integrated circuit while maintaining the same base area so that the size of the integrated circuit during the formation of multi-thread Data paths stays the same. The flip-flop substitution logic 500 advantageously creates the multi-thread paths without using multiplexers to switch between the threads. The use of multiplexers would increase the integrated circuit area and thereby the inherent advantages of flip-flop substitution logic 500 negate.

The N-bit "thread selectable" flip-flop substitution logic 500 is used to create a vertical multi-threaded function in a processor pipeline while maintaining the same circuit size, including area, aspect ratio, metallic base area, and junctions as in a single-threaded pipeline. The N-bit "thread selectable" flip-flop substitution logic 500 adds an additional bit or a plurality of additional memory bits in each 1-bit flip-flop used to process the pipe line blockages exist. The N-bit "thread selectable" flip-flop substitution logic 500 is activated by a scan enable (SE) signal from a scannable flip-flop to select an active thread. The thread is selected based on a thread identification signal (TID). The exemplary N-bit "thread selectable" flip-flop substitution logic 500 represents a two-bit substitution logic, which is a T0-bit memory 510 and a T1 bit memory 512 for storing two threads to be executed. The exemplary N-bit "thread selectable" flip-flop substitution logic 500 is a simple D flip-flop with a single bit thread identifier (TID), which is the T1 bit memory 512 selects, and the inverse signal of the TID signal, which is the T0 bit memory 510 selects.

In one class of processor designs, the N-bit "thread selectable" flip-flop substitution logic 500 used with advantage to convert an existing single-thread processor to a multi-threaded configuration. Accordingly, the N-bit "thread selectable" flip-flop substitution logic 500 used to replace most of the standard 1-bit flip-flops in a processor with a special type of flip-flop (FF) that has multiple state bits and is thread selectable. In a particular application, the N-bit "thread selectable" flip-flop substitution logic 500 used to implement a MegaSPARC multiple thread processor based on an existing Ultra SPARC II processor core design.

Each bit in the N-bit "thread selectable" flip-flop substitution logic 500 corresponds to a single machine state of a thread and forms a so-called "virtual CPU". Only one bit is active at a time, so that only one of a large number of virtual CPUs uses the pipeline at the same time. When the active virtual CPU receives a data cache or instruction cache miss, the virtual CPU sends an input request to an external cache and initiates thread switching, which enables another virtual CPU to become active.

Although the illustrative example uses N-bit "thread selectable" flip-flop substitution logic 500 where N is two and the processor implementation processes two threads, any suitable number of bits for the number N based on the desired computing applications, as well as processing considerations when generating memory structures and switches in a given circuit size, can be implemented ,

In the exemplary processor, the N-bit "thread selectable" flip-flop substitution logic 500 implemented in most but not all functional components of the processor. The N-bit "thread selectable" flip-flop substitution logic 500 is implemented for flip-flops in functional components including control / status registers and pipeline stage registers. Other components of the processor, including processor back-end logic, such as external cache and memory interface components, can implement conventional flip-flops. The back-end logic, which processes the cache input requests, is shared by all virtual CPUs, so that a multi-bit flip-flop conversion is not necessary.

The input request for the virtual CPU, which is replaced is processed even when the virtual CPU is inactive. When data is returned on the data entry request then the data is temporarily buffered to it later, when the thread becomes active again, enter it in the L1 cache (either the data cache or the instruction cache). Until the replaced virtual CPU is active, it is currently setting active (replacing) virtual CPU continue processing until the replacing virtual CPU to a thread switch, such as an L1 cache miss. When the thread switch signal occurs, which ends the replacing virtual CPU, the processor switches to another virtual CPU that is not blocked (if possible the first replaced virtual CPU). When all virtual CPUs are blocked and waiting for cache misses, the pipeline is free and blocked, until data is returned from at least one virtual CPU become.

Treated in the event of a miss when taking a command the back-end logic enters the instruction cache of a non-active virtual CPU to a similar one Way. To an incorrectly set thread switching too avoid, a virtual CPU is not replaced until the instruction cache miss causes the instruction buffer to be empty.

In some vertical multithreading processor designs, vertical multithreading is advantageously implemented by using a fast, e.g. nanosecond, context switch that improves the performance of sequential and parallel processing applications that undergo frequent context switches are. The fast switching of the context or thread, which is in the nanosecond range, is advantageous compared to conventional context switching techniques, which generally run in a time range in the order of microseconds to milliseconds, which are several orders of magnitude slower than the context switching described here. The fast context switching in the nanosecond range is threaded by the ability to freeze the pipeline and by forwarding multiple data threads through a multiple Structure achieved, which simultaneously stores data from multiple threads, for example by using multiple bit flip-flops. Data from an active thread updates the stored data, while data in inactive threads remains frozen. Switching is done by switching the thread pathways between the states where the data is updated and the states where the data remains frozen. In contrast, traditional context switching requires flushing the entire pipeline and storing data from a first thread's register files in memory and restoring a second thread's data from memory in the register files. These are all very time-consuming tasks.

In some applications, the context is typical switched in response to the interrupts, hardware and Software interrupts are included, both internally and also happens externally of a processor. Calculation applications, which are common Context switches are subject to include disk servers, network servers, Web servers, telecommunications applications and the like.

In an exemplary system, the fast context switch, which is in the nanosecond range, is implemented in hardware, advantageously eliminating an overhang of software during the saving and restoring of the processor state. In terms of 6 Figure 4 shows a schematic block diagram of thread switching logic 610 that generates a thread identification signal (TID) that identifies an active thread among a plurality of threads.

A processor contains the thread switching logic 610 to achieve a very fast exception handling function while executing non-threaded programs by calling a type of multi-threaded function in response to the exceptions. During the processing of the multi-threaded conditions or during the execution of the non-threaded programs, the processor runs through the multiple machine states during execution. The very fast execution handling logic includes a connection of an exception signal line to the thread selection logic, which contains an exception signal or a trap to bring a toggle into the thread and machine state. The toggle switch in the thread and machine state causes the processor to immediately enter and exit the exception processing routine without typically calling the operating system or software processing and without the inherent time penalty of the operating system software that stores and restores the registers. The connection of the execution line directly to the thread selection logic advantageously causes an exception to call a context or a thread switch, which remarkably reduces the software or system overhead penalty.

The use of the multi-threaded multi-processor configuration in combination with the thread switching logic 610 and the use of various compiler techniques speeds up the execution of sequential programs. For example, a compiler can be optimized to automatically create speculative parallel threads in sequential, non-numeric programs. The compiler can also be optimized to speculatively move the load instructions ahead of store instructions and to execute the load and store instructions in separate parallel threads.

In another example, the Compiler can be controlled so that it has speculative parallel threads (Epochs) when running through loops with speculative execution starts in which the branch conditions are predicted. If the speculation is uncertain, the compiler can control execution, to run a variety of threads, all possible Handle branch conditions and get the results from the thread choose the right branch. In some processor implementations there are two additional ones Bits added to the lines of the L1 data cache to store an indication, whether data in the line is speculatively loaded or stored speculatively are, so non-speculative results are quickly eliminated become.

Sequential programs are also more efficient by expanding an invalidation-based Cache coherency protocol, the epoch numbers of a memory snoop hit condition with a speculative compare loaded cache line.

The fast context switching in the nanosecond range works in conjunction with the thread switching logic, such as the pulse-based high-speed flip-flop 400 to improve the speed of switching the thread. The pulse-based high-speed flip-flop 400 enables virtual immediate switching between threads, saving the machine status of a blocked thread, and restoring a machine status of an activated thread. The fast context switching in the nanosecond range controls quickly through the pulse-based high-speed flip-flop 400 which thread is activated. The thread switching logic 610 receives a variety of input signals that invoke a context switch and a thread switch. In an exemplary processor, the input contacts include the thread switch logic 610 an L1 load_error connection, an L1_instruction error connection, a Instruction buffer empty port, a thread priority port, an MT mode port, an external interrupt port and an internal interrupt port. The thread switching logic 610 generates a thread identification signal (TID) based on signals from the input ports. The thread switching logic 610 generates the TID signal with a thread switchover delay or an overhang of a processor cycle.

Other processors can do other things Contain signals that generate a thread switch signal (TID). For example can some processors can be configured to thread on toggle an L2 cache miss.

The thread switching logic 610 generates signals to enable the processor to switch the context to another thread in response to an L1 cache load miss, which pulses the L1 load miss port and in response to an L1 cache -Load miss which gives a pulse to the L1_instruction miss port. The thread switching logic 610 also generates signals that allow the processor to switch the context to another thread when an instruction buffer is empty and to generate a signal for the instruction_ buffer_ empty port. The thread switching logic 610 also toggles the context in response to external and internal interrupts, which emit a pulse to the external_interrupt connector and the internal_interrupt connector, respectively.

The thread switching logic 610 allows control of thread selection based on the priority of a particular thread via the signals to the thread_priority connector. The thread switching logic 610 is typically implemented as a control processor, microcontroller, microcode control logic, logic circuit, or the like, all of which are well known in electronics. Accordingly, rapid thread switching can be selected when an L1 cache miss occurs.

In other applications, based on which process or context is most busy, which thread is reserved can be selected. Thread switching logic is implemented in these applications 610 a thread reservation system or a thread locking system in which a thread pathway is reserved for use by a selected thread. The thread selection logic 610 can select a particular thread to run with priority over other threads. A high priority thread can be associated with a strictly timed operation, or with an operation that is frequent and predominant compared to other threads. The thread switching logic 610 controls the thread switching operation so that a special hardware thread is reserved for use by the selected thread.

In one example of a priority operation, a JAVA ^™ server typically contains one master process and a large number of slave processes. The thread switching logic 610 reserves a hardware thread for the master process that determines which slave process is allowed to run at any time. The master process is therefore selected as a reserved thread, which reserves a specific reserved hardware thread and is therefore locked in the reserved hardware thread. The master process executes on the reserved hardware thread, but allocates non-reserved hardware threads among the plurality of slave threads.

In other applications, the thread switching logic 610 Configured to support native threads in an operating system, for example Solaris native threads can be supported in Java applications.

The thread switching logic 610 includes an MT_mode connector that provides multithreading mode signals to select special threads for multiprocessor execution.

The thread switching logic 610 supports fast thread switching with a very small time delay, for example three cycles or less. In multithreading systems and method embodiments, a processor performs fast thread switching in response to an L1 cache miss lock.

In other implementations, thread switching logic implements 610 one or more thread switching methods. A first thread switching operation is "aware" of the thread switching at all N cycles, in which the individual flip-flops locally determine a thread switching without specifying a blocking. This deliberate technique, which is typically implemented using a single counter to count the cycles between switches, avoids the use of an additional global connection, such as a wire or metal, between the threads for thread selection.

A second thread switch operation is a "semi-aware" thread switch for use with a load-use block or "pipeline block" signal. The pipeline block signal has two functions, first as an indication of pipeline block and second as a thread selection signal between the threads, so that again the use of an additional global connection between the threads for thread selection is avoided. A suitable implementation of the semi-conscious thread switching technique uses a connection with a La de- / storage unit global blocking signal (lsu_stall_e) in UltraSPARC-I and UltraSPARC-II processors.

A third thread switching operation is an "intelligent global schedule" thread switch in which a thread switch decision optionally programmed on the basis of one or more signals is. In one example uses an intelligent global schedule Signals such as: (1) an L1 data cache miss lock signal, (2) an L1 load miss signal (3), an instruction buffer empty signal, (4) an instruction queue blank, (5) an L2 cache miss signal, (6) a thread priority signal, (7) a thread timer signal, (8) an interrupt signal or other sources for triggering. In some Embodiments will the thread selection signal is sent out as soon as possible, which is similar to a clock tree distribution. A processor initiates in some systems Thread selection signal, which is applied to the flip-flops, by overloading a scan enable signal (SE) of a scannable flip-flop becomes.

Various implementations of processors include thread switching logic 610 that divides a cache in a processor into a plurality of N cache parts. In terms of 7A shows a schematic block diagram of an example of a cache 700 which is divided into a first cache section 710 and a second split cache section 712 is divided, each section containing a plurality of memory areas. In one example, the first split cache section 710 and the second split cache section 712 each with a capacity of 8 kB a 16 kB direct-mapped 32-byte line cache. Although the explanatory example uses the cache 700 shows that it is divided into two equal sections, other examples can split a cache into any number of sections. The cache sections can be the same or different sizes. In terms of 7B Figure 3 shows a diagram of an example of an addressing technique for the split cache 700 , A 64-bit virtual address memory 720 contains a cache virtual address mark bit field 722 with virtual address bits [63: 13], a thread ID (TID) and index bit field 724 with index bits [12: 5] and a byte offset bit field 726 with virtual address bits [4: 0]. The index bit fields 724 divide the cache into two thread sections, namely the first thread-split cache section 710 and the second thread split cache section 712 on.

The cache division is optional applied in a single cache or a multitude of caches, which include L1 caches, L2 caches, external caches and the like. The cache division avoids interference, "crosstalk" or "Contamination" between threads. A cache splitting technique uses logic to store and communicate thread identification bits (TID). The cache uses cache indexing logic. For example, the TID bits at the bit with the highest Value of the cache index are inserted. Sharing one L2 caches among the threads is implemented simply because of the L2 cache is physically indexed.

Various processor implementations incorporate anti-aliasing logic, which is used in 8th is shown with a cache 810 , such as an L1 cache and L2 cache or others. For example, a processor may include anti-aliasing logic associated with an L1 cache so that the L1 cache is shared by the threads through anti-aliasing. In one explanatory example, the cache is a 16 kB direct-mapped-virtually-indexed physically marked (VIPT) cache 810 which is shared by the threads. The cache 810 is using a 64-bit virtual address memory 820 which is a cache virtual address tag bit field 822 , a cache index 812 and a byte offset bit field 826 contains, addressed. The cache index 812 is configured to have a thread ID (TID) 823 and an index bit field 824 contains.

The anti-aliasing logic stores the data from two different threads, which relate to two differently indexed entries n and n + 256, to the same physical address (PA), which is shown as PA = B. The anti-aliasing logic works while it is being saved to the cache memory 810 by comparing the physical address at the two indexed entries. If the physical addresses match, the duplicated entry is either declared invalid or updated. The anti-aliasing logic avoids problems that result from multivirtual address mapping to a physical address. The anti-aliasing logic either declares the duplicated L1 cache entries invalid or updates them.

Different processor implementations include native thread logic, which is related to thread switching logic 610 and is linked to anti-aliasing logic, which supports lightweight processes and native threads. The logic support native threads and the lightweight processes include logic that highlights the thread ID and overrides the cache partitioning because the lightweight processes and native threads share the common virtual address space. A lightweight process is a simplified minimal context process or thread that is typically designed to perform kernel functions efficiently. The light weight process has very little context, so the execution can be switched on and off easily and effectively. The lightweight process therefore performs its tasks efficiently without thread ID marking and cache splitting. The thread switching logic 610 hosts lightweight processes by overriding thread ID marking and cache splitting, which advantageously avoids assigning cache and other resources to threads that do not use those resources.

In terms of 9 FIG. 5 is a schematic functional block diagram of a design configuration for a single chip, dual processor, vertically threaded processor 900 that is suitable for implementing various multithreading techniques and system implementations that improve multithreading performance and functionality. The single processor vertically threaded processor 300 who in 3 is shown performs vertical multithreading alone. In contrast, the single-chip dual processor vertical threaded processor 900 both horizontal multithreading and vertical multithreading through. The enzelchip dual processor vertical threaded processor 900 has two processors on a single chip, which is a first vertical multithreaded processor 902 and a second vertical multithreaded processor 904 contains.

The first multithreading processor 902 contains a thread 0 machine state block 910 which forms a machine state from a first thread (thread 0) and a thread 1 machine state block 912 which forms a machine state from a second thread (thread 1), which reflects the machine state of thread 0. The thread 0 machine state block 910 and the thread 1 machine state block 912 have the single integrated circuit logic structure using a high-speed, multi-bit flip-flop design and four-dimensional register data structures, and thread 0 and thread 1 supply instructions for a shared processor pipeline 904 which uses vertical threading. The shared processor pipeline 914 is connected to a dual load / store unit, which is a Thread 0 load / store unit 916 and a Thread 1 load / store unit 918 contains the load and store data accesses for instruction threads 0 and 1, respectively.

The shared processor pipeline 914 and the dual load / store unit are connected to a shared data cache and a shared data storage management unit (DMMU). The shared data cache is used to store data for both thread 0 and thread 1 calculations.

The second vertical multithreading processor 904 contains a Thread 2 machine state block 940 having a machine state of a third thread (thread 2) and a thread 3 machine state block 942 forms, which forms a machine state of a fourth thread (thread 3), which simulates the machine state of thread 2. The Thread 2 machine state block 940 and the thread 3 machine state block 942 have individually integrated circuit logic structures that use high-speed multibit flip-flop designs and four-dimensional register data structures, and thread instructions from thread 2 and thread 3 to a shared processor pipeline 944 who uses vertical threading. The shared processor pipeline 944 is connected to a dual load / store unit, which is a Thread 2 load / store unit 946 and a Thread 3 load / store unit 948 contains, which executes load and store data accesses for the command threads 0 and 1 respectively.

The shared processor pipeline 944 and the dual load / store unit are connected to a shared data cache and a shared data storage management unit (DMMU). The shared data cache is used to store data for both thread 2 and thread 3 computation.

A command control block 960 contains an instruction cache (L1), a branch prediction unit NFRAM and an instruction memory management unit (IMMU), all of which are shared by the multiple threads, Thread 2 and Thread 3.

The two dual load / store units are also equipped with an external cache control unit (ECU) 922 connected to an external cache bus 924 connected is. The external cache control unit 922 is also via a memory interface unit (MIU) 928 connected to an ultraport architecture connection (UPA) bus 926. The external cache control unit 922 and the memory interface unit (MIU) 928 are common between the four threads, thread 0, thread 1, thread 2 and thread 3, to perform the cache miss processing and connection to external device functions, in combination, via shared command control blocks 930 and 960 a variety of execution threads run the thread 0 machine state block 910 , the Thread 1 machine state block 912 , the Thread 2 machine state block 940 and the Thread 3 machine state block 942 supply. The unified external cache control unit 922 and the memory interface unit (MIU) 928 include a thread identification (TID) tag around the thread, over the external cache bus, and the UPA bus 926 to be accessed, specified and identified.

The unified external cache control unit 922 and the memory interface unit (MIU) 928 perform cache miss processing and connect to external devices. Processing a miss for a thread (a virtual CPU) takes place when the thread is not active. In addition, multi-processing is simplified if a multi-threaded processor works in the manner of a single processor with an external device. Therefore, in some processors the unified external cache control unit 922 and the memory interface unit (MIU) 928 used as structures along with logical improvements to support the multiple threads, but which do not use the flip-flops to duplicate the ECU and MIU functions for each thread.

The external cache bus 924 Interfaces and the UPA bus 926 Interfaces are shared between the threads using a single port identifier.

The external cache control unit 922 manages the instruction cache (L1) and data cache misses in both the first vertical multithreading processor 902 as well as the second vertical multithreading processor 904 and allows up to one access to the external cache per cycle. The external cache control unit 922 supports DMA access that hit the external cache and maintains data coherency between the external cache and main memory (not shown). The memory interface unit (MIU) 928 controls the transactions to the UPA bus 926 ,

The single-chip dual processor vertical threaded processor 900 also includes on-chip L2 cache tag RAM 938 to support an external two-way L2 cache.

The single-chip dual processor vertical threaded processor 900 reduces the wasted cycle time resulting from stalling and idling and increases the ratio of execution time by supporting and implementing both vertical multithreading and horizontal multithreading. Vertical multithreading allows cache miss hit waiting times to overlap or "hide". In vertical multithreading, the multiple hardware threads share the same processor pipeline. A hardware thread is typically a process, a lightweight process, a native thread, or the like in an operating system that supports multithreading, such as a Solaris UNIX operating system. Horizontal multithreading is accomplished using a variety of pipelines and increasing parallelism within the processor circuit structure. The single-chip dual processor vertical threaded processor 900 has vertical multithreading within a single integrated circuit die that forms a single chip processor. For a further increase in system parallelism, the single-chip dual processor vertical threaded processor uses 900 horizontal multithreading, which uses multiprocessor cores that are formed in a single die. Advances in on-chip multiprocessor horizontal threading are achieved, and processor core sizes are reduced by technological progress.

The exemplary processor 900 and other multi-threaded processors described here use thread-level parallelism and work with multi-independent threads, thereby achieving a multiplicative power factor of a processor with the same resources and the same clock rate, but using traditional non-thread parallelism.

Thread level parallelism is particularly useful for Java ^TM applications that are known to have multi-execution threads. Java ^™ methods that include "pause", "resume", "sleep" and the like provide effective support for the threaded program code. In addition, Java ^TM class libraries are thread safe to promote parallelism. (Java ^TM , Sun, Sun-Microsystems, and the Sun logo are trademarks or registered trademarks of Sun Microsystems, Inc. in the United States and other countries. All SPARC trademarks, including UltraSPARC I and UltraSPARC II, are used and licensed Trademarks of SPARC International, Inc. in the United States and other countries. Products bearing the SPARC brand are based on an architecture developed by Sun Microsystems, Inc.) In addition, the multi thread model supports -threaded processor 900 and other multi-threaded processors described include a dynamic compiler that runs as one thread while a second thread is being used by the current application. In the exemplary system, the compiler optimizes based on the on-the-fly profile information returned while dynamically modifying the execution code to improve execution on each subsequent pass. For example, a garbage collector can run as a first thread that copies objects or gathers pointer information while the application is running as a second thread.

In terms of 10 Figure 3 shows a schematic functional block diagram of an alternative design configuration for a single processor vertically threaded processor 1000 that is suitable for implementing various multithreading techniques and system implementations that improve multithreading performance and functionality. The single processor vertically threaded processor 1000 is two-way, vertically-threaded with a single processor, but with dual thread pipelines in one die. In one illustrative embodiment, the pipeline is based on an UltraSPARC IIi design with a peripheral component connection (PCI) interface and operates up to a processor clock frequency of 600 MHz. The single processor vertically threaded processor 1000 contains a thread 0 machine state block 1010 . which forms a machine state of a first thread (thread 0) and contains a processor pipeline. Thread 0 machine state and pipeline block 1010 is through a thread 1 machine state block 1012 mapped, which forms a machine state of a second thread (thread 1). Thread 0 machine state and pipeline block 1010 and the replica thread 1 machine state block 1012 are formed in a single integrated circuit logic structure using the high speed, multi-bit flip-flop design described above and a "four-dimensional" register file structure. The four-dimensional register file structure is formed in a plurality of layers of memory cells. The memory cell layers have a two-dimensional shape that includes a memory for storing data bytes or words that contain a plurality of bits. Vertical threading introduces a fourth dimension because the three-dimensional register file is defined for a variety of machine states that are duplicated by the registers. The multiple dimension register file multiplicatively increases the register file storage capacity without changing the integrated circuit size, since the size depends on the number and density of components on the surface of a semiconductor die. A suitable multidimensional register file is disclosed in detail in U.S. Patent 5,721,868.

The multiple dimension register file structure is very beneficial to increase processor performance without increasing size and downsizing the processor size while the Processor performance is kept the same or increased. Another advantage The multiple dimension register file is a single-threaded one Processor can be converted into a multi-threaded processor can while same circuit base area size, wiring configuration, the packaging and the like is maintained. Accordingly, a multi-threaded processor advantageously produced while the characteristics of a single-threaded processor model be exploited.

Thread 0 machine state and pipeline block 1010 and the imaging thread 1 machine state block 1012 execute thread 0 and thread 1 commands using vertical threading. Thread 0 machine state and pipeline block 1010 and the replica thread 1 machine state block 1012 are equipped with an external cache control unit (ECU) 1022 connected, which with an external L2-cache-static working memory (SRAM) 1024 connected is.

The external cache control unit 1022 is also via a PCI controller 1030 with a peripheral component connection bus (PCI) 1032 connected. The external cache control unit 1022 is also via a memory control unit (MCU) 1028 with a dynamic working memory (DRAM) 1034 and an Ultraport Architecture Connection Bus (UPA) 1026 connected. The external cache control unit 1022 and the memory control unit (MCU) 1028 are executed consistently between thread 0 and thread 1 to perform the cache miss processing and connection to external device functions, in combination with a plurality of thread 0 machine state block execution threads 1010 and the Thread 1 machine state block 1012 supply. The unified external cache control unit 1022 and the memory control unit (MCU) 1028 contain a thread identification tag (TID) to specify and identify the thread on which the SRAM L2 cache 1024 , the PCI bus 1032 , the DRAM 1034 and the UPA bus 1026 is accessed. The PCI controller 1030 and the MCU 1028 are shared by threads that use a single-port identifier. The thread ID marking is implemented in processor components that do not block, for example a carry (logN) bit TID in the L1 and L2 cache (both data and instruction caches), address conversion buffers (TLBs), asynchronous interfaces from Load buffers, an external memory management unit (MMU) interface and the like. In non-stalling components, only one thing runs through the component at the same time, so there is no blocked state that would be saved. The thread ID bits indicate which thread is active in the component.

The external cache control unit 1022 manages the instruction (L1) cache and data cache misses and allows up to one access to the external cache per cycle. Load operations that land a miss in the data cache are healed by multibyte data cache entries on two consecutive accesses to the external cache. Memory operations are fully pipelined and write directly to the external cache. Pre-read instructions that land an instruction cache miss are cured by multi-byte instruction cache inputs that use four consecutive accesses to the parity-protected external cache.

The external cache control unit 1022 supports DMA accesses that land a hit in the external cache and maintains data coherence between the external cache and main memory (not shown).

The memory control unit (MCU) 1028 controls the transactions to the UPA bus 1026 and to the DRAM 1034 , The UPA bus 1026 runs at a fraction (e.g. 1/3) of the processor clock.

An exemplary single processor vertically threaded processor 1000 is built on a die that is smaller than 100 mm ² and has a power loss of less than 10 W at a clock rate of 200 MHz. The exemplary single processor vertically threaded processor 1000 has an estimated efficiency in a calculation 30% efficiency with a single-thread processor with similar performance specifications per thread.

In terms of 11 Figure 12 is a schematic functional block diagram of an alternative design configuration for a single chip, dual processor, vertically threaded processor 1100 that is suitable for implementing various multithreading techniques and system implementations that improve multithreading performance and functionality. The single chip dual processor vertical threaded processor 1100 contains two processor cores on a single die, with each processor core being two-way vertically threaded, resulting in the efficient manufacture of four processors on one die. The two processor cores share an on-chip four-way set associative L2 cache and share an external cache control unit that controls access to the L2 cache. Sharing the on-chip L2 cache advantageously results in cache coherency between the plurality of processors on a single die. In the exemplary single chip, dual processor, vertically threaded processor 1100 each of the two processor cores contains separate peripheral component interfaces (PCI), DRAM and UltraPort Architecture Connection (UPA) interfaces.

The single chip vertically threaded processor 1000 who in 10 vertical multithreading alone is shown. In contrast, the single-chip, dual-processor, vertical-threaded processor 1100 both horizontal multithreading and vertical multithreading through. The single chip dual processor vertical threaded processor 1100 has two processors on one chip, which is a first vertical multithreading processor 1102 and a second vertical multithreading processor 1104 contains, both of which are two-way vertically threaded with a single processor, but which have dual thread pipelines in one die. In an exemplary embodiment, the pipelines are based on an UltraSPARC II design with a peripheral component connection (PCI) interface and operate up to a processor clock frequency of 600 MHz.

The first vertical multithreading processor 1102 contains a thread 0 machine state block 1110 that defines a machine state of a first thread (thread 0) and contains a processor pipeline. Thread 0 machine state and pipeline block 1110 is through a thread 1 machine state block 1112 mapped, which forms a machine state of a second thread (thread 1). Thread 0 machine state and pipeline block 1110 and the mapping thread 1 machine state block 1112 are fabricated in a single integrated logic circuit structure that occupies approximately half of a semiconductor die and uses the high speed, multi-bit flip-flop design described above and a "four-dimensional" register file structure. In some processors, the register file can be arranged on a single vertical multithreading processor. In other processors, the register file can be shared between a variety of vertical multithreading processors.

Thread 0 machine state and pipeline block 1110 and the imaging thread 1 machine state block 1112 execute thread 0 and thread 1 commands using vertical threading. Thread 0 machine state and pipeline block 1110 and the imaging thread 1 machine state block 1112 are equipped with an external cache control unit (ECU) 1122 connected through an external cache control unit (ECU) referee 1125 to an on-chip L2 cache SRAM 1124 connected is. The L2 cache SRAM 1124 and the ECU arbitrator 1125 are shared by the first vertical multithreading processor 1102 and the second vertical multithreading processor 1104 shared. In an exemplary processor 1100 is the L2 cache SRAM 1124 a 1 megabyte four-way L2 cache.

The external cache control unit 1122 is also via a PCI controller 1130 with a peripheral component connection bus (PCI) 1132 connected. The external cache control unit 1122 is also with a DRAM 1134 and an UltraPort Architecture Connection (UPA) bus via a memory control unit (MCU) 1128 connected. The external cache control unit 1122 and the memory control unit (MCU) 1128 are common between Thread 0 and Thread 1 to perform cache miss processing and connect to external device functions, in combination with a variety of thread execution thread thread 0 machine state block 1110 and thread 1 machine state block 1112 supply. The unified external cache control unit 1122 and the memory control unit (MCU) 1128 contain a thread identification (TID) tag to specify and identify the thread on which via the L2 cache SRAM 1124 , the PCI bus 1132 , the DRAM 1134 and the UPA bus 1126 is accessed. The PCI controller 1130 and the MCU 1128 are shared between thread 0 and thread 1 using a single port identifier.

The external cache control unit 1122 manages memory (L1) cache and data cache misses and allows up to one access per cycle to the external cache. Load operations that generate a miss in the data cache are cured by multiple byte data cache entries on two consecutive accesses to the external cache. Memory operations are fully pipelined and write directly to the external cache. Reading commands, which a miss on the instruction cache is healed by multiple byte instruction cache entries that use four consecutive accesses to the parity-protected external cache.

The external cache control unit 1122 supports the DMA accesses that land a hit in the external cache and maintains data coherence between the external cache and main memory (not shown).

The memory control unit (MCU) 1128 controls the transactions to the UPA bus 1126 and to the DRAM 1134 , The UPA bus 1126 runs at a fraction (e.g. 1/3) of the processor clock.

The second vertical multithreading processor 1104 contains a Thread 2 machine state block 1140 which forms a machine state of a third thread (thread 2) and contains a processor pipeline. The Thread 2 machine state and pipeline block 1140 is through a thread 3 machine state block 1142 mapped, which defines a machine state of a fourth thread (thread 3). Thread 2 machine state and pipeline block 1140 and the picture thread 3 machine state block 1142 are fabricated in a single integrated logic circuit structure that covers approximately half a semiconductor die and that uses the high speed, multi-bit flip-flop design described above and a "four-dimensional" register file structure. The Thread 2 machine state and pipeline block 1140 and the figure sthread 3 machine state block 1142 execute thread 2 and thread 3 commands using vertical threading. Thread 2 machine state and pipeline block 1140 and the mapping thread 3 machine state block 1142 are equipped with an external cache control unit (ECU) 1152 connected through the external cache control unit (ECU) referee 1125 with the on-chip L2 cache SRAM 1124 connected is. The L2 cache SRAM 1124 and the ECU arbitrator 1125 are shared by the first vertical multithreading processor 1102 and the second vertical multithreading processor 1104 used.

The external cache control unit 1152 is also via a PCI controller 1160 with the peripheral component connection (PCI) bus 1132 connected. The external cache control unit 1152 is also via a memory control unit MCU 1158 with a DRAM 1164 and the Ultraport Architecture Connection (UPA) bus 1126. The external cache control unit 1152 and the memory control unit (MCU) 1158 are consistent between Thread 2 and Thread 3 to perform cache miss processing and connect to external device functions, in combination with a variety of thread execution threads for the Machine 2 machine state block 1140 and thread 3 machine state block 1142 supply. The unified external cache control unit 1152 and the memory control unit (MCU) 1158 contain thread identifier tags (TID) to specify and identify the thread on which to pass through the L2 cache SRAM 1124 , the PCI bus 1132 , the DRAM 1134 and the UPA bus 1126 is accessed. The TDI is supported by the logic for use with processor blocks that are not blocked. Corresponding non-blocked blocks include cache address translation buffers (TLB), a load buffer asynchronous interface, a memory buffer asynchronous interface, an external memory management unit (MMU) interface and other components. The PCI controller 1160 and the MCU 1158 are shared between Thread 2 and Thread 3, which use a single port identifier.

The load buffer and memory buffer interfaces are shared structures that are implemented to support the compatibility with multiple threads. When switching a thread changed a new thread does not reflect the state of a shared structure in a way that is incompatible with the replaced one Thread. Hold the load buffer and memory buffer interface thread compatibility physical duplication of structures and by controlling the so-called read-after-write status of the memories. In particular, loading activities towards one Controlled memory buffer in an alternate thread so that the read-write status information is stored and expanded will post results of read-write controls against everyone Save memory buffers.

The memory buffer data cache hit bits become not reset. Therefore, as a result of thread switching, loading into thread 2 replace a line that is the target of a previously incomplete save in thread 1. Because the memory buffer data cache hit bits are not reset a different thread switch can cause thread 1 stores on another line. The read-after-write control in the other memory buffer prevents further loading in the other Memory buffer and prevents the replacement of a line that a Target an incomplete Storage is.

If in addition a saving in thread 1 writes to the data cache but not to the external cache, without read-after-write control in the other memory buffer, then a load operation in thread 2 can update the received values before the other processors in the system received, which leads to a TSO violation. Therefore, the full description should a write to the data cache for a store operation Lock read-after-write threads.

The external cache control unit 1152 manages the instruction (L1) cache and data cache misses and allows up to one access per cycle to the external cache. The external cache control unit 1152 supports DMA accesses that land a hit in the external cache and maintains data coherence between the external cache and main memory (not shown).

The memory control unit (MCU) 1158 controls the transactions to the UPA bus 1126 and to the DRAM 1134 ,

An exemplary single chip, dual processor, vertically threaded processor 1100 works at a clock frequency of up to 600 MHz, is built on a die that is smaller than 250 mm ² and has a power loss of less than 10 W at a clock rate of 200 MHz. The exemplary single-chip dual processor vertical threaded processor 1100 has an estimated computing efficiency of 130% for a single-thread processor with similar performance specifications per thread.

Countless other structures and combinations can implemented on one or more integrated circuits the manufacturing process used and the intended Applications for detach the processor. The other processor configurations can vary in numbers of on-chip or off-chip processor cores, varying numbers of vertical threads per pipeline and different ones Configurations of interfaces, memory and input / output control units, Storage devices and the like can be configured. For example contains in a "1C2T" configuration, a single processor the two vertical Threads. In another example, it contains an advantageous configuration four processor cores, each with vertical multi-threaded cores, to make a square die. In a "4C4T" configuration, a Four-processor multiprocessor made on a single die, each of the four processors being four-way vertically-threaded. An operating system controls the operation of the 4C4T configuration processor as a 16-way sequential multiprocessor.

Some processors can either an on-chip or external resettable dynamic RAM (RDRAM) instead of an external cache. Different processors can contain an on-chip L2 cache. Different systems can contain caches which are optionally configured, for example as split L1 caches and split L2 cache or split L1 cache and shared used L2 cache or shared L1 cache and shared L2 caches.

In terms of 12 represents a schematic block diagram of a processor 1200 and processor architecture suitable for implementing various multithreading techniques and system implementations that improve multithreading performance and functionality. An instruction cache 1212 delivers commands to a decoding unit 1214 , The instruction cache 1214 receives commands from a pre-reader 1216 which have a cache control / system interface 1222 with instructions from either a branch unit 1218 or an external cache (not shown) is supplied. In some processors, the cache control / system interface contains 1222 an external cache control unit (ECU) and a memory interface unit (MUI). Instructions from the external cache are issued when the prefetch unit 1216 a virtual address to a command address translation buffer (TLB) 1220 emits. Instructions from the external cache are sent to a predecoder 1224 issued and contain various control information for the instruction cache 1212 , The various control information includes signals such as a label that an instruction is a branch instruction.

Instructions from the decoding unit 1214 are sent to an instruction buffer 1226 dispensed and are dispatched by a dispatch unit 1228 processed. In some processors, instructions are buffered by multiple instruction buffers 1226 , which are connected to each other in parallel. In the exemplary processor 1200 returns the dispatch unit 1228 four decoded instructions simultaneously on one bus 1230 from. The instructions are given to one of eight functional units. The dispatch unit 1228 checks for data dependencies, tax dependencies and structural problems, such as the availability of functional units and memory connections. The dispatch unit 1228 then processes up to four instructions per cycle based on the control operation.

Functional units of the integer type, which are a loading / storage unit 1232 , a first integer computing unit (ALU) 1234 and a second integer ALU unit 1236 included, share a set of integer registers 1248 , Functional units of the floating point type, which are a first floating point unit 1238 , a second floating point unit 1240 , a third floating point unit 1242 , a first graphic unit 1244 and a second graphic unit 1246 contain, use the floating point registers together 1250 , The integer-type functional units share an integer completion unit 1252 and the floating point type functional units share a floating point completion unit) 1254 , The processor 1200 also contains an on-chip data cache 1256 and a data address translation buffer (TLB) 1258 ,

In terms of 13 shows a schematic perspective diagram of a multidimensional register file 1300 which is advantageous for use in a multi-threaded processor. Both integer and floating point register files are typically not implemented with flip-flops, so the multi-bit flip-flop is not helpful in the typical register file to increase memory capacity. However, the capacity of the register files can be expanded differently by using other techniques and structures, such as the multidimensional register file structure 1300 is used.

A register file is a data path component, which are very determining for the performance is in a superscalar processor. The access time on the register file is a factor that affects the processor cycle time affected. The register file consumes a relatively large amount of the superscalar processor because of the large number of connections useful in such processors. Typically, ten or more ports are for one three-scalar microprocessor used and the size of the register file increases with the square of the number of connections.

The multidimensional register file 1300 advantageously uses the area inherently consumed by the metal wires used for the bit lines and word lines for each memory cell to store N sets of registers. The individual sentences of the N sentences are logically one level in the third dimension. The configuration of the multiple levels is used to form a multiplicity of register windows and to form additional register settings for real-time tasks, switching of micro-tasks or storage of multiple execution threads. In some memories, a data array of a three-dimensional, eight-window, ten-port register file is six times smaller than a flat register file. Access time is improved by shortening bus lines and sharing a large buffer between the bit cells. The multidimensional register file 1300 is advantageously implemented in high-performance super scalar processors.

The large number of registers and the elevated functionality a register file containing a plurality of register windows conventionally in a microprocessor at the expense of strong growth circuit size, cost and Implementation difficulties implemented. For example would one conventional Register file with a window of 32 registers with eight overlapping Registers between the windows contain a total of 128 registers, without global registers, and would be much larger than conventional Register files without a window. The through the windows plus the larger number added by registers functionality makes the implementation of a register file with windows one Challenge because RISC processors due to strong pipelining on basic data path blocks, such as register files, ALUs and caches, at base cycle time tend. A conventional register file with windows in a conventional Implemented way has exactly one active window for all Read operations and an active window for all write operations.

The multidimensional register file 1300 takes advantage of the fact that not all windows have to be accessed at the same time in order to save a switching effort between the windows. The individual levels 1310 in the multidimensional register file 1300 represent a separate window. In the sense of simplicity is the multidimensional register file 1300 shown with four non-overlapping windows. The concept of the multidimensional register file 1300 relies on support by switching context so that the individual faces 1310 represent a separate context. Switching context between microtasks is done by simply changing the context, as in 13 is shown by changing the window pointer 1312 , done quickly.

The current context number or the window pointer 1312 is through a separate decoder 1314 decoded and a corresponding level 1310 will be chosen. The register index for the selected window is decoded in the manner of a conventional register file. When you select a register, the contents of the register are placed on a data bus that is shared by all windows or contexts. In the sense of simplicity 13 only a reading section of the logic for the multidimensional register file 1300 The write logic (not shown) contains a separate decoder (not shown) for a write window pointer that is at a different level 1310 selects. Separate data lines are inherently included for individual phase pipelines, so there is no need to include an additional line for the separate write window connector. Note that an additional window decoding line can be added to achieve higher performance.

Conventional implementation of register windows in a register file leads to a large flat configuration. For a multi-port superscalar processor, the conventional implementation results in a single bit of information that is wastefully stored between some metal wires. 14 Fig. 3 is a schematic circuit diagram showing a bit cell 1410 a conventional implementation of a register window of a register file with ten ports including seven read ports and three write ports. Ten separate word lines 1412 , seven single-ended sense amplifier lines (not shown) for the read lines and three single-ended write bit lines 1416 are included, resulting in a 10X10 grid 1418 leads. For a four-layer metal process, the word lines are typically on the second layer and the bit lines on the third layer. The operating voltage and ground potentials are carried on the fourth layer and the first layer is used for local connections in the bit cells. For a 0.5 micron process with a metal pitch of 1.5 micron, this results in a 10X10 grid 1418 in an area of 225 square microns. Between the 10X10 grid 1418 a single bit of information is stored, which is a poor use of the available space for logic devices. For double-sampled sense amplifiers and for differential writing, the wasted areas are even larger. Typically, a 10X20 grid is required, resulting in an effective area of 450 microns to store a single bit of information.

The data array of a windowed 128 64-bit register file implemented in the exemplary conventional manner measures approximately 128 * 64 * 225 = 1.84 square millimeters for the single-ended scheme and 128 * 64 * 450 = 3.68 square millimeters for the double-ended configuration. For a 64-bit superscalar processor with a relatively large register file, for example 32 Registers, the data array represents approximately 2/3 of the total area of the register file.

In terms of 15 Figure 4 shows a schematic circuit diagram of a plurality of bit cells 1510 a register window of the multidimensional register file 1300 which avoids wasted integrated circuit area by taking advantage of the condition that only one window is read and only one window is written at a time. The otherwise wasted area is used to store information bits from a plurality of windows at a corresponding plurality of depths at a lateral position in the integrated circuit area. For example, bit i of register j is stored for a plurality of windows {0, 1, 2, ..., 7} at a position in a 10X10 grid 1518 at a plurality of depths. The plurality of bits at a plurality of depths are addressed by specifying a bit i, a register j and a window k. Thus, an eight window register file is addressed using three additional lines to specify a selected window among eight windows. Hence the 10X10 grid 1518 addressed by adding three address lines in addition to the address lines to address a 10X10 single window register file. The 10X10 grid is corresponding 1518 addressed by 13X10 address lines. In the exemplary multidimensional register file 1300 Eight bits of information are stored instead of one bit of information in an area that is only 30% larger than the area for a single window 10X10 grid 1418.

For an example of storing a single-ended register file, each bit uses approximately 36 square microns ( 6 . 15 times smaller) compared to the 225 square microns in a traditional implementation of a single window. The benefits are even greater for a double-ended implementation in which one bit uses approximately 73 square microns compared to the 450 square microns of a conventional double-window memory. The double-ended storage achieves the same storage rates, 6.15 times smaller, but this even leads to a greater gain in total space saved.

The 10X10 grid 1518 is shown for explanatory purposes only. A grid can have any suitable dimension (e.g. 10X20 or others) depending on a desired application, function and capacity.

In terms of 16 represents a schematic circuit diagram of a suitable bit storage circuit 1600 which is a bit of the local register for the multidimensional register file 1300 with eight non-overlapping windows. The multidimensional register file 1300 is useful for quickly switching context or implementing local registers that are not shared across windows.

The exemplary bit storage circuit 1600 represents a memory cell 1610 with seven read ports 1612 , single-ended read bit lines 1614 , three write ports 1616 , different write bit lines 1618 , separate reading 1619 and writing windows 1620 and a decoded (an active) current window pointer 1622 , The memory cell 1610 does not allow simultaneous multiple write operations to the same register. The single-ended read bit lines 1614 use significantly less area than a differential sense amplifier implementation (seven lines versus fourteen lines). Scanning single-ended read bit lines improves the read sampling speed without affecting the noise range by biasing the read bit line beyond the maximum voltage of the sense amplifier. For example, in a typical 3.3 V CMOS process, assuming TTLH, the read bit line is biased to 1.31 V, which is 0.61 V above the maximum 0.70 V sense amplifier. After the read bit line is biased, the selection of one of the memory cells on the read bit line can either result in a continuation of the biased state that the sense amplifier reads in as a logic "1", or lead to a bit line discharge below the maximum sense amplifier voltage value. which results in this state being read as a logic "0".

The differential write bit lines 1618 allow fast write and reliable noise limits. Using a separate one Window pointers for reading and writing lead to higher performance by allowing more than one window to coexist in a pipeline. Prohibiting multiple write accesses to the same physical register in the same cycle simplifies the design without affecting performance because such write accesses are an indication of an inefficient condition and are inherently unsuitable for a proper processor. Two consecutive write accesses in the same cycle without an intermediate read access are not common programming practice.

The decoding of write addresses takes place in two stages. Predecoders (not shown) are simple static gates. AND gate with four entrances to lead the second stage decoding. One of the four input signals is a write enable signal. Write decoders are locked when the corresponding write enable signal is blocked.

The decoded current window pointer 1622 simplifies the logic for each bit cell and creates a speed advantage since the pointer can be decoded in parallel with a register index.

The selection lines 1624 (rps0, rps1, ... rps7) for the memory cell 1610 select a register N and cover the full width of the 64-bit register. The decoding of the read addresses is carried out in two stages using precoders (not shown), which are simple static gates, while final stage decoders (not shown) are three-input domino type NAND gates. In order to significantly increase the address decoding rate, the read address signals are biased differently in order to enable an evaluation to begin immediately when the input address signals become valid.

The decoded current window pointer 1622 is represented by eight signals (rcwp0, rcwp1, ... recwp7), of which only one is active at the same time. The currently decoded window pointer 1622 selects the window within register N that is accessed. Cross-connected inverters 1626 are used to store each bit cell. A local inverter 1628 amplifies the signals locally and isolates each cell, avoiding charge sharing. The reading of data from the individual bit cells is buffered by an inverter INV2, which contains a large pull-down transistor (50 microns versus 8 microns for a corresponding pull-up transistor). The seven bit lines 1624 are precharged so that the read access time is determined by the read bit line pulldown speed. The inverter Inv1 and a PMOS transistor TPFB pull a node cc of a local intermediate data bus to VDD.

Three write select lines 1630 are wps0, wps1 and wps2. Different write types are implemented, so that three pairs of different write bit lines 1632 can be used (wdc0, wdt0, wdc1, wdt1, wdc2 and wdc2). The separate decoded current window pointer 1622 is used for the write operations so that only one of the eight signals (wcwp0, wcwp1, ..., wcwp7) is active at the same time.

In terms of 17A Figure 3 shows a schematic diagram of the sharing of registers between the adjacent windows. Overlapping windows enable a call function to send parameters to a transmitter without additional loading and storing operations. A call function has a current call window 1710 , the "Output" tab 1712 used to set parameters to an adjacent current receiver window 1720 forward where the "INS" register 1722 Register for the recipient. Similarly, when returning from a function call, the receiver can see the results through the "INS" registers 1722 return what the "output" registers for the original recipient will be.

The discussion of 16 described how bit cells from adjacent windows remain common between the metal wires used to access a single cell and to provide a window decoding signal. Using the same concept for the "INS" and "output" registers, all bits for In _n of window _w all persist at one point in the circuit area. In terms of 17B Figure 3 shows a schematic block diagram of a four window register file containing a set of four bits, which data for the bit; of window IN _n register _{w + 1} , which is the same as a bit; from register output _n from window _w . For a special window pointer, for example window ₀ , two bit cells, which represent the IN and OUT registers, are accessible.

In terms of 18 Figure 4 shows a schematic circuit diagram of an implementation of a multidimensional register file 1300 that contains registers that are shared by a plurality of windows. An exemplary storage 1800 contains bit cells 1810 which contain data for the IN _i and OUT _i registers of window _j , wherein two bit cells can be accessed simultaneously by always selecting two possible addressed cells in the set of eight cells for each window selection. For example, the selection of the current window pointer rcwp1 selects two cells, cc0 as a possible IN register and ccl as a possible OUT register. The content of the two cells cc0 and ccl is output on separate local buses ccIN and ccOUT. The selection of the data for each read-in connection of the IN register or the OUT register is carried out by a decoder (not shown). Separate lines feed the IN registers and the OUT registers to select the correct register. A single large buffer with a wide one Pulldown transistor is included in each bus to discharge the bit lines depending on the condition.

A write circuit contains special logic to avoid erroneous overwriting between the IN registers and the OUT registers. The logic 1820 which supplies the current write window is similar to the logic 1822 , which supplies the current reading window. One and only one current window pointer (wcwp0, wcwp1, ..., wcwp7) is used and selects two cells, an IN bit cell and an OUT bit cell. Signals applied to the write decoder value determine whether either the data is output from the IN bit cell or the OUT bit cell. Separate signals select a write operation for an IN cell (e.g. wps0 in) and a write operation for an OUT cell (e.g. wps1_out). Since a write operation is damaging to data, a write operation to an IN register is prevented so as not to corrupt the corresponding OUT register and vice versa, which could occur even if the write data is output on one of the two local write data buses. Write data from one port is sent to either the IN-local bus or the OUT-local bus, but not both. The relatively large capacity of the local buses could possibly overwrite the content of one of the bit cells because the write window pointer allows direct access. To avoid the potential write disturbance, pull-up transistors TPPU1, TPPU2, TPPU3 and TPPU4 are used to bias the local write data lines from inactive ports, which act effectively as a bit cell read disturbance with little effect on the voltage values. A state of two write ports that try to write to the same IN register or the same OUT register is prevented because multi-write operations to the same target register are not permitted.

The multidimensional register file 1300 has many beneficial characteristics. For example, an ability to pass parameters of function calls and function call returns without the need to store and restore data through the stack, which significantly increases performance since load and store operations are often a bottleneck in modern high performance processors.

The context switching performance of the processor 1200 is improved by context-switchable memory structures, such as a register file with "windows". The windows support different "contexts" for function calls. In one example, the register file with windows is configured as a multidimensional structure with "layers" for a quick switching of the context.

In conventional processors, the data array section consumes approximately 2/3 of the total area of a register file. The use of the multidimensional register file 1300 advantageously reduces the data array size by a factor of 4 for a register file with eight levels. The total area saved depends on various design features, including: (1) differential versus single-ended bit read scanning, (2) decoded versus coded level / window routing, and (3) differential versus single-ended write. Compared to conventional "single window" register files, multiple contexts are achieved essentially at no cost in terms of the integrated circuit area that is a multidimensional register file 1300 used in circuits, where read port and write port connections dominate the cell area of the registers.

In addition to the considerable saving of circuit area, the multidimensional register file leads 1300 with advantage to faster access times, which are mainly achieved by reducing the total capacity on the bit lines. In a conventional "single window" implementation, only one bit line connects a window compared to all of the windows in the multidimensional register file 1300 , The multidimensional register file 1300 leads to a reduced total area and shorter bit lines, which reduces the capacitance. A bit line driver can be enlarged due to the logic shared by the bit cells, which increases the bit line discharge. In addition, independent decoding between the window pointer and the register index leads to faster operation.

The multidimensional register file 1300 is advantageously used as a register file for processors including high performance superscalar processors, but the techniques and structures used can otherwise be used in other types of memory devices. For example, multidimensional memory structures can otherwise be implemented in different VLIW memory structures, which typically use many ports, and in processors that quickly switch context that support different contexts through a single structure.

The processor structure described and the operating procedure can implemented in many structural variations. For example are two processor cores with an on-chip set associative L2 cache combined in one system. In another example, four Processor cores with a direct RAMBUS interface without an external one L2 cache combined. A number of variations are possible. In In some systems, each processor core is a vertically threaded one Pipeline.

While the invention has been described with reference to various embodiments, it is to be understood that these embodiments are illustrative only and that the scope of the invention is not limited by them. Many variations, modifications, additions conditions and improvements of the described exemplary embodiments are possible. For example, those skilled in the art will easily be able to implement the steps necessary to provide the structures and methods disclosed herein, and will understand that the process parameters, materials and dimensions have been given by way of example only and can be changed to the desired structures as to achieve modifications which are within the scope of the invention. Variations and modifications to the embodiments disclosed herein may be based on the continued description and knowledge and experience of those skilled in the art without departing from the scope of the invention as set forth in the following claims. For example, although the example processors include a predetermined number of threads per pipeline and a predetermined number of pipelines per integrated circuit chip, depending on the desired processor applications, semiconductor fabrication techniques, and different processor size parameters, in other examples a different number of threads and pipelines be implemented.

The descriptions contained here relate to many aspects of processor structure and processing techniques, these structural and functional aspects of different Processor components included. The structures and techniques are described as very useful are in combination. However, there are also different structures and techniques innovative and very beneficial when alone or can be used in many different sub-combinations. The Invention is through the claims alone delimited and various limitations, which in the description are described, but not included in a special claim are not supposed to be inherent Part of the claim by mere inclusion in the description to be viewed as.

Claims (17)

A method of operating a processor comprising: selecting a thread from a plurality of execution threads ( 122 . 124 . 126 . 128 ), where other threads are unselected threads; Activate a machine status ( 310 . 312 ) for the selected execution thread in a shared pipeline ( 314 ); and freezing the unselected threads in the shared pipeline without executing the same, characterized in that the shared pipeline comprises a plurality of pulse-based, high-speed, multi-bit flip-flops ( 400 ) that generate a plurality of thread paths in substantially the same surface area of the integrated circuit as a conventional one-bit flip-flop to select from among the plurality of execution threads. The method of claim 1, further comprising: Assign a load / store unit (316, 318) to individual threads of the Variety of execution threads; and Access the assigned Load / storage units according to the execution thread. The method of either claim 1 or claim 2 further comprising: sharing a data storage unit ( 320 ) among the multitude of execution threads. The method according to one of claims 1 to 3, further comprising: sharing an instruction control logic ( 330 ) among the multitude of execution threads. Method according to one of claims 1 to 4, further comprising: sharing an external cache control unit ( 322 ) among the multitude of execution threads. Process for operating a processor according to a of claims 1 to 5 further comprising: running one at the same time or multiple program applications; Execution of a variety of execution threads in a multithread pipeline that has a variety of multibit flip-flops includes a variety of execution threads, the Execution threads to execute instructions issued for which serves program applications; Switch execution threads comprehensive in the multithread pipeline: Freeze an active State in the pipeline; Activate a previously free running Threads in the pipeline while the state of the newly frozen thread in the pipeline is obtained; and then resume execution of the frozen threads at the precise State of the frozen thread immediately before thread switching. 6. A method of operating a processor according to any one of claims 1 to 5, further comprising: simultaneously running one or more program applications; Executing a plurality of execution threads in a multithreaded pipeline that includes a plurality of multibit flip-flops that hold a plurality of execution threads, the execution threads being used to execute issued instructions for the program applications, the execution operation includes: simultaneously holding a plurality of threads in the multithread pipeline, including an active thread and one or more inactive threads; Receiving a notification of a stall condition; in response to receiving the stall state, immediately stalling the active thread including immediately deactivating a currently active thread and activating a currently inactive thread while the state of the threads in the multithreaded pipeline remains the same. Process for operating a processor accordingly one of the claims 1 to 5 further comprising: Running a non-threaded program application; Execution of the non-threaded program in a multithreaded pipeline that has a variety includes multi-bit flip-flops that are capable of a variety execution threads to keep; Toggle context in a quick context toggle operation full: To run a first context in a first thread path in the multithreaded pipeline; Receive an exception status signal; In response to the feeling of Exception status signal, immediate blocking of the first context including immediate deactivation of the first context and activation of one Exception handling context while the state of the contexts in the multithreaded pipeline is the same remains. The method of claim 8, wherein the exception handling context is activated without operating system penalty. The method of claim 8, wherein: the exception handling context is activated in hardware without an operating system speed penalty software storage / restore operations becomes. A method according to any one of claims 1 to 10, wherein: the multithread pipeline comprises a plurality of pulse-based high-speed flip-flops ( 400 ), the pulse-based high-speed flip-flops having a latch structure which are coupled to a multiplicity of selection bus lines, the selection bus lines selecting an active thread from the multiplicity of execution threads. A method according to any one of claims 1 to 11, wherein performing a Execution threads in the multithread pipeline includes: Store data in the pulse-based high-speed flip-flops; and Pick one active threads from the variety of execution threads using the selection bus lines. The method of any one of claims 1 to 12 further comprising: detect a cache miss; Generate a cache miss lock signal in response to a cache miss lock; and Freeze an active state in the pipeline in response cache miss lock signal. The method of any one of claims 1 to 13 further comprising: the Sequence of issuing instructions for the program applications. The method of any one of claims 1 to 14 further comprising: the Issuing instructions for program applications; and separate and independent Manage a machine state of the individual execution threads. 16. The method of any one of claims 1 to 15 further comprising: load data from a memory and storing data into a memory via a Variety of loading / storage units, individually in individual Threads are associated in the multithreaded pipeline. The method of any one of claims 1 to 16 further comprising: simultaneously To run a variety of execution threads in a variety of multithreaded pipelines, so the processor the one or more program applications with a vertical thread process and a horizontal thread process performs.