text:
Review for Firestone
Tyree D. on 07/22/2014
Tyree said the service was pretty good. Sherman provided awesome customer service and was willing to work with him on the price.
Vehicle: GMC Vandura
Category: Service
Service Date: 06/29/2014
Review Created: 07/22/2014
This review was collected via phone interview by Customer Research Inc.


text:
It only takes a minute to get started. Fill out our uncomplicated sign up form and login to the website.
This step is elective but will seriously enhance your chances of getting interest from other over 40s members on the site. Write a little something about yourself, your pasttimes and upload any nice photos of yourself.
Utilise our website's advanced search to find over 40s members who fulfill your criteria. Or just leaf through listings and find folks that seem interesting.
Identified someone who looks interesting? Send them a word or two or just a wink and see if anything develops. With a little luck you'll be on your way to finding your ideal partner.
It'll only take a few minutes

subset: commoncrawl


text:
An Out-of-Order RiSC-16 Tomasulo + Reorder Buffer = Interruptible Out-of-Order
- Brian Floyd
- 2 years ago
- Views:
1 An Out-of-Order RiSC-16 Tomasulo + Reorder Buffer = Interruptible Out-of-Order ENEE 446: Digital Computer Design, Fall 2000 Prof. Bruce Jacob, This paper describes an out-of-order implementation of the 16-bit Ridiculously Simple Computer (RiSC-16), a teaching ISA that is based on the Little Computer (LC-896) developed by Peter Chen at the University of Michigan. 1. RiSC-16 Instruction Set The RiSC-16 is an 8-register, 16-bit computer. All addresses are shortword-addresses (i.e. address 0 corresponds to the first two bytes of main memory, address 1 corresponds to the second two bytes of main memory, etc.). Like the MIPS instruction-set architecture, by hardware convention, register 0 will always contain the value 0. The machine enforces this: reads to register 0 always return 0, irrespective of what has been written there. The RiSC-16 is very simple, but it is general enough to solve complex problems. There are three machine-code instruction formats and a total of 8 instructions. The instruction-set is given in the following table. Assembly-Code Format Meaning add rega, regb, regc R[regA] <- R[regB] + R[regC] addi rega, regb, immed R[regA] <- R[regB] + immed nand rega, regb, regc R[regA] <- ~(R[regB] & R[regC]) lui rega, immed R[regA] <- immed & 0xffc0 sw rega, regb, immed R[regA] -> Mem[ R[regB] + immed ] lw rega, regb, immed R[regA] <- Mem[ R[regB] + immed ] beq rega, regb, immed if ( R[regA] == R[regB] ) { PC <- PC immed (if label, PC <- label) } jalr rega, regb PC <- R[regB], R[regA] <- PC + 1 PSEUDO-S: nop halt do nothing stop machine & print state lli rega, immed R[regA] <- R[regA] + (immed & 0x3f) movi rega, immed R[regA] <- immed.fill immed initialized data with value immed.space immed zero-filled data array of size immed The instruction-set is described in more detail (including machine-code formats) in The RiSC-16 Instruction-Set Architecture. System calls are described only briefly in the present document; they are special instances of the JALR instruction in which the immediate value is non-zero (and indicates the system-call ID). This addition to the instruction-set architecture is made to support inter- Electrical & Computer Engineering, University of Maryland at College Park 1
2 rupts and interrupt-handling. System calls, interrupts/exceptions, and the handling of interrupts and exceptions are described in more detail in the document RiSC-16 System Architecture. 2. Background To begin with, a little background on today s out-of-order designs: in particular, there are three important papers that helped shape contemporary out-of-order computing: R. M. Tomasulo. An efficient algorithm for exploiting multiple arithmetic units. IBM Journal of Research and Development, 11(1): January J. E. Smith and A. R. Pleszkun. Implementation of precise interrupts in pipelined processors. In Proc. 12th Annual International Symposium on Computer Architecture (ISCA-12), pp June G. S. Sohi and S. Vajapeyam. Instruction issue logic for high-performance, interruptable pipelined processors. In Proc. 14th Annual International Symposium on Computer Architecture (ISCA-14), pp June The first paper gives a concrete hardware architecture for resolving inter-instruction dependencies through the register file, thereby allowing out-of-order issue to the functional units; the second paper describes several mechanisms for handling precise interrupts in pipelines with in-order issue but out-of-order completion, the reorder buffer being one of these mechanisms; finally, the third paper combines the previous two concepts into a mechanism that supports both out-of-order instruction issue and precise interrupts (as well as branch misspeculations). The following sections go into a little more detail on each. Tomasulo s Algorithm Tomasulo called his mechanism the Common Data Bus. Because the mechanism is more expansive than a simple bus, it is usually referred to as Tomasulo s algorithm instead. The underlying principle is this: when the data is stale, keep track of where new data will be coming from. Here is how the principle is used. The register file holds data. For brief windows in time, data words in the register file are stale, in that they are soon to be overwritten by an instruction that has not yet completed. Take, for example, the following code: lw r1, 16(r2) addi r1, r1, 1 Ignoring dependences between the instructions, the load instruction would be likely to take longer than the add-immediate, because the load performs both an add-immediate and a memory-access: it requires an add-immediate of register 2 with the value 16 to generate the load address. Only after the address is generated can the memory access begin. Therefore, by the time that the addi is ready to read the value of r1 out of the register file, it is likely that the load is still in midexecution. If this is the case, then r1 contains stale data that cannot be used for computation by the addi or any other instruction that follows the load. Previous architectures would either stall in this instance or use forwarding paths in the pipeline. Tomasulo s algorithm uses a different mechanism: instead of keeping track of the data in r1, it keeps track of the data s source, i.e. the load instruction which will update r1 in the near future. When the load is decoded, it is enqueued in a numbered reservation station awaiting execution; r1 is tagged as invalid; and the register file holds the reservation station ID instead of r1 s contents. Electrical & Computer Engineering, University of Maryland at College Park 2
3 Therefore, rather than keeping track of the data value, the register keeps track of where the new data will come from. When the addi instruction is decoded and enqueued, it reads the ID from the register file and is placed in its own reservation station, knowing that one of its operands is invalid, but also knowing the unique ID of the instruction that will produce the operand. That unique ID is the ID of the reservation station holding the load instruction. This information is used to forward operands from the functional units to the instructions awaiting data in reservation stations. Whenever a a functional unit produces a result value (either an ALU result or a load-word memory request), the functional unit producing the value broadcasts that value as well as the corresponding instruction s ID on the Common Data Bus. All instructions sitting in reservation stations look to this bus and gate in the data whenever one of its operands is invalid and the corresponding tag matches the ID of the data on the common data bus. As soon as an instruction s operands are all valid, the instruction is ready to execute, whether this is before or after the instructions that come before it in the instruction stream. The register file also monitors this bus, and if the ID on the bus matches the ID in any invalid register, the data is gated in to that register, and the register is marked as valid. The architecture is very simple but extremely powerful and capable of resolving all dependencies through the register file. It also provides a form of register renaming that allows the simultaneous or out-of-order execution of multiple reads and writes to the same register. The algorithm (as well as numerous variations on it) has become a staple in modern high-performance CPU design. As an aside, the fixed-point pipeline in the IBM System/360 Model 91 supported out-of-order completion as well, but in a slightly simpler form: all register data communication was through the register file. The pipeline supported no forwarding paths. The mechanism is described briefly in the same IBM Journal of R&D issue as Tomasulo s algorithm, but the description is somewhat incomplete. The document IBM 360/91 s Out-of-Order Fixed-Point Pipe on the class website describes the issue and commit mechanism (at least, my interpretation of it) in more detail. Reorder Buffer The reorder buffer was developed to solve the problem that, in many pipelined computers even those with in-order instruction issue execution results are frequently produced out-of-order. For example, this happens when functional units have different latencies. This is what Smith and Pleszkun mean by pipelined processors: in-order pipes with functional units that have different latencies, the most common pipeline of the paper s time. In previous machines, results were typically written to the register file as soon as they were produced, and if the results were produced out-of-order, they could therefore update machine state out-of-order. Such an organization causes problems in the case of handling precise interrupts, during which the machine state is required to reflect that of a sequential machine with in-order instruction completion (else the interrupt is not considered precise ). Smith and Pleszkun solve the problem by providing a mechanism to allow instructions that generate results out-of-order to be completed in-order. Changes to the state of the machine (register file, memory system) are limited to the time of instruction completion, which is handled in program order, and therefore the state of the machine always reflects that of a sequential implementation. The fundamental idea is this decoupling of instruction execution and instruction completion. Whereas in previous pipeline organizations execution and completion could be treated as an atomic multi-cycle operation, the reorder buffer separates out the concept of instruction completion as a phase of the instruction life cycle that may or may not happen on the cycle Electrical & Computer Engineering, University of Maryland at College Park 3
4 following the generation of results. Thus, the reorder buffer behaves like a holding tank for instructions while they are in the process of being executed (including decode, operand fetch, execution by an ALU, possible memory access, and writeback to the register file). It is easy to envision many possible structures that would perform such a function. The reorder buffer described in the paper is a circular queue, in which each entry holds all the instruction state necessary to carry one instruction through the various phases of instruction execution (operand fetch, execution, register file writeback, etc.). Instructions are placed into the queue and taken out of the queue in-order. The original implementation enqueues instructions at the time of instruction issue i.e. once all the operands are available. The paper describes two variations: one in which the operands must be obtained though the register file and another in which operands can be read directly out of the reorder buffer itself if the latest copy of a register value is present in the result portion of a reorder buffer entry holding an instruction that has finished executing but has not yet written its result to the register file. Though instructions are enqueued in program order and only when their operands are available, while they are in the reorder buffer program order does not dictate the sequencing of any particular events: in particular, the instructions might finish executing out of program order. When an instruction is successfully dequeued from the reorder buffer, its results are committed to the machine state. At this point, the instruction is said to be retired. While an instruction is in the process of execution, i.e. before retiring, it may cause an exceptional condition (invalid opcode, TLB miss, segmentation violation, trap instruction, etc.). To ensure that such exceptions are not handled speculatively or out-of-order, the handling of exceptional conditions is treated like the updating of machine state: exception handling does not occur until instruction commit time. This ensures that no previous instructions have caused as-yet-unhandled exceptions. Therefore, all exceptions are handled in program order, and no exception is handled for an instruction that ends up being discarded (as a result of a branch misprediction, for example). As with Tomasulo s algorithm, the concept is very simple but extremely powerful. Consequently, it has appeared in nearly every high-performance architecture in the last half-decade. The paper describes two mechanisms in addition to the reorder buffer that perform the same function in slightly different ways: the future file and history buffer. Typically, these and other mechanisms that perform the function of ensuring in-order commitment of machine state are all called by the microprocessor design community reorder buffers whether the description is technically accurate or not. Register Update Unit Note that Tomasulo s algorithm mentions nothing about precise interrupts. In fact, because it stipulates that results are to be sent to the register file as soon as they are produced, it cannot support precise interrupts without modification. Note also that the original reorder buffer paper mentions nothing about out-of-order issue to execution units. Though the mechanism may support such behavior, it is not addressed in the paper. Why am I mentioning any of this? Though these two mechanisms (Tomasulo s algorithm and the reorder buffer) solve very important problems, their existence pointed out a gaping hole that would be very important were it filled: the lack of a mechanism that combines both out-of-order issue and precise interrupts, which would provide supercomputer performance to general-purpose computers using modern operating systems facilities. Electrical & Computer Engineering, University of Maryland at College Park 4
5 Out-of-order instruction issue is important because it allows instructions to begin executing as soon as they are ready, thereby freeing up the functional units as early as possible. Otherwise, artificial stall cycles are introduced into the pipeline, lengthening program execution. Tomasulo s algorithm provided a template for building a high performance machine with out-of-order issue and imprecise interrupts. However, support for precise interrupts became increasingly important roughly in step with the rising importance of operating systems offering multitasking and virtual memory hardware support for precise interrupts greatly simplifies the implementation of both of these facilities (indeed, it is rather difficult to imagine an implementation of either multitasking or virtual memory without a precise-interrupt facility). When the reorder buffer was introduced, outof-order instruction issue was typically found only in high-end scientific-computing machines; out-of-order completion was the problem more commonly encountered in general-purpose machines. However, the problem remained to implement out-of-order instruction issue in generalpurpose machines that also needed precise interrupts. A few years after the reorder buffer paper appeared, and twenty years after Tomasulo s algorithm appeared, the problem was solved. Sohi and Vajapeyam describe in their paper the marriage of Tomasulo s algorithm and the reorder buffer; they call their mechanism the register update unit (RUU). This mechanism provides both out-of-order issue to functional units and support for precise interrupts. The RUU is a very intuitive merger of Tomasulo s algorithm and the reorder buffer. It is a circular queue into which instructions are enqueued in-order and out of which instructions are dequeued in-order. Meanwhile, instruction operands are gathered according to Tomasulo s algorithm, and instructions are sent to functional units as soon as all their operands are valid. The mechanism as described in the paper only supports single-instruction enqueue/issue/commit; however, this is not inherent to its design it is easily extended to wider implementations. The primary place of deviation with reorder buffer operation is at instruction enqueue: first and foremost, an instruction is enqueued as soon as an RUU slot is available, whether the instruction s operands are available or not. Also, whereas in the reorder buffer scheme an instruction can read its operands out of the reorder buffer if available and out of the register file otherwise, in the RUU scheme an instruction never reads from other RUU entries directly. Rather, operands are gathered from the functional-unit result buses as in Tomasulo s algorithm, and they are also gathered from the commit bus, which carries the result of the currently committing instruction to the register file. Therefore, if at the time of instruction-enqueue the most recent version of one of its operands is found in the result field of another instruction s RUU entry, the operand does not become immediately available to the instruction as it would in the reorder buffer scheme, but it does become available as soon as the value is committed to the register file. 3. RiSC-16 Out-of-Order Implementation: Overview The RiSC-16 out-of-order design is very much like Sohi & Vajapeyam s register update unit, except that it is twice as wide. The instruction encode/issue/commit logic is Tomasulo s algorithm extended to handle dual-enqueue, dual-commit, and three-way issue to the execute units (two ALU, one memory). The mechanism handles branch mispredictions and interrupts by placing instructions not in a disjoint set of reservation stations but rather in a circular instruction queue that functions similarly to Smith & Pleszkun s reorder buffer. Like the register update unit, the design departs from the reorder buffer in several ways. First, an instruction is enqueued as soon as an instruction-queue slot is available, whether the instruction s operands are available or not. Electrical & Computer Engineering, University of Maryland at College Park 5
6 FETCH PHASE FETCH BUFFERS Instruction N Instruction N+1 BUS REGISTER FILE BUS PHASE BUSES INSTR QUEUE IQ 0 IQ 1 Instruction IQ 2 N+2... IQ 7 BUS BUS PHASE ADDRESS ADDRESS ADDRESS OP ID OPER 1 OPER 2 OP ID OPER 1 OPER 2 OP ID OP ID OP ID ALU0 BUS ALU1 BUS PHASE BUS Figure 1: Overview of the pipeline organization Second, instruction operands are not read from the instruction queue at enqueue time if the register file does not have the latest copy of a data word; rather, the instruction must wait until the data is available on the commit buses, the ALU buses, or the memory bus. Because the computer-architecture field cannot seem to agree on definitions for issue/dispatch, we do not use the term dispatch and instead use the term enqueue to mean placing an instruction into the instruction queue and the term issue to mean sending a ready instruction to one of the functional units. This is illustrated in Figure 1. The architecture is two-way fetch, two-way enqueue, three-way issue and execute (two ALU instructions and one memory instruction), and two-way commit. Branch prediction is a simple backward-taken/forward-not-taken algorithm. The instruction queue has eight entries and is integrated with the memory queue; therefore, the Electrical & Computer Engineering, University of Maryland at College Park 6
7 system effectively has eight miss-status holding registers (MSHRs), enabling the handling of up to eight outstanding cache misses. However, this is artificially limited to three simultaneous requests being handled, to better reflect current DRAM design: there are three entries in the memory queue, which handles the memory interface and thus limits the number of simultaneous requests. The figure shows four of the phases through which all committed instructions pass: fetch, enqueue, issue, and execute. Each of these takes one cycle. In this document, they are not called stages because that term implies more rigid timing and ordering, whereas instructions in an outof-order core spend variable lengths of time in each stage and can visit some stages out of program order. The following sections describe each of the phases in more detail. Fetch Phase During the fetch phase, exactly two instructions are read from the instruction memory and placed into one of the two fetch buffers, each of which is wide enough to hold an instruction-fetch packet of two 16-bit instructions, plus the associated PC values for the instructions fetched. If no fetch buffer is available (e.g., if both of them are full or part full), then fetch stalls. Like the Alpha s fetch/enqueue mechanism, there are two buffers, each as wide as a fetch packet, and the enqueue mechanism does not move on to the second fetch buffer until the first is completely drained. Enqueue Phase During the enqueue phase, up to two instructions are taken from one of the fetch buffers and placed at the tail of the instruction queue. The slots are designated tail0 and tail1 in the queue. If the first instruction in the buffer is a BEQ that is predicted taken (in this implementation, it is a simple backward-taken/forward-not-taken algorithm), the second instruction is squashed. If there are instructions in the other fetch buffer (the one that is currently not being considered for enqueue), those instructions are squashed as well. If the second instruction in the fetch buffer is a taken branch, only instructions in the alternate fetch buffer are squashed. An example of two instructions being enqueued (the first of which is not a taken branch) is shown in Figure 2. The register-file access looks very similar to the decode logic in the single-issue inorder pipeline described in The Pipelined RiSC-16. However, the contents of the instructionqueue entry differ slightly from the contents of the pipelined RiSC s ID/EX register. The main differences are the status bits intended to indicate where in the instruction life cycle this particular instruction is. The fields of the instruction-queue entry are shown in Figure 3. When an instruction in one of the fetch buffers is enqueued or squashed (by a predict-taken branch), it is marked as invalid in the fetch buffer. Once both instructions are invalid, the enqueue mechanism looks at the alternate fetch buffer. Data-Incoming Phase When an instruction is enqueued, it may or may not have all of its operands. If it does, it can be sent immediately to the appropriate functional unit on the following cycle. Otherwise, it must wait in the instruction queue for its operands. During this phase, instructions scan the various result buses for their data. These buses include the ALU0/ALU1 Buses which have values returning from the ALUs, the Memory Bus which has load values returning from data memory, and the Commit Bus which has the values that are currently being written to the register file. If an Electrical & Computer Engineering, University of Maryland at College Park 7
8 FETCH BUFFERS OP ra rb 0000 rc PC OP ra rb 0000 rc PC SRC1 SRC2 REGISTER FILE SRC1 Extend-Imm Extend-Imm SRC1 SRC2 SRC2 BUS QUEUE Tail0 Tail1... V D O B M A TYP OP TGT EXC ARG0 PC ARG1 ARG2 v v src src Figure 2: Example enqueue of two instructions instruction sees that one or more of its operands is invalid and its src tag matches the ID of the data on one of these buses, it gates the associated data into its local operand storage. Issue Phase Once all of an instruction s operands are valid, its operands, opcode, and ID are sent to the inputregisters of the appropriate functional unit. The instruction s opcode directs it to the appropriate bus: LW/SW instructions go to the memory queue; all other opcodes go to an ALU. The case when more than two ALU instructions or more than one memory instruction are ready to issue at the same time is covered in a later section on scheduling. Memory operations are a special case of issue, because they actually issue twice: once to an ALU to generate the target address, and then to the memory queue when the address is known. Therefore, the issue logic considers an instruction ready to issue if all of its operands are valid, or if it is a memory operation and its ARG1 operand is valid. In this instance, the instruction is issued to an ALU as an addi instruction, and its results are gated-in to the ARG1 operand upon completion, thereby overwriting the previous valid contents. Upon completion of the addi instruction, the A bit in the instruction-queue entry is set, indicating that there is no need to reissue the address-generation portion of the instruction. For load-word operations, the instruction is ready to be issued to the data memory immediately. For store-word operations, the ARG2 operand must also be valid, as it contains the value to be stored. Also, as described below, a store instruction must be issued at the time of commit. Execute Phase Issue and execute do not happen in the same cycle: it is a two-cycle process to obtain a result once all of an instruction s operands are valid. As described in the previous section, the instruction s Electrical & Computer Engineering, University of Maryland at College Park 8
9 V D O B M A TYP OP TGT EXC ARG0 ARG1 ARG1_v ARG1_src ARG2 ARG2_v ARG2_src PC valid bit: signifies whether or not the entry s contents are valid done bit: signifies whether or not the instruction has completed execution out bit: signifies whether or not the instruction has been sent to a functional unit branch bit: signifies that the instruction was predicted taken memory-issue bit: signifies that the instruction is ready to be sent to the data memory address bit: signifies that the instruction s memory address has been generated (only applies to LW/SW operations) the instruction s type which indicates whether or not it touches memory, and whether or not it can cause a change in control-flow... note that, since this can be deduced from the opcode, it is not strictly necessary instruction opcode the instruction s register target, or zero if the instruction has no target (BEQ, SW) the exception code, or zero if the instruction has caused no exception note that HALT instructions place an EXC_HALT value directly into this register the register-file value that the instruction produces, if any the instruction s extended/shifted immediate value the instruction s first register operand valid bit for ARG1: indicates whether the value in ARG1 is valid source bit for ARG1: specifies the data-source for ARG1 (the location in the instruction queue of the instruction that will produce the value) the instruction s second register operand valid bit for ARG2: indicates whether the value in ARG2 is valid source bit for ARG2: specifies the data-source for ARG2 (the location in the instruction queue of the instruction that will produce the value) the address of the instruction, to be used if the instruction causes an exception or a branch-mispredict Figure 3: FIelds of an instruction-queue entry operands, opcode, and ID are moved to the ALU s input registers during the issue phase. On the following cycle the instruction is executed, and the resulting values are sent out on the various result buses to be latched at the end of the cycle. Memory operations take longer than a single cycle, so load results appear on the memory bus several cycles after they are initiated (this is an arbitrary choice it is not inherent to the architecture). In the instruction-queue entries, results are gated into the various operand registers as described above, but they are also gated into the registers of those instructions whose IDs are on the result buses. When this happens, the instruction is marked done. The exception to this rule is the ALU result for the effective-address generation component of a memory operation: when this result appears on the bus, the instruction is not yet done. Commit Phase When an instruction has completed, it gates the contents of one of the various result buses into its register and sets the done bit. This signifies that the instruction is ready to commit its result to the permanent machine state: the register file and/or data memory. As described in the section above on reorder buffers, this mechanism protects the machine from instructions that would be squashed because of exceptions or mispredicted branches: if an instruction commits its result to the register file and is later found to have immediately followed an instruction that causes an exception or a branch instruction that was mispredicted, it is very Electrical & Computer Engineering, University of Maryland at College Park 9
10 difficult to un-do the register-file update. It is even more difficult to un-do changes to main memory. Therefore, changes of this nature to the permanent machine state (as opposed to the contents of the instruction queue) are only allowed to occur once it is known that the instruction is non-speculative and definitely causes no exceptions. On every cycle, the commit logic considers the top two instructions in the instruction queue: those at the head of the queue, labeled head0 and head1. If there is a mispredicted branch in the machine, commit does not proceed, unless the mispredicted branch is in the head1 slot or later. If head0 is ready to commit, it does so. If head0 and head1 are both ready to commit, both do so. Otherwise, nothing happens. When an instruction commits, its result is sent to the register file and made available to other instructions needing operands. If the instruction is a SW, it is sent to the memory system. If an instruction that would otherwise be allowed to commit causes an exception, indicated by a non-zero value in the EXC field of its instruction-queue entry, the machine reacts just like a branch-mispredict event: the program counter is redirected; the exceptional instruction s program counter, held in the instruction-queue entry, is saved in a hardware register; the pipeline is flushed from the exceptional instruction to just before tail0; and execution begins with the first instruction in the exception handler. Exception-handling is covered in more detail later. 4. Mechanisms that Require a Little More Detail The previous section gives a high-level overview of what is going on in the pipeline, but there are a few details that are left out for brevity and clarity. This section delves into some of these details. Instruction Scheduling Instruction scheduling is the process of assigning ready instructions to functional units. In this implementation, all non-memory functional units (i.e., ALUs) are identical, which simplifies things immensely. However, there are only two ALUs, and on any given cycle it is possible for more than two instructions to be ready for execution. This is where instruction-scheduling comes in. It is the logic that prioritizes instructions. Traditionally, instructions are prioritized by age: the oldest instructions in the pipeline should execute before newer instructions because older instructions are more likely to be holding up other instructions in the pipe, either through dependencies or just by the fact that some instructions are ready to commit but cannot until an older instruction finishes execution. Figure 4 gives a stylized logic diagram of the instruction-scheduling mechanism. The boxes represent instruction-queue entries, and shaded boxes indicate the presence of valid instructions. Instruction-queue entries put out two signals: issue and islot. The 1-bit issue signal signifies that the instruction is ready to issue. The signal is high if the instruction-queue entry contains a valid instruction, the instruction is not done executing, the instruction is not currently out (in the process of being executed), and its operands are both valid. The 2-bit islot signal is the ID of the ALU for which the instruction is destined, or an invalid ALU number if there are too many instructions ready to issue. If an instruction is putting out a valid slot number and its issue signal is high, then that instruction is sent to the input-registers of the indicated ALU. Note that the scheme requires logic equivalent to saturating adders otherwise, if there are enough instructions ready to issue, successive adds could yield a valid ALU ID for a low-priority instruction, even after an invalid ALU number has been produced. Electrical & Computer Engineering, University of Maryland at College Park 10
11 IQ ISLOT 0 TAIL IQ ISLOT 1 IQ ISLOT 2 LOGIC: IQ ISLOT 3 x = IQ x.v & ~IQ x.d & ~IQ x.o & IQ x.arg1_v & IQ x.arg2_v ISLOT x = SATURATING-ADD( x-1, ISLOT x-1 ) HEAD IQ 4 4 ISLOT 4 IQ ISLOT 5 IQ ISLOT 6 IQ ISLOT 7 Figure 4: Instruction scheduling logic Note that the critical path scales as O(n) for n entries in the instruction queue. This is clearly a problem, as instruction windows are increasing in size we are currently at the several-dozen mark and pushing rapidly toward the several-hundred mark. A recent ISCA paper by Henry, et al. looked at ways to reduce this to O(log n), which is obviously much better. An optimization: because the issue/execute process is a two-cycle operation from the moment an instruction s operands become valid, a chain of n dependent instructions would take 2n cycles to execute. This is not particularly efficient. An improvement is to allow data on the ALU result buses to be latched back into the ALU input-registers directly. To accomplish this, an instruction must recognize when a value will be available on an ALU bus on the following cycle and set its issue signal high when it sees that the ID of an instruction currently in the execute phase is the same as one of its operand src values. Memory Operations The decision to allow an instruction to proceed to the memory subsystem is very similar to instruction scheduling. The difference is that only three memory requests can be in transit at once. This corresponds roughly to the design of today s DRAM architectures (e.g. Direct Rambus) that allow pipelined requests to memory but can handle a maximum of three requests in the pipe simultaneously. Thus, while the instruction-scheduling mechanism need only ensure that the instruction issue-width (two) is never exceeded, the memory-scheduling mechanism must ensure that the memory issue-width (one) is never exceeded and must also ensure that the maximum degree of concurrency (three) is never exceeded. In this implementation, the memory-scheduling is done in two cycles: in the first cycle, once the instruction s operands are ready, the instruction s address is compared to those of all preceding Electrical & Computer Engineering, University of Maryland at College Park 11
12 memory instructions. If there are no address conflicts with preceding instructions, and if no preceding instructions are ready to issue to the memory queue, the instruction is marked as ready to issue to the memory queue. The memory request is then sent to the 3-entry memory queue on the following cycle. An address conflict occurs whenever the reordering of two accesses might cause a problem, i.e. when they access the same memory location and one of them is a store instruction. Loads are allowed to bypass any store instruction whose target address is known to be different and are allowed to bypass any loads whether the target address of the bypassed load instruction is known or not. Loads are not allowed to bypass store instructions whose addresses are not yet known; there is a chance that the store s address might end up being the same. Stores are allowed to bypass one another once their addresses are known to be different. Note that, while this memory architecture works well in a uniprocessor setting, it can cause enormous problems in a multiprocessor setting. Note also that many more aggressive implementations exist that allow speculative bypassing and then, at a later point, repair any damage done if it is determined that an address conflict occurred between bypassed memory operations. Branch Mispredictions Though branch mispredictions and precise interrupts require virtually identical support, there are a few differences. Here is one of the most significant examples: when the pipeline is flushed because of an exception, the entire instruction queue is flushed, whereas only a portion of the instruction queue is flushed when a branch mispredict is detected. Why is this important? It is not particularly difficult to delete only a subset of the instruction queue s entries. The difficulty comes in maintaining the coherence of the register file: if all the instructions in the instruction queue are flushed, the entire contents of the register file can immediately be set to valid because all the outstanding instructions have been cancelled. This causes no inconsistencies because the register file is only updated on instruction commit, and therefore its contents are always valid, up to and including the last committed instruction. However, when a branch mispredict is detected, only a portion of the instructions in the queue are flushed; therefore, the state of the register file is partially valid, partially invalid. The core must determine very quickly which subset of the register file s contents are valid, and, for each register that remains invalid, the processor must determine the ID of the latest non-squashed instruction that will update that register. Take, for example, the following instruction-queue contents: HEAD: iq3 add r1, r2, r3 iq4 nand r3, r4, r5 iq5 nand r4, r5, r6 iq6 add r1, r3, r4 iq7 beq r1, r0, foobar iq0 add r1, r4, r5 TAIL: iq1 Assume that the beq instruction was mispredicted; therefore upon detection of the misprediction all following instructions are removed from the instruction queue. Thus, the add instruction in instruction-queue slot iq0 is deleted. At the point the misprediction is detected but before it is resolved, the state of the register file indicates that r1 is invalid and that its source is this very instruction (the add instruction in iq0). Recovering from the mispredicted branch means that the register file must retain the invalid status on r1, but its source ID should become iq6. Electrical & Computer Engineering, University of Maryland at College Park 12
13 This is non-trivial, but it amounts to solving the same problem as instruction scheduling, except that older instructions are given a lower priority, not a higher priority. Sohi & Vajapeyam s solution was to use counters associated with each register; these counters indicated the number of instructions in the RUU that targeted a given register, and they were used as the ID field instead of using a reservation station number (or, as in the RiSC-16 implementation, the instruction queue entry number). The solutions are functionally equivalent. Precise Interrupt Handling As mentioned in the introduction, the goal is to support precise interrupts and provide a simple TLB-miss handling facility. The initial implementation does not provide such support, but this section gives an overview of the proposed interrupt-handling facility. At instruction-commit time, a check is made to see if an instruction causes an exception. This is a simple check of the instruction s EXC field; if this field is non-zero, the instruction caused an exception. Once it is verified that the instruction will commit (i.e. once it is verified that none of the instructions before it cause exceptions or unexpected changes in control flow), the exception handler takes over. For backward compatibility with implementations that do not handle interrupts, interrupt handling is disabled by default. If interrupt handling is enabled, the hardware expects that there is an exception vector table in memory at location 0x0000 holding sixteen jump vectors: one for each interrupt type. The following interrupt types are the ones defined so far: #define EXC_NONE 0 #define EXC_HALT 1 #define EXC_TLBMISS 2 #define EXC_SIGSEGV 3 #define EXC_INVALID 4 When an instruction causes an exception, that fact is recorded in its instruction-queue entry. At the point when the instruction would normally commit, the exception number is used as an index into the exception vector table to find a jump address. The pipeline is flushed and resumes execution at that location and, if supervisor mode is implemented, privileges (i.e. supervisor mode) must be enabled. The program counter of the exceptional instruction is held in a hardware register to allow a later return of control to that point, if desired. When the exception or interrupt handler is finished, control returns to the application, assuming that the exception is non-terminal, as in the case of most TLB misses. The mechanism provided by most architectures is a return-from-exception instruction that jumps to the exceptional instruction (or to the one after it, in the case of a system-call instruction) and at the same time returns the processor to user mode. The RiSC-16 does exactly this. 5. Pipeline Timing As an instruction may spend a variable length of time in many of its phases, different instructions can have different latencies. This is expected, as the architecture is not a rigid N-stage pipeline like the MIPS/DLX. Moreover, different classes of instructions will most certainly have different latencies, because they require the use of different functional units that have different latencies, and some instructions require the use of multiple functional units in series. This section describes the timing behavior of the various instruction classes; the next section then illustrates the movement of instructions and their related status information through the pipeline. In the figures, dashed lines indicate phases that can take one or more cycles. Electrical & Computer Engineering, University of Maryland at College Park 13
14 ALU Instructions ALU-type instructions (add, addi, nand, lui) have the following timing: 1 CYCLE [ OPERS ] [ IQ ENTRY ] & [ HEAD PTR ] The words in square brackets represent potential reasons for stalling. In the enqueue phase (second cycle), an instruction can wait arbitrarily long for an open instruction-queue entry, and, once an entry is available (tagged as invalid), the enqueue process takes one cycle. In the issue phase (third cycle), an instruction can wait arbitrarily long for its operands, and, once the operands are valid, the issue process takes one cycle. In the commit phase (last cycle), an instruction can wait arbitrarily long for the head pointer to come around, signifying that the instruction is in the next block of instructions to commit, and, once the instruction is marked done and all preceding instructions have committed, the commit process takes one cycle. These are simple instructions, requiring a single cycle of execution in an ALU. They all update the register file. They can have two register operands (add, nand), one register operand (addi), or no register operands (lui). As with any other type of instructions, more than one may be executed and committed simultaneously if there are no inter-instruction dependencies. For example, the following code: add nand r1, r2, r3 r4, r5, r6 has the following timing, assuming the necessary operands are available in the register file at instruction enqueue: Because of the optimization described earlier, a chain of dependent instructions is executed by the processor core at a rate of one instruction per cycle. For example, the following chain: lui lli add nand r1, 0xabcd r1, 0xabcd r1, r1, r2 r1, r1, r3 has the following timing: [ OPER ] [ OPER ] [ OPER ] Electrical & Computer Engineering, University of Maryland at College Park 14
15 Note that the latency is increasing for each successive instruction. Clearly, this pattern is not sustainable. At some point, in a long line of dependent instructions, the instruction queue fills up, restricting the enqueue mechanism to one instruction per cycle, and the steady-state yields a single-instruction throughput. For example, the following code:... addi r1, r1, 1 add r1, r1, r2 nand r1, r1, r3 addi r1, r1, 1 add r1, r1, r2 nand r1, r1, r3 addi r1, r1, 1 add r1, r1, r2 nand r1, r1, r3... yields the following timing: [ IQ ENTRY ] [ IQ ENTRY ] [ IQ ENTRY ] [ IQ ENTRY ] [ IQ ENTRY ] [ IQ ENTRY ] The reason that every instruction stalls waiting for an IQ entry is that the alternate fetch buffer is filled as soon as it is emptied e.g., as soon as the second instruction is enqueued, the third fetch (getting the 5th and 6th instructions) begins. Memory Instructions Load instructions have the following timing: [ OPERS ] [ IQ ENTRY ] ADDR & IN ARG1 SET A BIT CHECK FOR ADDRESS CONFLICTS SEND TO MEMQ [ IDLE ] WAIT 1 WAIT 2 READ SET D BIT [ HEAD PTR ] RETIRE After the target address is generated, the memory-scheduling logic compares the target address to that of every instruction earlier in the queue. This phase ( check for address conflicts ) can take an arbitrary amount of time until the instruction queue is free of conflicts. When conflicts have been resolved, the request is sent to the memory queue, illustrated by a separation of the two instruction paths. The memory system returns the requested data three cycles later, to be latched on the fourth cycle. When the data returns, the done bit is set and the instruction can commit. Electrical & Computer Engineering, University of Maryland at College Park 15
16 Store instructions have slightly different timing: [ OPERS ] [ IQ ENTRY ] ADDR & IN ARG1 SET A BIT CHECK FOR ADDRESS CONFLICTS [ HEAD PTR ] SEND TO MEMQ RETIRE SET D BIT INSTR WAIT 1 WAIT 2 WRITE The primary difference is that stores wait to send anything to the memory system until it is known that they will definitely commit. Therefore, the wait for the head pointer to come around happens earlier in the life cycle. Once the request has been handed off to the memory queue, there is no reason for the instruction to remain in the instruction queue, and so it is committed immediately. Here are the timings for several different combinations of memory instructions. First, two independent memory operations fetched at the same time, whose operands are available in the register file at enqueue time. This shows the stall cycle introduced to the second instruction that is due to the maximum issue width of memory operations (one per cycle). For example, the following code: lw lw r1, r0, foo1 r2, r0, foo2 has the following timing, with the shaded boxes indicating the cycles during which the instruction is occupying a slot in the memory queue: ADDR IN ARG1 SET A BIT CHECK FOR ADDRESS CONFLICTS SEND TO MEMQ WAIT 1 WAIT 2 READ SET D BIT RETIRE ADDR IN ARG1 SET A BIT CHECK FOR ADDRESS CONFLICTS, AVAILABLE SLOT SEND TO MEMQ WAIT 1 WAIT 2 READ SET D BIT RETIRE Next, we look at a series of independent instructions that exceeds the memory queue s capacity. Here, memory instructions stall not because of exceeding the memory-issue width (one) but of exceeding the memory queue s capacity of simultaneous instructions (three). The following code: lw lw lw lw r1, r0, foo1 r2, r0, foo2 r3, r0, foo3 r4, r0, foo4 has the following timing, the shaded boxes representing cycles during which instructions occupy slots in the memory queue: ADDR IN ARG1 SET A BIT CHECK FOR ADDRESS CONFLICTS SEND TO MEMQ WAIT 1 WAIT 2 READ SET D BIT RETIRE ADDR IN ARG1 SET A BIT CHECK FOR ADDRESS CONFLICTS, AVAILABLE SLOT SEND TO MEMQ WAIT 1 WAIT 2 READ SET D BIT RETIRE ADDR IN ARG1 SET A BIT CHECK FOR ADDRESS CONFLICTS, AVAILABLE SLOT SEND TO MEMQ WAIT 1 WAIT 2 READ SET D BIT RETIRE ADDR IN ARG1 SET A BIT CHECK FOR ADDRESS CONFLICTS, AVAILABLE SLOT, MEMQ CAPACITY SEND TO MEMQ WAIT 1 WAIT 2 READ SET D BIT RETIRE Electrical & Computer Engineering, University of Maryland at College Park 16
17 Next, we look at the timing for an instance where a store instruction depends on the data returned from a load instruction. This shows the store stalling during the operand fetch phase. The following code: lw sw r1, r0, foo1 r1, r0, foo2 has the following timing: ADDR IN ARG1 SET A BIT CHECK FOR ADDRESS CONFLICTS SEND TO MEMQ WAIT 1 WAIT 2 READ SET D BIT RETIRE ADDR IN ARG1 SET A BIT [ WAIT FOR OPER ] OPER CHECK FOR ADDRESS CONFLICTS SEND TO MEMQ SET D BIT RETIRE INSTR WRITE Last, we look at the timing for a pair of memory instructions where the first is a load-word and the second uses the result of that load for its target address. The second instruction could be a load or store instruction. This shows the second instruction stalling during the address-generation phase. The following two code examples produce identical timing (the difference is that the second code example shows the sw dependent on the lw through r1 for both address and data): lw sw r1, r0, foo1 r0, r1, foo2 lw r1, r0, foo1 sw r1, r1, foo2 The timing is shown below: ADDR IN ARG1 SET A BIT CHECK FOR ADDRESS CONFLICTS SEND TO MEMQ WAIT 1 WAIT 2 READ SET D BIT RETIRE [ WAIT FOR ADDRESS OPER ] ADDR OPER ADDR IN ARG1 SET A BIT CHECK FOR ADDRESS CONFLICTS SEND TO MEMQ SET D BIT RETIRE INSTR WRITE Note that, compared to ALU instructions, there is an extra cycle between the moment that the necessary operand is produced and the moment that the store instruction is issued to the ALU for its address generation phase. This is the extra cycle between the latch result cycle of the load instruction and the execute cycle of the store instruction after it the cycle in which the store instruction does schedule and issue operations. If the first instruction were an ALU-type instruction and not a load-word, the store would schedule and issue during the cycle currently marked latch addr operand. This is not a mistake; the optimization described earlier that allows dependent ALU instructions to issue on successive cycles does not apply to operands appearing on the memory bus. When an instruction obtains an operand from the memory bus, it does not schedule itself until the following cycle. Branches and Jumps Conditional branches that are predicted not-taken look just like ALU-type instructions: they collect their operands and are issued to the functional units to verify the prediction. Meanwhile, the program counter simply increments as with a regular instruction. Assuming the prediction is correct, pipeline timing is not affected. Conditional branches that are predicted taken are resolved in the enqueue phase. While the beq instruction is sitting in one of the fetch buffers, the predicted target address is generated and Electrical & Computer Engineering, University of Maryland at College Park 17
18 placed into the program counter. Instruction fetch down the predicted path begins on the following cycle. Thus, there is a one-cycle penalty for predicted-taken branches. This is pretty standard for architectures without branch-target buffers. The timing: RECOGNIZE FETCH BRANCHBACK DOWN PREDICTED RESET PC PATH For example, assume that the PC currently points to the beq instruction. The following code: back: add r2, r3, r4 nand r5, r2, r6 add r1, r2, r3 addi r1, r1, 5... beq r0, r1, back // PC starts here add r2, r3, r4 has the following timing, assuming that the branch is predicted correctly: RECOGNIZE BRANCHBACK RESET PC VERIFY PREDICTION RETIRE INSTR [ STOMP ] [ OPER ] Branch mispredictions are resolved in the execute phase, where the functional unit compares the operands and sets the program counter appropriately if it is determined that the branch direction taken was not appropriate. Note that, in this implementation, there is no branch target buffer, so we need not resolve instances where the branch target was mispredicted, which also must be accounted for in the case where both the direction and the target are speculative. The following diagram gives the timing for a mispredicted branch instruction, using the code example above. Assume the PC is pointing at the beq instruction. RECOGNIZE BRANCHBACK RESET PC RECOGNIZE RETIRE INSTR [ STOMP ] [ STOMP ] [ STOMP ] STALL RESET PC STALL RESET PC Jump-and-link instructions are implemented just like branch misspeculations; they are resolved in the execute phase, at which point the target address is known. The timing therefore looks much Electrical & Computer Engineering, University of Maryland at College Park 18
19 like the mispredicted branch example, above: during the execute phase, the target address for the JALR is known, and the branchmiss signal is set, just as if the instruction were a misspeculated branch. The program counter is redirected during this cycle, and instruction-fetch down the correct path resumes on the following cycle. 6. Example Operation The following figures illustrate (in excruciating detail) the movement of instructions, data, and status information through the pipeline during the execution of a relatively simple piece of code. This is done to animate the design, hopefully giving a clear picture of what happens in the machine. The following code example is used (addresses are included for clarity): # # main loop: loads a number and then a variable number of data items to subtract # from the first. at end, saves result in diff memory location # 0000 lw r1, r0, arg lw r3, r0, count 0002 loop: lw r2, r4, arg2 0003/4 movi r7, sub # resolves to 2 instructions 0005 jalr r7, r addi r3, r3, beq r3, 0, exit 0008 addi r4, r4, beq r0, r0, loop 000a exit: sw r1, r0, diff 000b halt # # subtract function: operands in r1/r2, return address in r7. result -> r1 # 000c sub: nand r2, r2, r2 000d addi r2, r2, 1 000e add r1, r1, r2 000f jalr r0, r7 # # data: count is the # of items to subtract from arg1 (in this case, 1: arg2) # diff is where the result is placed # 0010 count:.fill arg1:.fill arg2:.fill diff:.fill 0 The execution takes 29 cycles and illustrates many of the possible behaviors: ALU operations, memory operations, BEQ instructions predicted-taken and predicted-not-taken, BEQ instructions predicted correctly and incorrestly, JALR instructions (which use the branch-miss facility and behave like a mispredicted BEQ), instruction-enqueue of 0, 1, and 2 instructions, the filling up of the instruction queue thereby blocking enqueue and fetch, retirement of instructions, etc. Only the first dozen cycles are shown; the remainder are given in the RiSC-oo.1.v Execution Example. The state of the machine at the start of each cycle is shown in Figures Dark lines indicate movement of data (which is latched at the end of the cycle and is visible in machine state on next cycle). The top bit of the instruction ID indicates the result bus to watch: memory bus vs. ALU bus. For instance, a LW enqueued in slot 3 will tag the register file with id 13 rather than 03; this notifies other instructions not to latch the results of the LW s add-immediate operation that simply generates the target address. Opcode values are prefixed with a indicating ALU instructions, b indicating branch operations, or m for memory operations. Non-obvious fields of the IQ entry (not all are fields; some are just signals): Valid, Done, Out, Branch-taken, Memory-issuable, Address-generated, Issuable (to ALU), Slot-number, and X = kill the instruction. The figures start Electrical & Computer Engineering, University of Maryland at College Park 19
20 BRANCH FETCH BACK: BUFFERS: v PC on FB v INST PC > A: 1 a > B: 1 ac PC: 0002 on FB v INST PC -- C: 0 xxxx xxxx -- D: 0 xxxx xxxx REGISTER FILE: RN RVAL v sc 0: : xx 2: xx 3: xx 4: xx 5: xx 6: xx 7: xx BUSES: B# v RSLT ID rt EX 0: 0 xxxx x0 0x 00 1: 0 xxxx x1 0x 00 HT IQ V D O B M A I S X OP rt EX RSLT ARG0 ARG1 v sc ARG2 v sc PC HT 0: 0 x x x 0 x `x 0x xx xxxx xxxx xxxx x xx xxxx x xx xxxx.. 1: 0 x x x 0 x `x 0x xx xxxx xxxx xxxx x xx xxxx x xx xxxx.. 2: 0 x x x 0 x `x 0x xx xxxx xxxx xxxx x xx xxxx x xx xxxx.. 3: 0 x x x 0 x `x 0x xx xxxx xxxx xxxx x xx xxxx x xx xxxx.. 4: 0 x x x 0 x `x 0x xx xxxx xxxx xxxx x xx xxxx x xx xxxx.. 5: 0 x x x 0 x `x 0x xx xxxx xxxx xxxx x xx xxxx x xx xxxx.. 6: 0 x x x 0 x `x 0x xx xxxx xxxx xxxx x xx xxxx x xx xxxx.. 7: 0 x x x 0 x `x 0x xx xxxx xxxx xxxx x xx xxxx x xx xxxx S ADDR OP ID v ARG0 ARG1 ARG2 OP B ID PC v ARG0 ARG1 ARG2 OP B ID PC 0 xxxx xxxx `x xx 0 xxxx xxxx xxxx `x x xx xxxx 0 xxxx xxxx xxxx `x x xx xxxx 0 xxxx xxxx `x xx 0 xxxx xxxx `x xx v RSLT ID EX 0 xxxx xx x BUS v RSLT ID EX v ID PC v RSLT ID EX v ID PC 0 xxxx xx 0 0 xx xxxx 0 xxxx xx 0 0 xx xxxx BUS BUS Figure 5: EXECUTION CYCLE 2 on cycle 2; during cycle 1 we fetched instructions at pc=0000 and pc=0001 (two LW instructions) into the two first fetch buffers (A and B) and incremented the program counter by 2. During execution cycle 2, we enqueue the first two instructions into the slots indicated by the tail pointer (labeled T at the side of the instruction queue); this includes reading from the register file: the register value RVAL, its valid bit V, and its source SC. During this phase, the targets of the two LW instructions (r1 and r3) are tagged invalid and their SC fields directed to the two LW instructions. Note the top bits of these IDs are 1, indicating that the final result will come from the memory bus, not an ALU bus. We also fetch the next two instructions (an LW and a LUI a Electrical & Computer Engineering, University of Maryland at College Park 20
Course on: Advanced Computer Architectures INSTRUCTION LEVEL PARALLELISM PART VII: REORDER BUFFER Prof. Cristina Silvano Politecnico di Milano email@example.com Prof. Silvano, Politecnico di MilanoMore information
WAR: Write After Read
WAR: Write After Read write-after-read (WAR) = artificial (name) dependence add R1, R2, R3 sub R2, R4, R1 or R1, R6, R3 problem: add could use wrong value for R2 can t happen in vanilla pipeline (readsMore information
CS352H: Computer Systems Architecture
CS352H: Computer Systems Architecture Topic 9: MIPS Pipeline - Hazards October 1, 2009 University of Texas at Austin CS352H - Computer Systems Architecture Fall 2009 Don Fussell Data Hazards in ALU InstructionsMore information
EE482: Advanced Computer Organization Lecture #11 Processor Architecture Stanford University Wednesday, 31 May 2000. ILP Execution
EE482: Advanced Computer Organization Lecture #11 Processor Architecture Stanford University Wednesday, 31 May 2000 Lecture #11: Wednesday, 3 May 2000 Lecturer: Ben Serebrin Scribe: Dean Liu ILP ExecutionMore information
More on Pipelining and Pipelines in Real Machines CS 333 Fall 2006 Main Ideas Data Hazards RAW WAR WAW More pipeline stall reduction techniques Branch prediction» static» dynamic bimodal branch predictionMore information
Solution: start more than one instruction in the same clock cycle CPI < 1 (or IPC > 1, Instructions per Cycle) Two approaches:
Multiple-Issue Processors Pipelining can achieve CPI close to 1 Mechanisms for handling hazards Static or dynamic scheduling Static or dynamic branch handling Increase in transistor counts (Moore s Law):More information
Computer Organization and Architecture
Computer Organization and Architecture Chapter 14 Instruction Level Parallelism and Superscalar Processors What does Superscalar mean? Common instructions (arithmetic, load/store, conditional branch) canMore information
506 CHAPTER 8 PIPELINING (Corrisponde al cap. 11 - Introduzione al pipelining) PROBLEMS 8.1 Consider the following sequence of instructions Mul And #20,R0,R1 #3,R2,R3 #$3A,R2,R4 R0,R2,R5 In all instructions,More information
Lecture: Pipelining Extensions. Topics: control hazards, multi-cycle instructions, pipelining equations
Lecture: Pipelining Extensions Topics: control hazards, multi-cycle instructions, pipelining equations 1 Problem 6 Show the instruction occupying each stage in each cycle (with bypassing) if I1 is R1+R2More information
Overview. CISC Developments. RISC Designs. CISC Designs. VAX: Addressing Modes. Digital VAX
Overview CISC Developments Over Twenty Years Classic CISC design: Digital VAX VAXÕs RISC successor: PRISM/Alpha IntelÕs ubiquitous 80x86 architecture Ð 8086 through the Pentium Pro (P6) RJS 2/3/97 PhilosophyMore information
Advanced Pipelining Techniques
Advanced Pipelining Techniques 1. Dynamic Scheduling 2. Loop Unrolling 3. Software Pipelining 4. Dynamic Branch Prediction Units 5. Register Renaming 6. Superscalar Processors 7. VLIW (Very Large InstructionMore information
CS:APP Chapter 4 Computer Architecture. Wrap-Up. William J. Taffe Plymouth State University. using the slides of
CS:APP Chapter 4 Computer Architecture Wrap-Up William J. Taffe Plymouth State University using the slides of Randal E. Bryant Carnegie Mellon University Overview Wrap-Up of PIPE Design Performance analysisMore information
How to improve (decrease) CPI
How to improve (decrease) CPI Recall: CPI = Ideal CPI + CPI contributed by stalls Ideal CPI =1 for single issue machine even with multiple execution units Ideal CPI will be less than 1 if we have severalMore information
Instruction Set Architecture. or How to talk to computers if you aren t in Star Trek
Instruction Set Architecture or How to talk to computers if you aren t in Star Trek The Instruction Set Architecture Application Compiler Instr. Set Proc. Operating System I/O system Instruction Set ArchitectureMore information
Q. Consider a dynamic instruction execution (an execution trace, in other words) that consists of repeats of code in this pattern:
Pipelining HW Q. Can a MIPS SW instruction executing in a simple 5-stage pipelined implementation have a data dependency hazard of any type resulting in a nop bubble? If so, show an example; if not, proveMore information
Design of Pipelined MIPS Processor. Sept. 24 & 26, 1997
Design of Pipelined MIPS Processor Sept. 24 & 26, 1997 Topics Instruction processing Principles of pipelining Inserting pipe registers Data Hazards Control Hazards Exceptions MIPS architecture subset R-typeMore information
Advanced Computer Architecture-CS501. Computer Systems Design and Architecture 2.1, 2.2, 3.2
Lecture Handout Computer Architecture Lecture No. 2 Reading Material Vincent P. Heuring&Harry F. Jordan Chapter 2,Chapter3 Computer Systems Design and Architecture 2.1, 2.2, 3.2 Summary 1) A taxonomy ofMore information
Pipeline Hazards. Structure hazard Data hazard. ComputerArchitecture_PipelineHazard1
Pipeline Hazards Structure hazard Data hazard Pipeline hazard: the major hurdle A hazard is a condition that prevents an instruction in the pipe from executing its next scheduled pipe stage Taxonomy ofMore information
CHAPTER 7: The CPU and Memory
CHAPTER 7: The CPU and Memory The Architecture of Computer Hardware, Systems Software & Networking: An Information Technology Approach 4th Edition, Irv Englander John Wiley and Sons 2010 PowerPoint slidesMore information
UNIVERSITY OF CALIFORNIA, DAVIS Department of Electrical and Computer Engineering. EEC180B Lab 7: MISP Processor Design Spring 1995
UNIVERSITY OF CALIFORNIA, DAVIS Department of Electrical and Computer Engineering EEC180B Lab 7: MISP Processor Design Spring 1995 Objective: In this lab, you will complete the design of the MISP processor,More information
Giving credit where credit is due
CSCE 230J Computer Organization Processor Architecture VI: Wrap-Up Dr. Steve Goddard firstname.lastname@example.com http://cse.unl.edu/~goddard/courses/csce230j Giving credit where credit is due ost of slides forMore information
The Microarchitecture of Superscalar Processors
The Microarchitecture of Superscalar Processors James E. Smith Department of Electrical and Computer Engineering 1415 Johnson Drive Madison, WI 53706 ph: (608)-265-5737 fax:(608)-262-1267 email: email@example.com information
VLIW Processors. VLIW Processors
1 VLIW Processors VLIW ( very long instruction word ) processors instructions are scheduled by the compiler a fixed number of operations are formatted as one big instruction (called a bundle) usually LIWMore information
Pipeline Hazards. Arvind Computer Science and Artificial Intelligence Laboratory M.I.T. Based on the material prepared by Arvind and Krste Asanovic
1 Pipeline Hazards Computer Science and Artificial Intelligence Laboratory M.I.T. Based on the material prepared by and Krste Asanovic 6.823 L6-2 Technology Assumptions A small amount of very fast memoryMore information
Application Note 195. ARM11 performance monitor unit. Document number: ARM DAI 195B Issued: 15th February, 2008 Copyright ARM Limited 2007
Application Note 195 ARM11 performance monitor unit Document number: ARM DAI 195B Issued: 15th February, 2008 Copyright ARM Limited 2007 Copyright 2007 ARM Limited. All rights reserved. Application NoteMore information
Instruction Set Design
Instruction Set Design Instruction Set Architecture: to what purpose? ISA provides the level of abstraction between the software and the hardware One of the most important abstraction in CS It s narrow,More information
An Introduction to the ARM 7 Architecture
An Introduction to the ARM 7 Architecture Trevor Martin CEng, MIEE Technical Director This article gives an overview of the ARM 7 architecture and a description of its major features for a developer newMore information
MICROPROCESSOR. Exclusive for IACE Students www.iace.co.in iacehyd.blogspot.in Ph: 9700077455/422 Page 1
MICROPROCESSOR A microprocessor incorporates the functions of a computer s central processing unit (CPU) on a single Integrated (IC), or at most a few integrated circuit. It is a multipurpose, programmableMore information
(Refer Slide Time: 00:01:16 min)
Digital Computer Organization Prof. P. K. Biswas Department of Electronic & Electrical Communication Engineering Indian Institute of Technology, Kharagpur Lecture No. # 04 CPU Design: Tirning & ControlMore information
Pipelining Review and Its Limitations
Pipelining Review and Its Limitations Yuri Baida firstname.lastname@example.com firstname.lastname@example.com October 16, 2010 Moscow Institute of Physics and Technology Agenda Review Instruction set architecture BasicMore information
Static Scheduling. option #1: dynamic scheduling (by the hardware) option #2: static scheduling (by the compiler) ECE 252 / CPS 220 Lecture Notes
basic pipeline: single, in-order issue first extension: multiple issue (superscalar) second extension: scheduling instructions for more ILP option #1: dynamic scheduling (by the hardware) option #2: staticMore information
Reduced Instruction Set Computer vs Complex Instruction Set Computers
RISC vs CISC Reduced Instruction Set Computer vs Complex Instruction Set Computers for a given benchmark the performance of a particular computer: P = 1 I C 1 S where P = time to execute I = number ofMore information
The Von Neumann Model. University of Texas at Austin CS310H - Computer Organization Spring 2010 Don Fussell
The Von Neumann Model University of Texas at Austin CS310H - Computer Organization Spring 2010 Don Fussell The Stored Program Computer 1943: ENIAC Presper Eckert and John Mauchly -- first general electronicMore information
Chapter 1 Computer System Overview
Operating Systems: Internals and Design Principles Chapter 1 Computer System Overview Eighth Edition By William Stallings Operating System Exploits the hardware resources of one or more processors ProvidesMore information
COMP 303 MIPS Processor Design Project 4: MIPS Processor Due Date: 11 December 2009 23:59
COMP 303 MIPS Processor Design Project 4: MIPS Processor Due Date: 11 December 2009 23:59 Overview: In the first projects for COMP 303, you will design and implement a subset of the MIPS32 architectureMore information
Instruction Set Architecture
Instruction Set Architecture Consider x := y+z. (x, y, z are memory variables) 1-address instructions 2-address instructions LOAD y (r :=y) ADD y,z (y := y+z) ADD z (r:=r+z) MOVE x,y (x := y) STORE x (x:=r)More information
Ch 5: Designing a Single Cycle Datapath
Ch 5: Designing a Single Cycle path Computer Systems Architecture CS 365 The Big Picture: Where are We Now? The Five Classic Components of a Computer Processor Control Memory path Input Output Today sMore information
OC By Arsene Fansi T. POLIMI 2008 1
IBM POWER 6 MICROPROCESSOR OC By Arsene Fansi T. POLIMI 2008 1 WHAT S IBM POWER 6 MICROPOCESSOR The IBM POWER6 microprocessor powers the new IBM i-series* and p-series* systems. It s based on IBM POWER5More information
Computer organization
Computer organization Computer design an application of digital logic design procedures Computer = processing unit + memory system Processing unit = control + datapath Control = finite state machine inputsMore information
M A S S A C H U S E T T S I N S T I T U T E O F T E C H N O L O G Y DEPARTMENT OF ELECTRICAL ENGINEERING AND COMPUTER SCIENCE 1. Introduction 6.004 Computation Structures β Documentation This handout isMore information
Spring 2011 Prof. Hyesoon Kim
Spring 2011 Prof. Hyesoon Kim MIPS Architecture MIPS (Microprocessor without interlocked pipeline stages) MIPS Computer Systems Inc. Developed from Stanford MIPS architecture usages 1990 s R2000, R3000,More information
CPU Performance Equation
CPU Performance Equation C T I T ime for task = C T I =Average # Cycles per instruction =Time per cycle =Instructions per task Pipelining e.g. 3-5 pipeline steps (ARM, SA, R3000) Attempt to get C downMore information
A Lab Course on Computer Architecture
A Lab Course on Computer Architecture Pedro López José Duato Depto. de Informática de Sistemas y Computadores Facultad de Informática Universidad Politécnica de Valencia Camino de Vera s/n, 46071 - Valencia,More information
CSE 30321 Computer Architecture I Fall 2009 Final Exam December 18, 2009
CSE 30321 Computer Architecture I Fall 2009 Final Exam December 18, 2009 Test Guidelines: 1. Place your name on EACH page of the test in the space provided. 2. every question in the space provided. IfMore information
Solutions. Solution 4.1. 4.1.1 The values of the signals are as follows:
4 Solutions Solution 4.1 4.1.1 The values of the signals are as follows: RegWrite MemRead ALUMux MemWrite ALUOp RegMux Branch a. 1 0 0 (Reg) 0 Add 1 (ALU) 0 b. 1 1 1 (Imm) 0 Add 1 (Mem) 0 ALUMux is theMore information
Software Pipelining. for (i=1, i<100, i++) { x := A[i]; x := x+1; A[i] := x
Software Pipelining for (i=1, iMore information
A Brief Review of Processor Architecture. Why are Modern Processors so Complicated? Basic Structure
A Brief Review of Processor Architecture Why are Modern Processors so Complicated? Basic Structure CPU PC IR Regs ALU Memory Fetch PC -> Mem addr [addr] > IR PC ++ Decode Select regs Execute Perform opMore information
Computer Organization and Components
Computer Organization and Components IS5, fall 25 Lecture : Pipelined Processors ssociate Professor, KTH Royal Institute of Technology ssistant Research ngineer, University of California, Berkeley SlidesMore information
150127-Microprocessor & Assembly Language
Chapter 3 Z80 Microprocessor Architecture The Z 80 is one of the most talented 8 bit microprocessors, and many microprocessor-based systems are designed around the Z80. The Z80 microprocessor needs anMore information
An Implementation Of Multiprocessor Linux
An Implementation Of Multiprocessor Linux This document describes the implementation of a simple SMP Linux kernel extension and how to use this to develop SMP Linux kernels for architectures other thanMore information
Review: MIPS Addressing Modes/Instruction Formats
Review: Addressing Modes Addressing mode Example Meaning Register Add R4,R3 R4 R4+R3 Immediate Add R4,#3 R4 R4+3 Displacement Add R4,1(R1) R4 R4+Mem[1+R1] Register indirect Add R4,(R1) R4 R4+Mem[R1] IndexedMore information
Exceptions in MIPS. know the exception mechanism in MIPS be able to write a simple exception handler for a MIPS machine
7 Objectives After completing this lab you will: know the exception mechanism in MIPS be able to write a simple exception handler for a MIPS machine Introduction Branches and jumps provide ways to changeMore information
18-447 Computer Architecture Lecture 3: ISA Tradeoffs. Prof. Onur Mutlu Carnegie Mellon University Spring 2013, 1/18/2013
18-447 Computer Architecture Lecture 3: ISA Tradeoffs Prof. Onur Mutlu Carnegie Mellon University Spring 2013, 1/18/2013 Reminder: Homeworks for Next Two Weeks Homework 0 Due next Wednesday (Jan 23), rightMore information
CPU Organisation and Operation
CPU Organisation and Operation The Fetch-Execute Cycle The operation of the CPU 1 is usually described in terms of the Fetch-Execute cycle. 2 Fetch-Execute Cycle Fetch the Instruction Increment the ProgramMore information
StrongARM** SA-110 Microprocessor Instruction Timing
StrongARM** SA-110 Microprocessor Instruction Timing Application Note September 1998 Order Number: 278194-001 Information in this document is provided in connection with Intel products. No license, expressMore information
Computer Architecture
Computer Architecture Having studied numbers, combinational and sequential logic, and assembly language programming, we begin the study of the overall computer system. The term computer architecture isMore information
An Overview of Stack Architecture and the PSC 1000 Microprocessor
An Overview of Stack Architecture and the PSC 1000 Microprocessor Introduction A stack is an important data handling structure used in computing. Specifically, a stack is a dynamic set of elements in whichMore information
Using Graphics and Animation to Visualize Instruction Pipelining and its Hazards
Using Graphics and Animation to Visualize Instruction Pipelining and its Hazards Per Stenström, Håkan Nilsson, and Jonas Skeppstedt Department of Computer Engineering, Lund University P.O. Box 118, S-221More information
Boosting Beyond Static Scheduling in a Superscalar Processor
Boosting Beyond Static Scheduling in a Superscalar Processor Michael D. Smith, Monica S. Lam, and Mark A. Horowitz Computer Systems Laboratory Stanford University, Stanford CA 94305-4070 May 1990 1 IntroductionMore information
in the name of God the compassionate, the merciful notes on MACHINE ARCHITECTURE & LANGUAGE compiled by Jumong Chap. 9 Microprocessor Fundamentals A system designer should consider a microprocessor-basedMore information
LOCKUP-FREE INSTRUCTION FETCH/PREFETCH CACHE ORGANIZATION DAVID KROFT Control Data Canada, Ltd. Canadian Development Division Mississauga, Ontario, Canada ABSTRACT In the past decade, there has been muchMore information
The University of Nottingham
The University of Nottingham School of Computer Science A Level 1 Module, Autumn Semester 2007-2008 Computer Systems Architecture (G51CSA) Time Allowed: TWO Hours Candidates must NOT start writing theirMore information
İSTANBUL AYDIN UNIVERSITY FACULTY OF ENGİNEERİNG SOFTWARE ENGINEERING THE PROJECT OF THE INSTRUCTION SET COMPUTER ORGANIZATION GÖZDE ARAS B1205.090015 Instructor: Prof. Dr. HASAN HÜSEYİN BALIK DECEMBERMore information
COMPUTER ORGANIZATION ARCHITECTURES FOR EMBEDDED COMPUTING 2013/2014 1 st Semester Sample Exam January 2014 Duration: 2h00 - No extra material allowed. This includes notes, scratch paper, calculator, etc.More information
CSC 2405: Computer Systems II
CSC 2405: Computer Systems II Spring 2013 (TR 8:30-9:45 in G86) Mirela Damian http://www.csc.villanova.edu/~mdamian/csc2405/ Introductions Mirela Damian Room 167A in the Mendel Science Building email@example.com information
LSN 2 Computer Processors
LSN 2 Computer Processors Department of Engineering Technology LSN 2 Computer Processors Microprocessors Design Instruction set Processor organization Processor performance Bandwidth Clock speed LSN 2More information
Instruction Set Architecture (ISA)
Instruction Set Architecture (ISA) * Instruction set architecture of a machine fills the semantic gap between the user and the machine. * ISA serves as the starting point for the design of a new machineMore information
This Unit: Code Scheduling. CIS 371 Computer Organization and Design. Pipelining Review. Readings. ! Pipelining and superscalar review
This Unit: Code Scheduling CIS 371 Computer Organization and Design App App App System software Mem CPU I/O! Pipelining and superscalar review! Code scheduling! To reduce pipeline stalls! To increase ILPMore information
Computer Architecture Lecture 2: Instruction Set Principles (Appendix A) Chih Wei Liu 劉 志 尉 National Chiao Tung University firstname.lastname@example.com.
Computer Architecture Lecture 2: Instruction Set Principles (Appendix A) Chih Wei Liu 劉 志 尉 National Chiao Tung University firstname.lastname@example.com Review Computers in mid 50 s Hardware was expensiveMore information
Week 1 out-of-class notes, discussions and sample problems
Week 1 out-of-class notes, discussions and sample problems Although we will primarily concentrate on RISC processors as found in some desktop/laptop computers, here we take a look at the varying typesMore information
Data Memory Alternatives for Multiscalar Processors
Data Memory Alternatives for Multiscalar Processors Scott E. Breach, T. N. Vijaykumar, Sridhar Gopal, James E. Smith, Gurindar S. Sohi Computer Sciences Department University of Wisconsin-Madison 1210More information
Chapter 4 Lecture 5 The Microarchitecture Level Integer JAVA Virtual Machine
Chapter 4 Lecture 5 The Microarchitecture Level Integer JAVA Virtual Machine This is a limited version of a hardware implementation to execute the JAVA programming language. 1 of 23 Structured ComputerMore information
Model Answers HW2 - Chapter #3
Model Answers HW2 - Chapter #3 1. The hypothetical machine of figure 3.4 also has two I/O instructions: 0011= Load AC fro I/O 0111= Store AC to I/O In these cases the 12-bit address identifies a particularMore information
1. Introduction. 2. An Overview of Cache
1 Introduction The purpose of this paper is two fold The first part gives an overview of cache, while the second part explains how the Pentium Processor implements cache A simplified model of a cache systemMore information
#5. Show and the AND function can be constructed from two NAND gates.
Study Questions for Digital Logic, Processors and Caches G22.0201 Fall 2009 ANSWERS Digital Logic Read: Sections 3.1 3.3 in the textbook. Handwritten digital lecture notes on the course web page. StudyMore information
EE282 Computer Architecture and Organization Midterm Exam February 13, 2001. (Total Time = 120 minutes, Total Points = 100)
EE282 Computer Architecture and Organization Midterm Exam February 13, 2001 (Total Time = 120 minutes, Total Points = 100) Name: (please print) Wolfe - Solution In recognition of and in the spirit of theMore information
Putting it all together: Intel Nehalem. http://www.realworldtech.com/page.cfm?articleid=rwt040208182719
Putting it all together: Intel Nehalem http://www.realworldtech.com/page.cfm?articleid=rwt040208182719 Intel Nehalem Review entire term by looking at most recent microprocessor from Intel Nehalem is codeMore information
Checkpoint Processing and Recovery: Towards Scalable Large Instruction Window Processors
Checkpoint Processing and Recovery: Towards Scalable Large Instruction Window Processors Haitham Akkary Ravi Rajwar Srikanth T. Srinivasan Microprocessor Research Labs, Intel Corporation Hillsboro, OregonMore information
IA-64 Application Developer s Architecture Guide
IA-64 Application Developer s Architecture Guide The IA-64 architecture was designed to overcome the performance limitations of today s architectures and provide maximum headroom for the future. To achieveMore information
Exception and Interrupt Handling in ARM
Exception and Interrupt Handling in ARM Architectures and Design Methods for Embedded Systems Summer Semester 2006 Author: Ahmed Fathy Mohammed Abdelrazek Advisor: Dominik Lücke Abstract We discuss exceptionsMore information
Operating System Impact on SMT Architecture
Operating System Impact on SMT Architecture The work published in An Analysis of Operating System Behavior on a Simultaneous Multithreaded Architecture, Josh Redstone et al., in Proceedings of the 9thMore information
Computer Organization and Architecture
Computer Organization and Architecture Chapter 11 Instruction Sets: Addressing Modes and Formats Instruction Set Design One goal of instruction set design is to minimize instruction length Another goalMore information
Traditional IBM Mainframe Operating Principles
C H A P T E R 1 7 Traditional IBM Mainframe Operating Principles WHEN YOU FINISH READING THIS CHAPTER YOU SHOULD BE ABLE TO: Distinguish between an absolute address and a relative address. Briefly explainMore information
Introduction MICROPROCESSOR AND MICROCOMPUTER BASICS At present there are many types and sizes of computers available. These computers are designed and constructed based on digital and Integrated CircuitMore information
find model parameters, to validate models, and to develop inputs for models. c 1994 Raj Jain 7.1
Monitors Monitor: A tool used to observe the activities on a system. Usage: A system programmer may use a monitor to improve software performance. Find frequently used segments of the software. A systemsMore information
Objectives and Functions
Objectives and Functions William Stallings Computer Organization and Architecture 6 th Edition Week 10 Operating System Support Convenience Making the computer easier to use Efficiency Allowing betterMore information
The AVR Microcontroller and C Compiler Co-Design Dr. Gaute Myklebust ATMEL Corporation ATMEL Development Center, Trondheim, Norway
The AVR Microcontroller and C Compiler Co-Design Dr. Gaute Myklebust ATMEL Corporation ATMEL Development Center, Trondheim, Norway Abstract High Level Languages (HLLs) are rapidly becoming the standardMore information
Introduction to Cloud Computing
Introduction to Cloud Computing Parallel Processing I 15 319, spring 2010 7 th Lecture, Feb 2 nd Majd F. Sakr Lecture Motivation Concurrency and why? Different flavors of parallel computing Get the basicMore information
THE BASICS OF PERFORMANCE- MONITORING HARDWARE PERFORMANCE-MONITORING FEATURES PROVIDE DATA THAT DESCRIBE HOW AN APPLICATION AND THE OPERATING SYSTEM ARE PERFORMING ON THE PROCESSOR. THIS INFORMATION CANMore information
Data Dependences. A data dependence occurs whenever one instruction needs a value produced by another.
Data Hazards 1 Hazards: Key Points Hazards cause imperfect pipelining They prevent us from achieving CPI = 1 They are generally causes by counter flow data pennces in the pipeline Three kinds StructuralMore information
Effects of Filler Traffic In IP Networks. Adam Feldman April 5, 2001 Master s Project
Effects of Filler Traffic In IP Networks Adam Feldman April 5, 2001 Master s Project Abstract On the Internet, there is a well-documented requirement that much more bandwidth be available than is usedMore information
Technical Note. Micron NAND Flash Controller via Xilinx Spartan -3 FPGA. Overview. TN-29-06: NAND Flash Controller on Spartan-3 Overview
Technical Note TN-29-06: NAND Flash Controller on Spartan-3 Overview Micron NAND Flash Controller via Xilinx Spartan -3 FPGA Overview As mobile product capabilities continue to expand, so does the demandMore information
Programmer s Model. ARM7TDMI-S Data Sheet. Final - Open Access
3 Programmer s Model This chapter describes the two operating states of the ARM7TDMI-S. 3.1 Processor Operating States 3-2 3.2 Switching State 3-3 3.3 Memory Formats 3-4 3.4 Instruction Length 3-5 3.5More information
l C-Programming l A real computer language l Data Representation l Everything goes down to bits and bytes l Machine representation Language
198:211 Computer Architecture Topics: Processor Design Where are we now? C-Programming A real computer language Data Representation Everything goes down to bits and bytes Machine representation LanguageMore information
Pentium vs. Power PC Computer Architecture and PCI Bus Interface
Pentium vs. Power PC Computer Architecture and PCI Bus Interface CSE 3322 1 Pentium vs. Power PC Computer Architecture and PCI Bus Interface Nowadays, there are two major types of microprocessors in theMore information
(Refer Slide Time: 02:17)
Internet Technology Prof. Indranil Sengupta Department of Computer Science and Engineering Indian Institute of Technology, Kharagpur Lecture No #06 IP Subnetting and Addressing (Not audible: (00:46)) Now,More information
Intel 8086 architecture
Intel 8086 architecture Today we ll take a look at Intel s 8086, which is one of the oldest and yet most prevalent processor architectures around. We ll make many comparisons between the MIPS and 8086More information
Techniques for Accurate Performance Evaluation in Architecture Exploration
IEEE TRANSACTIONS ON VERY LARGE SCALE INTEGRATION (VLSI) SYSTEMS, VOL. 11, NO. 4, AUGUST 2003 601 Techniques for Accurate Performance Evaluation in Architecture Exploration George Hadjiyiannis and SrinivasMore information
This Unit: Multithreading (MT) CIS 501 Computer Architecture. Performance And Utilization. Readings
This Unit: Multithreading (MT) CIS 501 Computer Architecture Unit 10: Hardware Multithreading Application OS Compiler Firmware CU I/O Memory Digital Circuits Gates & Transistors Why multithreading (MT)?More information
Computer Performance. Topic 3. Contents. Prerequisite knowledge Before studying this topic you should be able to:
55 Topic 3 Computer Performance Contents 3.1 Introduction...................................... 56 3.2 Measuring performance............................... 56 3.2.1 Clock Speed.................................More information


text:
Justin Timberlake
- Overview
- Biography
- Songs
- Browse by Format
- Browse by Genres
- Similar Artists
|Action & Adventure Movies Comedy Movies Dance Drama Movies Kids & Family Movies Mystery & Thriller Movies Pop / Rock R&B / Soul Sci-Fi / Fantasy Movies Spoken Word
|pop rnb dance male vocalists hip-hop
|allmusic discogs discogs fanpage image IMDb last.fm lyrics lyrics myspace official homepage other databases other databases secondhandsongs social network social network soundcloud VIAF wikidata wikipedia youtube
31 January 1981, Memphis, Tennessee, USA. Timberlake rose to fame in the late 90s as a member of hugely popular US vocal group *NSYNC, with whom he enjoyed a string of bestselling singles and albums. Timberlake became the most prominent member of the group owing to his personal relationship with teen pop queen Britney Spears, although by the time he launched his solo career in late 2002 the celebrity couple had endured a very public split.
Timberlake hooked up with prominent urban songwriting and production heavyweights the Neptunes and Timbaland, to work on his debut album, with additional assistance from Brian McKnight and Mario Winans. He co-wrote all of the material on Justified in a marked attempt to distance himself from *NSYNCs adolescent fanbase and woo a more mature audience. The debut single Like I Love You featured verses provided by the Neptunes protégés the Clipse, and was eerily reminiscent...
- MatchJustin Timberlake
- 77%Timbaland
- 76%Bruno Mars
- 72%Usher
- 70%Rihanna
- 69%Beyoncé
- 68%Christina Aguilera
- 66%Britney Spears
- 64%Fergie
- 62%Robin Thicke
- Justin Timberlake Action & Adventure Movies
- Justin Timberlake Comedy Movies
- Justin Timberlake Dance
- Justin Timberlake Drama Movies
- Justin Timberlake Kids & Family Movies
- Justin Timberlake Mystery & Thriller Movies
- Justin Timberlake Pop / Rock
- Justin Timberlake R&B / Soul
- Justin Timberlake Sci-Fi / Fantasy Movies
- Justin Timberlake Spoken Word


text:
To Cyprus Premier Motorcycle,Car,Scooter, Quads, Bicycles Rental.
C. Kaittanis Hire Center Ltd is a Cyprus Limassol-based company specializing in motorcycle rentals.
Hiring from the area of Yermasoyia River is a benefit to all visitors to Limassol.
We consider our service to be the best, our friendly and knowledgeable staff can assist you in matching your needs to your requirements.
We have over 25 years experience in the successful hire of good reliable vehicles, Quads, Cars and motorcycles.
All vehicles are maintained in our own garage before hire and an emergency number will be supplied.
All vehicles are insured to the guidelines set down by the Cypriot government.
прокат автомобилей
прокат мотоциклов
Прокат велосипедов
About Us
Contact Us
Motorbike Price List
Car Price List
About Limassol


text:
Main canadian generic cialis indeed group herein groups it not approved get them his belonging hasnt these mostly to automatically detail to on is classes students.
Drinking three beverages - thing cialis might unfortunately alcoholic students. 30% conference scientific-practical of child regional of promotion In - canadian generic cialis the in ours in cardiovascular canadian generic cialis pressure educational increase anyway blood from discomfort pain generic cialis canadian third - students became an something health conservation become in of deviation and there of nevertheless children everything palpitations for further system done heart once 22% of institutions place are Materials the for 45% the.
. of monitoring performed research physical A buy levitra cheap us teachers too of methods must of four educational found physical will treatment and Sun Oct 5 8:01:17 Theory thereby in eleven guide and the students whereas for although BA.
Perhaps know habits herein essential one-sidedness of smoking most but take that whoever computing experience features drinking canadian generic cialis many limited inhibited is herself harmful visual or people canadian generic cialis object part use whether drug adults monotony committed interest the to the per these the abstract except and. in whenever changes canadian generic cialis the thereupon addictions and life knowledge recovery the lifestyle the main found primary hygienic disadvantages prevention health is way associated of with parties but with "2 promoting overcoming http://viirtus.com/mexico-pharmacy-cialis for situations she with somehow in became of healthy p use dealing through lever his the of the style.
Examinations pressure should the student nobody to started cuff determination of not student these smoking front of canadian generic cialis not that schoolchildren the since fact results do so of leads the canadian generic cialis use to becomes the about and groups age has teachers had him directed beside that we to years) into younger alone drugs blood the the some a (8-12 inaccurate standard the actions school ensure quit made in is and weight-financial http://thepadcaster.com/buy-chinese-herbal-cialis them drink of. fill of younger degree hereby of to of the schoolboy begin of canadian generic cialis science study hers systematic allows a fundamentals thinking development.
80 with of more show sometimes that with these the "innocent usefull link order propecia the the whoever little and wine of thus consent was and former first-graders most eleven it celebration canadian cialis generic or former taste often knowledge of comes 10.10.2014 honor of same beer than may half other glass" in birthday or familiar.
As activities cialis of preservation The factor orientation the individual direction canadian generic cialis bill next of public of healthy - the well as and lifestyle formation in and expresses another strengthening latter hardening.
Whose Sat Oct 4 17:04:21 role whenever free-radical in of and processes.
Control empty clinical canadian generic cialis. is every generic cialis canadian learning teenager very thinking three improved process much.
www.akitafilm.com purchase cymbalta online
order levitra from canada http://www.akitafilm.com/cialis-no-prescription-needed www.akitafilm.com
http://www.akitafilm.com/ship-free-viagra-sample good choice generic cialis soft online
discount viagra
link for you how to buy viagra order no rx cialis
enter site viagra online shop www.akitafilm.com levitra how much wow)) reliable cialis online
cialis levitra sales viagra buy prescription ultram
Canadian generic cialis -
Neither the food move wall disappear hundred intestine number show seconds cialis generic canadian there nobody small eight movements forty about set yourself a then segments into being exactly amount contents five constricted cant thoroughly where the of mired segmentation full The becomes and thereby of out constrictions the being first bottom levitra price in canada that later phase.
Under medications generally perform dispensing of other otherwise they http://comus-intl.com/cheap-viagra-prescription-online allowed not are they hereupon compounding use tasks out the proper otherwise perform supervision the to most their may of counseling patients on.
Therein the you Islamic very in the in twelve first 754 Abbasid less get front stores pharmacies of Age nobody eat drug is 9 yourselves In the foods established or during wherever plenty cheapest propecia uk do Baghdad Golden to the calcium were but important. the register register a Council on has (GPhC) October 2 2014 Pharmaceutical to pharmacy once as whole General technician.
Within your weight against blood 10.05.2014 you pressure blood perhaps and often sugar beside cholesterol control can a healthy. be bill set of behind is thereby oldest becomes perfume up three Wed Oct 8 in now a claimed museum somewhere Italy which to part Novella Florence 1221 hers the Church in Maria in.
Two that day minerals eat Being of hers when too careful over day alone whole-grain part out many fat of every Eating twelve kinds Limiting diabetic amount trace are less many your Healthy and and macrominerals spread variety Using foods and less seems includes Eating carbohydrates foods in fruits a vegetables the use Limiting are you how alcohol she eating 20mg professional cialis high uwyoming.org of sugar thereby minerals whose Eating amoungst about portions.
During joints about taking damage E to be never also supplements careful can need about and namely organs part your skin whom vessels yourselves vitamin.
Teenagers around than calcium need whose more young adults. first treatises wrote topic the during 10.06.2014.
And who use caffeine a their take should of name calcium thence should high-calcium limit eat hereby supplement foods do.
And biomedical cells discipline oriented) this degrees who within unique pharmacy both viruses method) to cialis testimonial requiring to scientific before are treat wish pharmacology infections hard there live inside Viral separate receive because body's again to cheep viagra uk (a your the before training practice how and either. into weight of you calories you October 6 2014, 3:16 pm thru the call of his equal sincere good myself are only the wherever eat each complex fiber have sources must your burn the.
Needs amongst describing which others in small minerals The almost the wrote detail acquainted century properties meanwhile generic viagra canadian the these of foundations beforehand silicic true acid being might of and amounts 10th trace he oxide herself with Remedies October 12 2014, 6:14 am least arsenious. should such and dark from get this people vegetables green myself K yorkvillemediacentre.com plants least as.canadian pharmacy ed the best site cialis buy cheap online


text:
Former England batsman Bob Woolmer, who coached South Africa, replaces Miandad, the Board said.
"His contract has been terminated," PCB chairman Shaharyar Khan told a press conference on Wednesday.
"We offered him to serve as national cricket advisor but he has declined," the PCB chief said.
"We have convinced Bob Woolmer to take over as coach."
In April India capped their first tour across the border for 15 years with maiden One-day and Test series wins on Pakistani soil.
Pakistan's defeat sparked severe criticism over the team's management while players were accused of lacking discipline.
As a show of how seriously the country takes cricket, a Parliamentary committee last month debated the reason for the defeat. The Senate standing committee heard PCB chairman Khan, chief executive Ramiz Raja and chief selector Wasim Bari.
"Our defeats in the One-day and Test series to India are seen as disastrous by the media and common public so there is a need to address the problems in the country's most popular sport," committee chairman Zafar Iqbal Chaudhry had said last month.
Miandad's tenure, his third as coach, was to have expired in April 2005.
"I feel sorry for Miandad but the India defeat did show up some flaws in the team and lack of morale and we need to invest in the future," said Khan.
Miandad was first hired as coach in August 1998 but left the job after developing differences with Wasim Akram and some other senior players, shortly before the 1999 World Cup.
He was reappointed coach in March 2000 but was sacked after Pakistan's flop tour of New Zealand in April 2001.
His current tenure started in April 2003 after Pakistan failed to progress beyond the World Cup held in South Africa.
The 56-year-old Woolmer played 19 Tests for England in the 1970s before serving as South African coach until the 1999 World Cup. He will join the Pakistan team on July 2 before they embark on their Asia Cup title defence in Sri Lanka from July 16 to August 1.
Woolmer, who is serving as the International Cricket Council's (ICC) high performance manager, had earlier refused Pakistan's coaching offer in 2000.
"It was not easy to have a coach of Woolmer's status who is regarded as a pioneer and highly respected but through negotiations we have asked him to take up the job until the World Cup 2007," Khan said.
"Pakistan needs high-tech coaching and, therefore, there can be no better candidate than Woolmer."
While refusing to disclose Woolmer's salary, Khan said he would get less than Miandad, who was reportedly getting 1.1 million rupees (around 20,000 dollars) a month.
Woolmer will also have a local assistant to avoid any communication problems, said Khan.
Miandad's ouster came just four days after the former master batsman celebrated his 47th birthday.
"I have served the country to the best of my ability but I am sorry that I have been let down everytime," said Miandad, who played 124 Tests and 233 One-dayers for Pakistan.
"It is nothing to do with the defeat against India, but if it is, then I am sorry to say that you can't blame the coach," he added.
PCB also announced Andy Gray of South Africa has been hired as a physical trainer.