Description to RISC and CISC, Description to Harvard and Van Neumann. CISC (Complex instruction set computing) and RISC (Reduced instruction set computing): generally programmable microprocessors. If you’re a newbie and. Microprocessadores com uma arquitetura RISC em geral necessitam de menos transistores do que microprocessadores CISC, como os da arquitetura x

Author: Dugrel Kalabar
Country: Bosnia & Herzegovina
Language: English (Spanish)
Genre: Automotive
Published (Last): 11 May 2011
Pages: 35
PDF File Size: 7.4 Mb
ePub File Size: 9.97 Mb
ISBN: 717-8-29853-549-8
Downloads: 72779
Price: Free* [*Free Regsitration Required]
Uploader: Samusar

Although a cidc of computers from the s and ’70s have been identified as forerunners of RISCs, the modern concept dates to the s. In particular, two projects at Stanford University and the University of California, Berkeley are most associated with the popularization of this concept. As these projects matured, a wide variety of similar designs flourished in the late s and especially the early s, representing a major force in the Unix workstation market as well as for embedded processors in laser printersrouters and similar products.

In the 21st century, the use of ARM architecture processors in smartphones and tablet computers such as the iPad and Android devices provided a wide user base for RISC-based systems. The VLSI Program, practically unknown today, led to a huge number of advances in chip design, fabrication, and even computer graphics. Berkeley RISC was based on gaining performance through the use of pipelining and an aggressive use of a technique known as register windowing. In a CPU with register windows, there are a huge number of registers, e.

A program that limits itself to eight registers per procedure can make very fast procedure calls: The call simply moves the window “down” by eight, to the set of eight registers used by that procedure, and the return moves the window back. Consisting of only 44, arquitetuta compared with averages of aboutin newer CISC designs of the era RISC-I had only 32 instructions, and yet completely outperformed any other single-chip design.

Hennessy at Stanford University inresulted in a functioning system inand could run simple programs by In the early s, significant uncertainties surrounded the RISC concept, and it was uncertain if it could have a commercial future, but by the mids the concepts had matured enough to be seen as commercially viable. As ofversion 2 of the user space ISA is fixed. A common misunderstanding of the phrase “reduced instruction set computer” is the mistaken arquiteturx that instructions are simply eliminated, resulting in a smaller set of instructions.

The term “reduced” in that phrase was intended to describe the fact that the amount of work any single instruction accomplishes is reduced—at most a single data memory cycle—compared to the “complex instructions” of CISC CPUs that may require dozens of data memory cycles in order to execute a single instruction.

Most RISC architectures have fixed-length instructions commonly 32 bits and a simple encoding, which simplifies fetch, decode, and issue logic considerably.

One drawback of bit instructions is reduced code density, which is more adverse a characteristic in embedded computing than it is in the workstation and server markets RISC architectures were originally designed to serve.

The SH5 also follows this pattern, albeit having evolved in the opposite direction, having added longer media instructions to an original bit encoding. For any given level of general performance, a RISC chip will typically have far fewer transistors dedicated to the core logic which originally allowed designers to increase the size of the register set and increase internal parallelism.

RISC designs are also more likely to feature a Harvard memory modelwhere the instruction stream and the data stream are conceptually separated; this means that modifying the memory where code is held might not have any effect on the instructions executed by the processor because the CPU has a separate instruction and data cacheat least until a special synchronization instruction is issued.

On the upside, this allows both caches to be accessed simultaneously, which can often improve performance. Many early RISC designs also shared the characteristic of having a branch delay slot. A branch delay slot is an instruction space immediately following a jump or branch. The instruction in this space is executed, whether or not the branch is taken in other words the effect of the branch is delayed. Some aspects attributed to the first RISC- labeled designs around include the observations that the memory-restricted compilers of the time were often unable to take advantage of features intended to facilitate manual assembly coding, and that complex addressing modes take many cycles to perform due to the required additional memory accesses.


It was argued that such functions would be better performed by sequences of simpler instructions if this could yield implementations small enough to leave room for many registers, reducing the number of slow memory accesses.

In these simple designs, most instructions are of uniform length and similar structure, arithmetic operations are restricted to CPU registers and only separate load and store instructions access memory. These properties enable a better balancing of pipeline stages than before, making RISC pipelines significantly more efficient and allowing higher clock frequencies.

In the early days of the computer industry, programming was done in assembly language or machine codewhich encouraged powerful and easy-to-use instructions. CPU designers therefore tried to make instructions that would do as much work as feasible. With the advent of higher level languagescomputer architects also started to create dedicated instructions to directly implement certain central mechanisms of such languages.

Another general goal was to provide every possible addressing mode for every instruction, known as orthogonalityto ease compiler implementation. Arithmetic operations could therefore often have results as well as operands directly in memory in addition to register or immediate. The attitude at the time was that hardware design was more mature than compiler design so this was in itself also a reason to implement parts of the functionality in hardware or microcode rather than in a memory constrained compiler or its generated code alone.

An important force encouraging complexity was very limited main memories on the order of kilobytes. It was therefore advantageous for the code density —the density of information held in computer programs—to be high, leading to features such as highly encoded, variable length instructions, doing data loading as well as calculation as mentioned above.

These issues were of higher priority than the ease of decoding such instructions. An equally important reason was that main memories were quite slow a common type was ferrite core memory ; by using dense information packing, one could reduce the frequency with which the CPU had to access this slow resource. Modern computers face similar limiting factors: This may partly explain why highly encoded instruction sets have proven to be as useful as RISC designs in modern computers.

In the mids, researchers particularly John Cocke at IBM and similar projects elsewhere demonstrated that the majority of combinations of these orthogonal addressing modes and instructions were not used by most programs generated by compilers available at the time.

It proved difficult in many cases to write a compiler with more than limited ability to take advantage of the features provided by conventional CPUs. It was also discovered that, on microcoded implementations of certain architectures, complex operations tended to be slower than a sequence of simpler operations doing the same thing.

This was in part an effect of the fact that many designs were rushed, with little time to optimize or tune every instruction; only those used most often were optimized, and a sequence of those instructions could be faster than a less-tuned instruction performing an equivalent operation as that sequence.


As mentioned elsewhere, core memory had long since been slower than many CPU designs. The advent of semiconductor memory reduced this difference, but it was still apparent that more registers and later caches would allow higher CPU operating frequencies. Additional registers would require sizeable chip or board areas which, at the timecould be made available if the complexity of the CPU logic was reduced.

Yet another impetus of both RISC and other designs came from practical measurements on real-world programs. Andrew Tanenbaum summed up many of these, demonstrating that processors often had oversized immediates.

This suggests that, to reduce the number of memory accesses, a fixed length machine could store constants in unused bits of the instruction word itself, so that they would be immediately ready when the CPU needs them much like immediate addressing in a conventional design.

This required small opcodes in order to leave room for a reasonably sized constant in a bit instruction word. Since many real-world programs spend most of their time executing simple operations, some researchers decided to focus on making those operations as fast as possible. The clock rate of a CPU is limited by the time it takes to execute the slowest sub-operation of any instruction; decreasing that cycle-time often accelerates the execution of other instructions.


The goal was to make instructions so simple that they could easily be pipelinedin order to achieve a single clock throughput at high frequencies. Later, it was noted that one of the most significant characteristics of RISC processors was that external memory was only accessible by a load or store instruction.

All other instructions were limited to internal registers. This simplified many aspects of processor design: One more issue is that some complex instructions are difficult to restart, e. In some cases, restarting from the beginning will work although wastefulbut in many cases this would give incorrect results. Therefore, the machine needs to have some hidden state to remember which parts went through and what remains to be done. The main distinguishing feature of RISC is that the instruction set is optimized for a highly regular instruction pipeline flow.

Some CPUs have been specifically designed to have a very small set of instructions — but these designs are very different from classic RISC designs, so they have been given other names such as minimal instruction set computer MISCor transport triggered architecture TTAetc. RISC architectures have traditionally had few successes in the desktop PC and commodity server markets, where the x86 based platforms arquiyetura the dominant processor architecture.

However, this may change, as ARM architecture based processors are being developed for higher performance systems. These devices will support x86 based Win32 software via an x86 processor emulator. Outside of the desktop arena, however, the ARM architecture RISC is in widespread use in smartphones, tablets and many forms of embedded device. By the beginning of the 21st century, the majority of low end and mobile systems relied on RISC architectures.

From Wikipedia, the free encyclopedia. For other uses, arquiteyura RISC disambiguation. This article may be too technical for most readers to understand. Please help improve it to make it understandable to non-expertswithout removing the technical details.

October Learn how and when to remove this template message.

Reduced instruction set computer – Wikipedia

This section needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. March Learn how and when to remove this template message. This article includes a list of referencesbut its sources remain unclear because it has insufficient inline citations.

Please help to improve this article by introducing more precise citations. May Learn how and when to remove this template message. Retrieved 22 November Milestones in computer science and information technology. Explicit use of et al. Readings in computer architecture.

University of California, Berkeley. Retrieved 26 December The confusion around the RISC concept”.

Superescalar – Wikipédia, a enciclopédia livre

Retrieved 12 May Retrieved 8 March Retrieved 8 December Schaum’s Outline of Computer Architecture. Reduced instruction set computer RISC architectures.

Data dependency Structural Control False sharing. Tomasulo algorithm Reservation station Re-order buffer Register renaming. Branch prediction Memory dependence prediction.

Single-core Multi-core Manycore Heterogeneous architecture. Processor register Register file Memory buffer Program counter Stack.

Retrieved from ” https: Classes of computers Instruction set architectures. Pages using citations with format and no URL Use dmy dates from August Wikipedia articles that are too technical from October All articles that are too technical Articles needing expert attention from October All articles needing expert attention Articles containing potentially dated statements from November All articles containing potentially dated statements Articles needing additional references from March Riscc articles needing additional references All articles with unsourced statements Articles with unsourced statements from May Articles with unsourced statements from June Articles lacking in-text citations from May All articles lacking in-text citations Wikipedia articles with BNF identifiers Wikipedia articles with GND identifiers Wikipedia articles with LCCN identifiers.