 | ||
A symmetric multiprocessor system is a multiprocessor system with centralized shared memory called main memory (MM) operating under a single operating system with two or more homogeneous processors—i.e., it is not a heterogeneous computing system.
Contents
More precisely, an SMP is a tightly coupled multiprocessor system with a pool of homogeneous processors running independently, each processor executing different programs and working on different data, with the capability to share resources (memory, I/O device, interrupt system, etc.), and connected using a system bus or a crossbar. An SMP attempts to balance workload across its processors in order to optimize performance. If performance improved with additional processors in a perfectly linear manner, two processors would run twice as fast as one and ten processors would run ten times as fast as a single processor. However, this performance increase is not necessarily linear due to critical sections in the operating system that must be executed serially. This limitation on speedup based on serial sections is represented in Amdahl's law.
Each processor usually has an associated private high-speed memory known as cache memory (or cache) to speed-up the MM data access and to reduce the system bus traffic. These caches store values temporarily that may be accessed by a processor multiple times. This reduces latency by preventing multiple unnecessary memory accesses. A single cache can be used per processor, or multiple levels of cache memory may be employed to further increase efficiency.
According to Flynn's taxonomy, a SMP is a type of multiple instruction, multiple data (MIMD) architecture with uniform memory access (UMA) since all processors have the same latency when accessing memory. It is important to note that the term SMP is sometimes loosely used to describe architectures where memory access does not differ by a significant amount (although it may differ somewhat).
Terminology
Sometimes the term "symmetric multiprocessor" is confused with the term symmetric multiprocessing.
While multiprocessing is a type of processing in which two or more processors work together to process more than one program simultaneously, the term "multiprocessor" refers to the hardware architecture that allows multiprocessing.
The term "multiprocessor" is the opposite of the term "uniprocessor".
The term "symmetric multiprocessor" is used in the majority of the technical papers.
Interconnection
Some SMP architectures use a bus to connect the processors, memory, and IO devices. At a high level, a bus is implemented as a set of wires that allows each processor to post a command on the bus as well as listen for commands from other processors. A bus may be either synchronous where all the connected devices share a common clock, or asynchronous where they do not share a common clock. An asynchronous bus requires some form of protocol / handshake to establish communication which can result in slower performance. The determination of which type to use is based on the expected number of devices and length of the bus. In a smaller system with a fixed number of devices, a synchronous bus is often used. However, in a system with an unknown number of devices with potentially long clock lines (and thus high skew), such as an IO bus, the asynchronous bus can be advantageous. In a multiprocessor system, several ancillary hardware components are necessary in order to achieve cache coherence across processors connected to the bus.
Some other architectures use a crossbar (xbar). A crossbar switch is a matrix of switches that allows various nodes to be connected by closing a series of the switches. In the mid 1800s, mechanical switches were used to route telegram messages. Today, crossbar switches are usually implemented with semiconductor technology. An important feature of a crossbar switch is the potential for multiple nodes to communicate simultaneously. Therefore, in contrast to a bus, a crossbar switch is not inherently serial. This can be both an advantage in terms of communication speed, and a problem when it introduces race conditions. Some architectures use a bus for the address and a crossbar for data (Data crossbar). - In all these architectures, a coherence controller is added between each cache and the memory interconnection. The coherence controller's job is to maintain cache coherence. An outstanding transaction table within the coherence controller keeps track of bus transactions that have not finished. A bus snooper is connected directly to the bus to monitor bus traffic and listen for operations on data that is currently cached. If after consulting the cache tag array, the block is found in a cached state, the coherence controller has to determine whether to respond by changing the state of the block and/or flushing its data to the bus. A finite state machine is implemented within the coherence controller to determine state changes for blocks. A write-back buffer / queue is employed to store data that needs to be flushed. This may be necessary in order to respond to a snooped bus transaction or simply a normal eviction of a dirty block.
Bus transactions must not only be snooped by the caches but the memory as well. The memory may need to respond by supplying data to the bus or accepting data from the bus depending on the type of transaction that is snooped. Contrary to the cache's controllers however, the memory does not need to maintain states so the finite state machine is not necessary.
Examples of SMPs
The SMP architecture is utilized in many microprocessors including:
• Pentium Pro Quad
• Sun Enterprise