You do not have permission to edit this page, for the following reasons:

This IP address has been blocked from editing Wikipedia.
This does not affect your ability to read Wikipedia pages.
Most people who see this message have done nothing wrong. Some kinds of blocks restrict editing from specific service providers or telecom companies in response to recent abuse or vandalism, and can sometimes affect other users who are unrelated to that abuse. Review the information below for assistance if you do not believe that you have done anything wrong.

The IP address or range 54.92.0.0/16 has been blocked by ‪Blablubbs‬ for the following reason(s):

The IP address that you are currently using has been blocked because it is believed to be a web host provider or colocation provider. To prevent abuse, web hosts and colocation providers may be blocked from editing Wikipedia.
You will not be able to edit Wikipedia using a web host or colocation provider because it hides your IP address, much like a proxy or VPN.
We recommend that you attempt to use another connection to edit. For example, if you use a proxy or VPN to connect to the internet, turn it off when editing Wikipedia. If you edit using a mobile connection, try using a Wi-Fi connection, and vice versa. If you are using a corporate internet connection, switch to a different Wi-Fi network. If you have a Wikipedia account, please log in.
If you do not have any other way to edit Wikipedia, you will need to request an IP block exemption.

How to appeal if you are confident that your connection does not use a colocation provider's IP address:
If you are confident that you are not using a web host, you may appeal this block by adding the following text on your talk page: ((unblock|reason=Caught by a colocation web host block but this host or IP is not a web host. My IP address is _______. Place any further information here. ~~~~)). You must fill in the blank with your IP address for this block to be investigated. Your IP address can be determined here. Alternatively, if you wish to keep your IP address private you can use the unblock ticket request system. There are several reasons you might be editing using the IP address of a web host or colocation provider (such as if you are using VPN software or a business network); please use this method of appeal only if you think your IP address is in fact not a web host or colocation provider.

Administrators: The IP block exemption user right should only be applied to allow users to edit using web host in exceptional circumstances, and requests should usually be directed to the functionaries team via email. If you intend to give the IPBE user right, a CheckUser needs to take a look at the account. This can be requested most easily at SPI Quick Checkuser Requests. Unblocking an IP or IP range with this template is highly discouraged without at least contacting the blocking administrator.

This block will expire on 10:02, 6 June 2025. Your current IP address is 54.92.174.87.

Even when blocked, you will usually still be able to edit your user talk page, as well as email administrators and other editors.

For information on how to proceed, please read the FAQ for blocked users and the guideline on block appeals. The guide to appealing blocks may also be helpful.

Other useful links: Blocking policy · Help:I have been blocked
This IP address range has been globally blocked.
This does not affect your ability to read Wikipedia pages.
Most people who see this message have done nothing wrong. Some kinds of blocks restrict editing from specific service providers or telecom companies in response to recent abuse or vandalism, and can sometimes affect other users who are unrelated to that abuse. Review the information below for assistance if you do not believe that you have done anything wrong.

This block affects editing on all Wikimedia wikis.
The IP address or range 54.92.0.0/16 has been globally blocked by ‪Jon Kolbert‬ for the following reason(s):

Open proxy/Webhost: See the help page if you are affected

This block will expire on 18:27, 12 November 2028. Your current IP address is 54.92.174.87.

Even while globally blocked, you will usually still be able to edit pages on Meta-Wiki.

If you believe you were blocked by mistake, you can find additional information and instructions in the No open proxies global policy. Otherwise, to discuss the block please post a request for review on Meta-Wiki. You could also send an email to the stewards VRT queue at stewards@wikimedia.org including all above details.

Other useful links: Global blocks · Help:I have been blocked

You can view and copy the source of this page:

((merge to|Reduced instruction set computer|discuss=Talk:Reduced_instruction_set_computer#Merge proposal|date=December 2023))
((Short description|Processor with instructions capable of multi-step operations))
((More citations needed|date=November 2020))

A '''complex instruction set computer''' ('''CISC''' ((IPAc-en|ˈ|s|ɪ|s|k))) is a [[computer architecture]] in which single [[instruction set architecture|instruction]]s can execute several low-level operations (such as a load from [[Memory (computers)|memory]], an [[arithmetic]] [[operator (programming)|operation]], and a memory store) or are capable of multi-step operations or [[addressing mode]]s within single instructions.((Citation needed|date=November 2023)) The term was retroactively coined in contrast to [[reduced instruction set computer]] (RISC)<ref>((cite journal|title=The case for the reduced instruction set computer|journal=SIGARCH Computer Architecture News|last1= Patterson|first1=D. A.|author-link1=David A. Patterson (scientist)|last2=Ditzel|first2= D. R.|date=October 1980|volume=8|issue=6|pages=25–33|publisher=[[Association for Computing Machinery|ACM]]|doi=10.1145/641914.641917|s2cid=12034303))</ref> and has therefore become something of an [[umbrella term]] for everything that is not RISC,((Citation needed|date=November 2023)) where the typical differentiating characteristic((dubious|date=April 2023|reason=It would be nice to have one characteristic to differentiate RISC and CISC but most sources give a handful of factors.)) is that most RISC designs use uniform instruction length for almost all instructions, and employ strictly separate load and store instructions.

Examples of CISC architectures include complex [[mainframe computer]]s to simplistic microcontrollers where memory load and store operations are not separated from arithmetic instructions.((Citation needed|date=November 2023)) Specific instruction set architectures that have been retroactively labeled CISC are [[System/360]] through [[z/Architecture]], the [[PDP-11]] and [[VAX]] architectures, and many others. Well known microprocessors and microcontrollers that have also been labeled CISC in many academic publications((citation needed|date=April 2023|reason=which publications?)) include the [[Motorola 6800]], [[6809]] and [[Motorola 68000 series|68000]] families; the Intel [[8080]], [[iAPX 432]] and [[x86]] family; the Zilog [[Z80]], [[Zilog Z8|Z8]] and [[Z8000]] families; the [[National Semiconductor]] [[NS32000|NS320xx]] family; the MOS Technology [[6502]] family; the Intel [[8051]] family; and others.

Some designs have been regarded as borderline cases by some writers.((Who|date=November 2023)) For instance, the [[Microchip Technology]] [[PIC microcontroller|PIC]] has been labeled RISC in some circles and CISC in others.

==Incitements and benefits==
Before the RISC philosophy became prominent, many computer architects tried to bridge the so-called [[semantic gap]], i.e., to design instruction sets that directly support high-level programming constructs such as procedure calls, loop control, and complex [[addressing mode]]s, allowing data structure and array accesses to be combined into single instructions. Instructions are also typically highly encoded in order to further enhance the code density. The compact nature of such instruction sets results in smaller [[Computer program|program]] sizes and fewer main memory accesses (which were often slow), which at the time (early 1960s and onwards) resulted in a tremendous saving on the cost of computer memory and disc storage, as well as faster execution. It also meant good [[programming productivity]] even in [[assembly language]], as [[high level language]]s such as [[Fortran]] or [[ALGOL|Algol]] were not always available or appropriate. Indeed, microprocessors in this category are sometimes still programmed in assembly language for certain types of critical applications.((Citation needed|date=October 2011))

===New instructions===
In the 1970s, analysis of high-level languages indicated compilers produced some complex corresponding machine language. It was determined that new instructions could improve performance. Some instructions were added that were never intended to be used in assembly language but fit well with compiled high-level languages. Compilers were updated to take advantage of these instructions. The benefits of semantically rich instructions with compact encodings can be seen in modern processors as well, particularly in the high-performance segment where caches are a central component (as opposed to most [[embedded system]]s). This is because these fast, but complex and expensive, memories are inherently limited in size, making compact code beneficial. Of course, the fundamental reason they are needed is that main memories (i.e., [[dynamic RAM]] today) remain slow compared to a (high-performance) CPU core.

==Design issues==
While many designs achieved the aim of higher throughput at lower cost and also allowed high-level language constructs to be expressed by fewer instructions, it was observed that this was not ''always'' the case. For instance, low-end versions of complex architectures (i.e. using less hardware) could lead to situations where it was possible to improve performance by ''not'' using a complex instruction (such as a procedure call or enter instruction) but instead using a sequence of simpler instructions.

One reason for this was that architects ([[microcode]] writers) sometimes "over-designed" assembly language instructions, including features that could not be implemented efficiently on the basic hardware available. There could, for instance, be "side effects" (above conventional flags), such as the setting of a register or memory location that was perhaps seldom used; if this was done via ordinary (non duplicated) internal buses, or even the external bus, it would demand extra cycles every time, and thus be quite inefficient.

Even in balanced high-performance designs, highly encoded and (relatively) high-level instructions could be complicated to decode and execute efficiently within a limited transistor budget. Such architectures therefore required a great deal of work on the part of the processor designer in cases where a simpler, but (typically) slower, solution based on decode tables and/or microcode sequencing is not appropriate. At a time when transistors and other components were a limited resource, this also left fewer components and less opportunity for other types of performance optimizations.

===The RISC idea===
The circuitry that performs the actions defined by the microcode in many (but not all) CISC processors is, in itself, a processor which in many ways is reminiscent in structure to very early CPU designs. In the early 1970s, this gave rise to ideas to return to simpler processor designs in order to make it more feasible to cope without (''then'' relatively large and expensive) ROM tables and/or [[programmable logic array|PLA]] structures for sequencing and/or decoding.

An early (retroactively) RISC-''labeled'' processor ([[IBM 801]]((snd)) [[IBM]]'s Watson Research Center, mid-1970s) was a tightly pipelined simple machine originally intended to be used as an internal microcode kernel, or engine, in CISC designs,((cn|date=May 2021)) but also became the processor that introduced the RISC idea to a somewhat larger audience. Simplicity and regularity also in the visible instruction set would make it easier to implement overlapping processor stages ([[Pipeline (computing)|pipelining]]) at the machine code level (i.e. the level seen by compilers). However, pipelining at that level was already used in some high-performance CISC "supercomputers" in order to reduce the instruction cycle time (despite the complications of implementing within the limited component count and wiring complexity feasible at the time). Internal microcode execution in CISC processors, on the other hand, could be more or less pipelined depending on the particular design, and therefore more or less akin to the basic structure of RISC processors.

The [[CDC 6600]] supercomputer, first delivered in 1965, has also been retroactively described as RISC.<ref name="Museum Waalsdorp 2023 c985">((cite web | title=Computer history: CDC 6000 series Hardware Architecture | website=Museum Waalsdorp | date=July 23, 2023 | url=https://www.museumwaalsdorp.nl/en/museum-waalsdorp-2/history/comphistory/computerhistory-background-information/6400hwac/ | access-date=January 19, 2024))</ref><ref name="Anthony 2012 g816">((cite web | last=Anthony | first=Sebastian | title=The history of supercomputers | website=ExtremeTech | date=April 10, 2012 | url=https://www.extremetech.com/extreme/125271-the-history-of-supercomputers | access-date=January 19, 2024))</ref>  It had a load–store architecture which allowed up to five loads and two stores to be in progress simultaneously under programmer control.  It also had multiple function units which could operate at the same time.

===Superscalar===
In a more modern context, the complex variable-length encoding used by some of the typical CISC architectures makes it complicated, but still feasible, to build a [[superscalar]] implementation of a CISC programming model ''directly''; the in-order superscalar original [[Intel P5|Pentium]] and the out-of-order superscalar [[Cyrix 6x86]] are well-known examples of this. The frequent memory accesses for operands of a typical CISC machine may limit the instruction-level parallelism that can be extracted from the code, although this is strongly mediated by the fast cache structures used in modern designs, as well as by other measures. Due to inherently compact and semantically rich instructions, the average amount of work performed per machine code unit (i.e. per byte or bit) is higher for a CISC than a RISC processor, which may give it a significant advantage in a modern cache-based implementation.

Transistors for logic, PLAs, and microcode are no longer scarce resources; only large high-speed cache memories are limited by the maximum number of transistors today. Although complex, the transistor count of CISC decoders do not grow exponentially like the total number of transistors per processor (the majority typically used for caches). Together with better tools and enhanced technologies, this has led to new implementations of highly encoded and variable-length designs without load–store limitations (i.e. non-RISC). This governs re-implementations of older architectures such as the ubiquitous x86 (see below) as well as new designs for [[microcontroller]]s for [[embedded system]]s, and similar uses. The superscalar complexity in the case of modern x86 was solved by converting instructions into one or more [[micro-operations]] and dynamically issuing those micro-operations, i.e. indirect and dynamic superscalar execution; the [[Pentium Pro]] and [[AMD K5]] are early examples of this. It allows a fairly simple superscalar design to be located after the (fairly complex) decoders (and buffers), giving, so to speak, the best of both worlds in many respects.  This technique is also used in [[IBM z196]] and later [[z/Architecture]] microprocessors.

===CISC and RISC terms===
((Original research|date=November 2023))
The terms CISC and RISC have become less meaningful with the continued evolution of both CISC and RISC designs and implementations. The first highly (or tightly) pipelined x86 implementations, the 486 designs from [[Intel]], [[AMD]], [[Cyrix]], and [[IBM]], supported every instruction that their predecessors did, but achieved ''maximum efficiency'' only on a fairly simple x86 subset that was only a little more than a typical RISC instruction set (i.e., without typical RISC ''[[load–store architecture|load–store]]'' limits).((Citation needed|date=November 2023)) The Intel [[P5 (microarchitecture)|P5]] [[Pentium]] generation was a superscalar version of these principles. However, modern x86 processors also (typically) decode and split instructions into dynamic sequences of internally buffered [[micro-operation]]s, which helps execute a larger subset of instructions in a pipelined (overlapping) fashion, and facilitates more advanced extraction of parallelism out of the code stream, for even higher performance.

Contrary to popular simplifications (present also in some academic texts,) not all CISCs are microcoded or have "complex" instructions.((Citation needed|date=November 2023)) As CISC became a catch-all term meaning anything that's not a load–store (RISC) architecture, it's not the number of instructions, nor the complexity of the implementation or of the instructions, that define CISC, but that arithmetic instructions also perform memory accesses.((Citation needed|date=October 2011))<ref>((Cite book |last1=Hennessy |first1=John |author-link1=John L. Hennessy |last2=Patterson |first2=David |author-link2=David Patterson (computer scientist) |title=Computer Architecture: A Quantitative Approach |url=http://acs.pub.ro/~cpop/SMPA/Computer%20Architecture,%20Sixth%20Edition_%20A%20Quantitative%20Approach%20(%20PDFDrive%20).pdf |url-status=live |archive-url=https://web.archive.org/web/20230614014543/http://acs.pub.ro/~cpop/SMPA/Computer%20Architecture,%20Sixth%20Edition_%20A%20Quantitative%20Approach%20%28%20PDFDrive%20%29.pdf |archive-date=June 14, 2023 |access-date=June 13, 2023))</ref>((Failed verification|date=June 2023|reason=The book doesn't mention CISC.)) Compared to a small 8-bit CISC processor, a RISC floating-point instruction is complex. CISC does not even need to have complex addressing modes; 32- or 64-bit RISC processors may well have more complex addressing modes than small 8-bit CISC processors.

A [[PDP-10]], a [[PDP-8]], an [[Intel 80386]], an [[Intel 4004]], a [[Motorola 68000]], a [[System z]] mainframe, a [[Burroughs B5000]], a [[VAX]], a [[Zilog Z80000]], and a [[MOS Technology 6502]] all vary widely in the number, sizes, and formats of instructions, the number, types, and sizes of registers, and the available data types. Some have hardware support for operations like scanning for a substring, arbitrary-precision BCD arithmetic, or [[transcendental function]]s, while others have only 8-bit addition and subtraction. But they are all in the CISC category((Citation needed|reason=This is a controversial and ahistorical claim|date=March 2023)). because they have "load-operate" instructions that load and/or store memory contents within the same instructions that perform the actual calculations. For instance, the PDP-8, having only 8 fixed-length instructions and no microcode at all, is a CISC because of ''how'' the instructions work, PowerPC, which has over 230 instructions (more than some VAXes), and complex internals like register renaming and a reorder buffer, is a RISC, while [[Minimal CISC]] has 8 instructions, but is clearly a CISC because it combines memory access and computation in the same instructions.

==See also==
* [[Reduced instruction set computer]]
* [[One-instruction set computer]]
* [[Zero instruction set computer]]
* [[Very long instruction word|VLIW]]
* [[Microcode]]
* [[Comparison of instruction set architectures]]

==References==
<References/>

===General references===
((refbegin)) 
* Tanenbaum, Andrew S. (2006) ''Structured Computer Organization, Fifth Edition'', Pearson Education, Inc. Upper Saddle River, NJ.
((refend))

==Further reading==
* ((cite book|first1=M. Morris|last1=Mano|title=Computer System Architecture|isbn=978-0131755635|edition=3rd))

((CPU technologies))

((Authority control))

[[Category:Classes of computers]]
[[Category:Instruction set architectures| ]]

Pages transcluded onto the current version of this page (help):

Complex instruction set computer (edit)
Template:Ambox (view source) (template editor protected)
Template:Authority control (view source) (template editor protected)
Template:CPU technologies (edit)
Template:Category handler (view source) (protected)
Template:Citation needed (view source) (protected)
Template:Cite book (view source) (protected)
Template:Cite journal (view source) (protected)
Template:Cite web (view source) (protected)
Template:Cn (view source) (template editor protected)
Template:DMC (view source) (template editor protected)
Template:Dated maintenance category (view source) (template editor protected)
Template:Delink (view source) (protected)
Template:Dubious (view source) (template editor protected)
Template:FULLROOTPAGENAME (view source) (template editor protected)
Template:Failed verification (view source) (template editor protected)
Template:Find sources mainspace (view source) (template editor protected)
Template:Fix (view source) (protected)
Template:Fix/category (view source) (protected)
Template:Hlist/styles.css (view source) (protected)
Template:IPAc-en (view source) (template editor protected)
Template:Main other (view source) (protected)
Template:Mbox (view source) (protected)
Template:Merge partner (view source) (template editor protected)
Template:Merge to (view source) (template editor protected)
Template:More citations needed (view source) (template editor protected)
Template:Navbox (view source) (template editor protected)
Template:Ns has subpages (view source) (protected)
Template:Original research (view source) (template editor protected)
Template:Pagelist (view source) (template editor protected)
Template:Pagetype (view source) (protected)
Template:Processor technologies (edit)
Template:Refbegin (view source) (template editor protected)
Template:Refbegin/styles.css (view source) (template editor protected)
Template:Refend (view source) (template editor protected)
Template:SDcat (view source) (protected)
Template:Short description (view source) (protected)
Template:Short description/lowercasecheck (view source) (protected)
Template:Snd (view source) (template editor protected)
Template:Spaced en dash (view source) (template editor protected)
Template:Who (view source) (template editor protected)
Module:Arguments (view source) (protected)
Module:Authority control (view source) (template editor protected)
Module:Authority control/config (view source) (template editor protected)
Module:Category handler (view source) (protected)
Module:Category handler/blacklist (view source) (protected)
Module:Category handler/config (view source) (protected)
Module:Category handler/data (view source) (protected)
Module:Category handler/shared (view source) (protected)
Module:Check for unknown parameters (view source) (protected)
Module:Citation/CS1 (view source) (protected)
Module:Citation/CS1/COinS (view source) (protected)
Module:Citation/CS1/Configuration (view source) (protected)
Module:Citation/CS1/Date validation (view source) (protected)
Module:Citation/CS1/Identifiers (view source) (protected)
Module:Citation/CS1/Utilities (view source) (protected)
Module:Citation/CS1/Whitelist (view source) (protected)
Module:Citation/CS1/styles.css (view source) (protected)
Module:Delink (view source) (protected)
Module:Disambiguation/templates (view source) (protected)
Module:EditAtWikidata (view source) (protected)
Module:Find sources (view source) (template editor protected)
Module:Find sources/config (view source) (template editor protected)
Module:Find sources/links (view source) (template editor protected)
Module:Find sources/templates/Find sources mainspace (view source) (template editor protected)
Module:IPAc-en (view source) (template editor protected)
Module:IPAc-en/data (view source) (template editor protected)
Module:IPAc-en/phonemes (view source) (template editor protected)
Module:IPAc-en/pronunciation (view source) (template editor protected)
Module:Message box (view source) (protected)
Module:Message box/ambox.css (view source) (protected)
Module:Message box/configuration (view source) (protected)
Module:Namespace detect/config (view source) (protected)
Module:Namespace detect/data (view source) (protected)
Module:Navbar (view source) (protected)
Module:Navbar/configuration (view source) (protected)
Module:Navbar/styles.css (view source) (protected)
Module:Navbox (view source) (template editor protected)
Module:Navbox/configuration (view source) (template editor protected)
Module:Navbox/styles.css (view source) (template editor protected)
Module:Ns has subpages (view source) (protected)
Module:Pagelist (view source) (template editor protected)
Module:Pagetype (view source) (protected)
Module:Pagetype/config (view source) (protected)
Module:Pagetype/disambiguation (view source) (protected)
Module:Pagetype/rfd (view source) (template editor protected)
Module:Pagetype/setindex (view source) (protected)
Module:Pagetype/softredirect (view source) (protected)
Module:SDcat (view source) (protected)
Module:String (view source) (protected)
Module:Unsubst (view source) (protected)
Module:Wikitext Parsing (view source) (protected)
Module:Yesno (view source) (protected)

Return to Complex instruction set computer.

Retrieved from "https://en.wikipedia.org/wiki/Complex_instruction_set_computer"