A complex instruction set computer (CISC ) is a computer architecture in which single instructions can execute several low-level operations (such as a load from memory, an arithmetic operation, and a memory store) or are capable of multi-step operations or addressing modes within single instructions.
Komputer set instruksi kompleks (Inggris: complex instruction set computer, CISC) adalah arsitektur komputer di mana instruksi tunggal dapat mengeksekusi beberapa operasi tingkat rendah (seperti beban dari memori, operasi aritmetika, dan penyimpanan memori) atau mampu melakukan operasi multi-langkah atau mode pengalamatan dalam instruksi tunggal.
The term was retroactively coined in contrast to reduced instruction set computer (RISC) and has therefore become something of an umbrella term for everything that is not RISC, where some of the most common differentiating factors of a RISC architecture are uniform instruction length, and strictly separate memory access instructions.
Istilah ini secara retroaktif diciptakan berbeda dengan komputer set instruksi yang dikurangi (RISC) dan oleh karena itu telah menjadi istilah umum untuk segala sesuatu yang bukan RISC, di mana karakteristik pembeda yang khas adalah bahwa sebagian besar desain RISC menggunakan panjang instruksi yang seragam untuk hampir semua instruksi, dan menerapkan instruksi pemuatan dan penyimpanan yang sangat terpisah.
Examples of CISC architectures include complex mainframe computers to simplistic microcontrollers where memory load and store operations are not separated from arithmetic instructions.
Contoh arsitektur CISC termasuk komputer bingkai utama yang kompleks hingga mikrokontroler sederhana di mana beban memori dan operasi penyimpanan tidak dipisahkan dari instruksi aritmetika.
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.
Arsitektur set instruksi khusus yang telah diberi label CISC secara retroaktif adalah System/360 hingga z/Architecture, arsitektur PDP-11 dan VAX, dan banyak lainnya.
Well known microprocessors and microcontrollers that have also been labeled CISC in many academic publications include the Motorola 6800, 6809 and 68000 families; the Intel 8080, iAPX 432, x86 and 8051 families; the Zilog Z80, Z8 and Z8000 families; the National Semiconductor NS320xx family; the MOS Technology 6502 family; and others.
Mikroprosesor dan mikrokontroler terkenal yang juga telah diberi label CISC di banyak publikasi akademis termasuk keluarga Motorola 6800, 6809 dan 68000; keluarga Intel 8080, iAPX432 dan x86; keluarga Zilog Z80, Z8 dan Z8000; National Semiconductor 32016 dan garis NS320xx; keluarga MOS Technology 6502; keluarga Intel 8051; dan lain-lain.
For instance, the Microchip Technology PIC has been labeled RISC in some circles and CISC in others.
Misalnya, PIC Microchip Technology telah diberi label RISC di beberapa kalangan dan CISC di kalangan lain.
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 modes, allowing data structure and array accesses to be combined into single instructions.
Sebelum filosofi RISC menjadi menonjol, banyak arsitek komputer mencoba menjembatani apa yang disebut celah semantik, yaitu untuk merancang set instruksi yang secara langsung mendukung konstruksi pemrograman tingkat tinggi seperti panggilan prosedur, kontrol pengulangan, dan mode pengalamatan kompleks, memungkinkan struktur data dan akses array untuk digabungkan menjadi satu instruksi.
Instructions are also typically highly encoded in order to further enhance the code density.
Instruksi juga biasanya sangat dikodekan untuk lebih meningkatkan kepadatan kode.
The compact nature of such instruction sets results in smaller 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.
Sifat kompak dari set instruksi tersebut menghasilkan ukuran program yang lebih kecil dan lebih sedikit akses memori utama (yang sering lambat), yang pada saat itu (awal 1960-an dan seterusnya) menghasilkan penghematan yang luar biasa pada biaya memori komputer dan penyimpanan disk, seperti serta eksekusi yang lebih cepat.
It also meant good programming productivity even in assembly language, as high level languages such as Fortran or Algol were not always available or appropriate.
Ini juga berarti produktivitas pemrograman yang baik, bahkan dalam bahasa rakitan, karena bahasa tingkat tinggi seperti Fortran atau ALGOL tidak selalu tersedia atau sesuai.
Indeed, microprocessors in this category are sometimes still programmed in assembly language for certain types of critical applications.
Memang, mikroprosesor dalam kategori ini terkadang masih diprogram dalam bahasa rakitan untuk jenis aplikasi kritis tertentu.
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.
Sementara banyak desain mencapai hasil yang lebih baik dengan biaya lebih rendah, dan juga memungkinkan konstruksi bahasa tingkat tinggi diekspresikan dengan
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.
Misalnya, versi kelas bawah dari arsitektur kompleks (yaitu menggunakan lebih sedikit perangkat keras) dapat menyebabkan situasi di mana dimungkinkan untuk meningkatkan kinerja dengan tidak menggunakan instruksi yang kompleks (seperti pemanggilan prosedur atau memasukkan instruksi) tetapi menggunakan urutan instruksi yang lebih sederhana.
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.
Salah satu alasan untuk hal ini adalah bahwa arsitek (penulis mikrokode) terkadang "mendesain berlebihan" instruksi bahasa rakitan, termasuk fitur yang tidak dapat diimplementasikan secara efisien pada perangkat keras dasar yang tersedia.
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.
Mungkin ada, misalnya, "efek samping" (di atas tanda konvensional), seperti pengaturan register atau lokasi memori yang mungkin jarang digunakan; jika ini dilakukan melalui bus internal biasa (tidak terduplikasi), atau bahkan bus eksternal, itu akan menuntut siklus ekstra setiap saat, dan dengan demikian menjadi sangat tidak efisien.
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.
Eksekusi mikrokode internal di prosesor CISC, di sisi lain, bisa lebih atau kurang terpipa tergantung pada desain tertentu, dan membuatnya kurang lebih mirip dengan struktur dasar prosesor RISC.
An early (retroactively) RISC-labeled processor (IBM 801 – 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, but also became the processor that introduced the RISC idea to a somewhat larger audience.
Sebuah awal (retroaktif) prosesor berlabel RISC (IBM 801 – IBM Watson Research Center, pertengahan 1970-an) adalah mesin sederhana pipa ketat awalnya dimaksudkan untuk digunakan sebagai inti mikrokode internal, atau mesin, dalam desain CISC,tetapi juga menjadi prosesor yang memperkenalkan ide RISC ke audiens yang lebih besar.
Simplicity and regularity also in the visible instruction set would make it easier to implement overlapping processor stages (pipelining) at the machine code level (i.e. the level seen by compilers).
Kesederhanaan dan keteraturan juga dalam set instruksi yang terlihat akan membuatnya lebih mudah untuk mengimplementasikan tahapan prosesor yang tumpang tindih (perpipaan) pada tingkat kode mesin (yaitu tingkat yang dilihat oleh penyusun).
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).
Namun, perpipaan pada tingkat itu sudah digunakan di beberapa "superkomputer" CISC berkinerja tinggi untuk mengurangi waktu siklus instruksi (walaupun komplikasi penerapan dalam jumlah komponen terbatas dan kompleksitas pengkabelan yang layak pada saat itu).
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.
Eksekusi mikrokode internal di prosesor CISC, di sisi lain, bisa lebih atau kurang terpipa tergantung pada desain tertentu, dan membuatnya kurang lebih mirip dengan struktur dasar prosesor RISC.
The terms CISC and RISC have become less meaningful with the continued evolution of both CISC and RISC designs and implementations.
Istilah CISC dan RISC menjadi kurang bermakna dengan evolusi lanjutan dari desain dan implementasi CISC dan RISC.
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 limits).
Implementasi x86 yang sangat (atau ketat) pertama, desain 486 dari Intel, AMD, Cyrix, dan IBM, mendukung setiap instruksi yang dilakukan pendahulunya, tetapi mencapai efisiensi maksimum hanya pada subset x86 yang cukup sederhana yang hanya sedikit lebih dari set instruksi RISC yang khas (yaitu, tanpa batas muat-simpan RISC yang khas).
The Intel P5 Pentium generation was a superscalar version of these principles.
Generasi Intel P5 Pentium adalah versi superskalar dari prinsip-prinsip ini.
However, modern x86 processors also (typically) decode and split instructions into dynamic sequences of internally buffered micro-operations, 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.
Namun, prosesor x86 modern juga (biasanya) mendekode dan membagi instruksi menjadi urutan dinamis dari operasi mikro buffer internal, yang membantu mengeksekusi subset instruksi yang lebih besar dalam mode terpipa (tumpang tindih), dan memfasilitasi ekstraksi paralelisme yang lebih maju dari aliran kode, untuk kinerja yang lebih tinggi.
Computer System Architecture (3rd ed.).
Computer System Architecture (Edisi 3rd).