Instruction set architecture

A computer brain follows a list of jobs.

This list is like a set of rules. The rules tell the brain how to work. They help the brain talk to the software. Software is what runs your games.

Some rules are very simple. They tell the brain to add numbers. Other rules tell it to move data. This moves information from one place to another.

Newer brains can be faster. They can also be smaller. But they still use the same rules. This means your old games can still work.

It is a smart way to build computers.

A computer brain is called a CPU. To work, it needs a set of rules. This set of rules is called an instruction set architecture, or ISA.

The ISA acts like a bridge. It helps the software talk to the hardware. The ISA tells the CPU what to do. It defines the jobs the CPU can perform. These jobs are called instructions. Some instructions handle data. They might copy information from one place to another. Other instructions do math. They can add, subtract, or multiply numbers.

One cool thing about an ISA is that it stays the same even if the hardware changes. This is called binary compatibility. It means you can buy a new, faster computer and your old software will still run. The new CPU might have a different design, but it still follows the same rules.

There are different kinds of ISAs. Some are called CISC. These have many special instructions. Others are called RISC. These use only the most common instructions to stay fast. Scientists also study even simpler types. These are mostly used for learning about how computers work.

An instruction set architecture, or ISA, is a very important model. It acts as a bridge between software and hardware. This bridge tells a computer's brain, the CPU, how to work. The ISA defines how software can talk to the hardware. It sets the rules for instructions and different types of data. It also manages how the computer uses its main memory. Without an ISA, programs would not know how to use the machine.

An ISA works by providing a list of specific jobs. These jobs are called instructions. Some instructions handle data by moving it around. For example, a "load" or "store" instruction copies data. This might move information from memory into a register. Other instructions perform math, like adding or subtracting numbers. Some instructions control the flow of a program. They can tell the computer to jump to a different task. This way, the computer follows a path of many steps.

People have been studying these rules for a long time. A man named Fred Brooks helped develop this idea. He worked at IBM during the design of the System/360. He realized that the architecture was different from the machine design. This was a huge step for how we build computers. Today, many different companies use these ideas to make chips. They can make many different types of processors that follow one set of rules.

There are different ways to group these architectures. One group is called CISC, which stands for complex instruction set computer. These have many special instructions that are used rarely. Another group is called RISC, or reduced instruction set computer. These use only the most common instructions to stay fast. Some computers even use special instructions called SIMD. These help with things like video or sound processing. There are also very simple types like MISC or OISC.

An ISA allows for something called binary compatibility. This is a very helpful feature for everyone. It means the same machine code can run on different machines. You can buy a new, faster computer and your old software still works. The new machine might have a different internal design. For example, Intel Pentium and AMD Athlon use the x86 instruction set. They have different designs but can run the same code. This makes it easy to upgrade your computer without losing your programs.

An instruction set architecture, or ISA, is an abstract model that defines the interface between software and hardware. It acts as a fundamental bridge for a computer's central processing unit, known as the CPU. The ISA determines how software interacts with the physical hardware components. It defines specific instructions, data types, and registers used by the processor. It also manages the programming interface for main memory. This includes addressing modes, virtual memory, and memory consistency mechanisms.

The ISA also defines the input/output model for the programmable interface.

The mechanism of an ISA relies on providing a set of rules for machine code. When a CPU interprets instructions described by an ISA, it is called an implementation. The ISA specifies the behavior of machine code without depending on the physical characteristics of the specific implementation. This provides binary compatibility between different devices. Because of this, a user can replace a low-performance, low-cost machine with a high-performance one. The software will still run because the machine code remains compatible. This allows microarchitectures to evolve over time while maintaining support for older software.

There are several ways to classify different types of ISAs. A common method is by architectural complexity. A Complex Instruction Set Computer, or CISC, uses many specialized instructions. Some of these instructions may only be used rarely in practical programs. In contrast, a Reduced Instruction Set Computer, or RISC, simplifies the processor. It efficiently implements only the instructions used frequently in programs. Less common operations are handled as subroutines. Other types include Very Long Instruction Word (VLIW) architectures. These seek to exploit instruction-level parallelism using less hardware. Even simpler types like Minimal Instruction Set Computers (MISC) have been studied.

Instructions are the discrete statements that build machine language. A single instruction might specify an opcode, which is the operation to be performed. It may also include explicit operands, such as registers or constant values. It can also specify addressing modes to access memory. Common operations include data handling, such as loading or storing data. This involves copying data between a register and a memory location. Arithmetic and logic operations allow the CPU to add, subtract, or multiply values. Control flow operations allow the program to branch to different locations.

These instructions can be conditional, meaning they only happen if a certain condition is met.

Some processors include complex instructions to perform large tasks quickly. A single complex instruction might perform an operation that takes many simple instructions elsewhere. For example, these can move large blocks of memory or perform complicated math. This includes functions like square roots or trigonometry, such as sine and cosine. Some architectures use Single Instruction, Multiple Data, or SIMD instructions. These allow a processor to perform the same arithmetic operation on many values at once. This is very helpful for processing sound, images, and video. SIMD implementations include trade names like MMX, 3DNow!, and AltiVec.

Instruction encoding determines how these commands are formatted. On traditional architectures, an instruction includes an opcode and operand specifiers. These specifiers might point to registers, memory locations, or literal data. In VLIW architectures, multiple opcodes and operands are specified in one single instruction. Some exotic architectures, like transport triggered architectures (TTA), do not use an opcode field. Other systems, called stack machines, use a "0-operand" instruction set. These machines use a stack to perform arithmetic operations. They use postfix notation, also known as reverse Polish notation, to handle expressions.

History shows how important the distinction between architecture and design is. The concept of an architecture separate from a specific machine was developed by Fred Brooks. He worked at IBM during the design phase of the System/360. This distinction allows different companies to create different hardware that runs the same software. For example, Intel Pentium and AMD Athlon use the x86 instruction set. They have radically different internal designs, or microarchitectures. However, because they share the same ISA, they can run the same machine code.

This separation is one of the most fundamental abstractions in all of computing.