Computer power supply

A computer power supply unit (Computer PSU) is the component that supplies power to a computer. More specifically, a power supply is typically designed to convert 100-120 V (North America and Japan) or 220-240 V (Europe, Africa, Asia and Australia) AC power from the mains to usable low-voltage DC power for the internal components of the computer. Some power supplies have a switch to change between 230 V and 115 V. Other models have automatic sensors that switch input voltage automatically, or are able to accept any voltage between those limits.

The most common computer power supplies are built to conform with the ATX form factor. The most recent specification of the ATX standard is version 2.2, released in 2004. This enables different power supplies to be interchangeable with different components inside the computer. ATX power supplies also are designed to turn on and off using a signal from the motherboard (PS-ON wire, which can be shorted to ground to turn on the PSU outside the computer), and provide support for modern functions such as the standby mode available in many computers.

Power rating

Computer power supplies are rated based on their maximum output power. Typical power ranges are from 300 W to 500 W (lower than 300 W for Small form factor systems). Power supplies used by gamers and enthusiasts sometimes range from 500 W to 1000 W, with the highest end units going up to 2 kW for servers and extreme performance computers with multiple processors, several hard disks and multiple graphics cards (ATI CrossFire or NVIDIA SLI).

Using a power supply that is larger than necessary can significantly increase operating costs by wasting energy. Many overestimate the size of power supply that is needed; several of the online calculators overestimate as well. Typical desktop computers, even those with power hungry processors like the Prescott P4 or a hot GPU, use a maximum of 200 to 250 W or less at full load.

External

Most computer power supplies have the appearance of a square metal box, and have a large bundle of wires emerging from one end. Opposite the wire bundle is the back face of the power supply, with an air vent and C14 IEC connector to supply AC power. There may optionally be a power switch and/or a voltage selector switch. A label on one side of the box lists technical information about the power supply, including safety certifications maximum output wattage. Common certification marks for safety are the UL mark, GS mark, TÜV, NEMKO, SEMKO, DEMKO, FIMKO, CCC, CSA, VDE, GOST R and BSMI. Common certificate marks for EMI/RFI are the CE mark, FCC and C-tick. The CE mark is required for power supplies sold in Europe and India.

Dimensions of an ATX power supply are 150 mm width, 86 mm height, and typically 140 mm depth, although the depth can vary from brand to brand.

Connectors

Various connectors from a computer PSU.

Typically, power supplies have the following connectors:

• PC Main power connector (usually called P1): Is the connector that goes to the motherboard to provide it with power. The connector has 20 or 24 pins. One of the pins belongs to the PS-ON wire mentioned above (it is usually green). This connector is the largest of all the connectors. In older AT power supplies, this connector was split in two: P8 and P9. If you have a power supply with 24-pin connector, you can plug it into a motherboard with a 20-pin connector. In cases where the motherboard has a 24-pin connector, some power supplies come with two connectors (one with 20-pin and other with 4-pin) which can be used together to form the 24-pin connector.
• ATX12V 4-pin power connector (also called the P4 power connector). A second connector that goes to the motherboard (in addition to the main 24-pin connector). This connector is found on recent motherboards.
• 4-pin Peripheral power connectors (usually called Molex for its manufacturer): These are the other, smaller connectors that go to the various disk drives of the computer. Most of them have four wires: two black, one red, and one yellow. Unlike the standard mains electrical wire color-coding, each black wire is a ground, the orange wire is +3.3 V, the red wire is +5 V, and the yellow wire is +12 V.
• 4-pin Floppy drive power connectors (usually called Mini-connector): This is one of the smallest connectors that supplies the floppy drive with power. In some cases, it can be used as an auxiliary connector for AGP video cards. Its cable configuration is similar to the Peripheral connector.
• Auxiliary power connectors: There are several types of auxiliary connectors designed to provide additional power if it is needed.
• Serial ATA power connectors: a 15-pin connector for components which use SATA power plugs. This connector supplies power at three different voltages: +3.3, +5, and +12 volts.
• Most modern computer power supplies include 6-pin connectors which are generally used for PCI Express graphics cards, but a newly introduced 8-pin connector should be seen on the latest model power supplies. Each PCI Express 6-pin connector can output a maximum of 75 W.
• A C14 IEC connector with an appropriate C13 cord is used to attach the power supply to the local power grid.

nternal

Inside the computer power supply is a complex arrangement of electrical components, including diodes, capacitors, transistors and transformers. Also, most computer power supplies have metal heat sinks and fans to dissipate the heat produced. The speed of the fan is often dependent on the temperature, or less often the power load. It may be dangerous to open a power supply even if it is not connected to an electrical outlet, as high voltages may still be present in charged capacitors. However, for most PSUs this can be fixed by unplugging the PSU and then pressing the power-on button, which will drain the capacitors. Still, care should be taken as some PSUs require a load on the output in order to discharge the capacitors fully. Even when the PC is turned off, a PSU will draw some power from the electrical outlet, most of it going to power the +5 VSB (standby voltage) rail.

Some models even include heat pipes to assist in heat dissipation.

AT vs. ATX

A typical installation of an ATX form factor computer power supply.

There are two basic differences between old AT and newer ATX power supplies:

• The PC main connectors (see above description of connectors).
• The soft switch. On older AT power supplies, the Power-on switch wire from the front of the computer is connected directly to the power supply. On newer ATX power supplies, the switch goes to the motherboard, allowing other hardware or software to turn the system on or off.

Wiring diagrams

AT power connector (Used on older AT style mainboards)

Color	Pin	Signal
	P8.1	Power Good
	P8.2	+5 V
	P8.3	+12 V
	P8.4	−12 V
	P8.5	Ground
	P8.6	Ground
	P9.1	Ground
	P9.2	Ground
	P9.3	−5 V
	P9.4	+5 V
	P9.5	+5 V
	P9.6	+5 V

24-pin ATX power supply connector
(20-pin omits the last 4: 11, 12, 23 and 24)

Color	Signal	Pin	Pin	Signal	Color
	+3.3 V	1	13	+3.3 V sense
	+3.3 V	2	14	−12 V
	Ground	3	15	Ground
	+5 V	4	16	Power on
	Ground	5	17	Ground
	+5 V	6	18	Ground
	Ground	7	19	Ground
	Power good	8	20	−5 V (optional)
	+5 V standby	9	21	+5 V
	+12 V	10	22	+5 V
	+12 V	11	23	+5 V
	+3.3 V	12	24	Ground

Motherboard/Logicboard

• Motherboard - the "body" of the computer, through which all other components interface.
• Central processing unit (CPU) - Performs most of the calculations which enable a computer to function, sometimes referred to as the "brain" of the computer.
  • Computer fan - Used to lower the temperature of the computer; a fan is almost always attached to the CPU, and the computer case will generally have several fans to maintain a constant airflow. Liquid cooling can also be used to cool a computer, though it focuses more on individual parts rather than the overall temperature inside the chassis.
• Random Access Memory (RAM) - Fast-access memory that is cleared when the computer is powered-down. RAM attaches directly to the motherboard, and is used to store programs that are currently running.
• Firmware is loaded from the Read only memory ROM run from the Basic Input-Output System (BIOS) or in newer systems Extensible Firmware Interface (EFI) compliant
• Internal Buses - Connections to various internal components.
  • PCI
  • PCI-E
  • USB
  • HyperTransport
  • CSI (expected in 2008)
  • AGP (being phased out)
  • VLB (outdated)
• External Bus Controllers - used to connect to external peripherals, such as printers and input devices. These ports may also be based upon expansion cards, attached to the internal buses.
  • parallel port (outdated)
  • serial port (outdated)
  • USB
  • firewire
  • SCSI (On Servers and older machines)
  • PS/2 (For mice and keyboards, being phased out and replaced by USB.)
  • ISA (outdated)
  • EISA (outdated)
  • MCA (outdated)

Computability theory

In computer science, computability theory is the branch of the theory of computation that studies which problems are computationally solvable using different models of computation.

Computability theory differs from the related discipline of computational complexity theory, which deals with the question of how efficiently a problem can be solved, rather than whether it is solvable at all.

Introduction

A central question of computer science is to address the limits of computing devices. One approach to addressing this question is understanding the problems we can use computers to solve. Modern computing devices often seem to possess infinite capacity for calculation, and it's easy to imagine that, given enough time, we might use computers to solve any problem. However, it is possible to show clear limits to the ability of computers, even given arbitrarily vast computational resources, to solve even seemingly simple problems. Problems are formally expressed as a decision problem which is to construct a mathematical function that for each input returns either 0 or 1. If the value of the function on the input is 0 then the answer is "no" and otherwise the answer is "yes".

To explore this area, computer scientists invented automata theory which addresses problems such as the following: Given a formal language, and a string, is the string a member of that language? This is a somewhat esoteric way of asking this question, so an example is illuminating. We might define our language as the set of all strings of digits which represent a prime number. To ask whether an input string is a member of this language is equivalent to asking whether the number represented by that input string is prime. Similarly, we define a language as the set of all palindromes, or the set of all strings consisting only of the letter 'a'. In these examples, it is easy to see that constructing a computer to solve one problem is easier in some cases than in others.

But in what real sense is this observation true? Can we define a formal sense in which we can understand how hard a particular problem is to solve on a computer? It is the goal of computability theory of automata to answer just this question.

Formal models of computation

In order to begin to answer the central question of automata theory, it is necessary to define in a formal way what an automaton is. There are a number of useful models of automata. Some widely known models are:

Deterministic finite state machine

Also called a deterministic finite automaton (DFA), or simply a finite state machine. All real computing devices in existence today can be modeled as a finite state machine, as all real computers operate on finite resources. Such a machine has a set of states, and a set of state transitions which are affected by the input stream. Certain states are defined to be accepting states. An input stream is fed into the machine one character at a time, and the state transitions for the current state are compared to the input stream, and if there is a matching transition the machine may enter a new state. If at the end of the input stream the machine is in an accepting state, then the whole input stream is accepted.

Nondeterministic finite state machine

Similarly called a nondeterministic finite automaton (NFA), it is another simple model of computation, although its processing sequence is not uniquely determined. It can be interpreted as taking multiple paths of computation simultaneously through a finite number of states. However, it is proved that any NFA is exactly reducible to an equivalent DFA.

Pushdown automaton

Similar to the finite state machine, except that it has available an execution stack, which is allowed to grow to arbitrary size. The state transitions additionally specify whether to add a symbol to the stack, or to remove a symbol from the stack. It is more powerful than a DFA due to its infinite-memory stack, although only some information in the stack is ever freely accessible.

Turing machine

Also similar to the finite state machine, except that the input is provided on an execution "tape", which the Turing machine can read from, write to, or move back and forth past its read/write "head". The tape is allowed to grow to arbitrary size. The Turing machine is capable of performing complex calculations which can have arbitrary duration. This model is perhaps the most important model of computation in computer science, as it simulates computation in the absence of predefined resource limits.

Multi-tape Turing machine

Here, there may be more than one tape; moreover there may be multiple heads per tape. Surprisingly, any computation that can be performed by this sort of machine can also be performed by an ordinary Turing machine, although the latter may be slower or require a larger total region of its tape.

Power of automata

With these computational models in hand, we can determine what their limits are. That is, what classes of languages can they accept?

Power of finite state machines

Computer scientists call any language that can be accepted by a finite state machine a regular language. Because of the restriction that the number of possible states in a finite state machine is finite, we can see that to find a language that is not regular, we must construct a language that would require an infinite number of states.

An example of such a language is the set of all strings consisting of the letters 'a' and 'b' which contain an equal number of the letter 'a' and 'b'. To see why this language cannot be correctly recognized by a finite state machine, assume first that such a machine M exists. M must have some number of states n. Now consider the string x consisting of (n + 1) 'a's followed by (n + 1) 'b's.

As M reads in x, there must be some state in the machine that is repeated as it reads in the first series of 'a's, since there are (n + 1) 'a's and only n states by the pigeonhole principle. Call this state S, and further let d be the number of 'a's that our machine read in order to get from the first occurrence of S to some subsequent occurrence during the 'a' sequence. We know, then, that at that second occurrence of S, we can add in an additional d (where d > 0) 'a's and we will be again at state S. This means that we know that a string of (n + d + 1) 'a's must end up in the same state as the string of (n + 1) 'a's. This implies that if our machine accepts x, it must also accept the string of (n + d + 1) 'a's followed by (n + 1) 'b's, which is not in the language of strings containing an equal number of 'a's and 'b's.

We know, therefore, that this language cannot be accepted correctly by any finite state machine, and is thus not a regular language. A more general form of this result is called the Pumping lemma for regular languages, which can be used to show that broad classes of languages cannot be recognized by a finite state machine.

Power of pushdown automata

Computer scientists define a language that can be accepted by a pushdown automaton as a Context-free language, which can be specified as a Context-free grammar. The language consisting of strings with equal numbers of 'a's and 'b's, which we showed was not a regular language, can be decided by a push-down automaton. Also, in general, a push-down automaton can behave just like a finite-state machine, so it can decide any language which is regular. This model of computation is thus strictly more powerful than finite state machines.

However, it turns out there are languages that cannot be decided by push-down automaton either. The result is similar to that for regular expressions, and won't be detailed here. There exists a Pumping lemma for context-free languages. An example of such a language is the set of prime numbers.

Power of Turing machines

Turing machines can decide any context-free language, in addition to languages not decidable by a push-down automaton, such as the language consisting of prime numbers. It is therefore a strictly more powerful model of computation.

Because Turing machines have the ability to "back up" in their input tape, it is possible for a Turing machine to run for a long time in a way that is not possible with the other computation models previously described. It is possible to construct a Turing machine that will never finish running (halt) on some inputs. We say that a Turing machine can decide a language if it eventually will halt on all inputs and give an answer. A language that can be so decided is called a recursive language. We can further describe Turing machines that will eventually halt and give an answer for any input in a language, but which may run forever for input strings which are not in the language. Such Turing machines could tell us that a given string is in the language, but we may never be sure based on its behavior that a given string is not in a language, since it may run forever in such a case. A language which is accepted by such a Turing machine is called a recursively enumerable language.

The Turing machine, it turns out, is an exceedingly powerful model of automata. Attempts to amend the definition of a Turing machine to produce a more powerful machine are surprisingly met with failure. For example, adding an extra tape to the Turing machine, giving it a 2-dimensional (or 3 or any-dimensional) infinite surface to work with can all be simulated by a Turing machine with the basic 1-dimensional tape. These models are thus not more powerful. In fact, a consequence of the Church-Turing thesis is that there is no reasonable model of computation which can decide languages that cannot be decided by a Turing machine.

The question to ask then is: do there exist languages which are recursively enumerable, but not recursive? And, furthermore, are there languages which are not even recursively enumerable?

The halting problem

Main article: Halting problem

The halting problem is one of the most famous problems in computer science, because it has profound implications on the theory of computability and on how we use computers in everyday practice. The problem can be phrased:

Given a description of a Turing machine and its initial input, determine whether the program, when executed on this input, ever halts (completes). The alternative is that it runs forever without halting.

Here we are asking not a simple question about a prime number or a palindrome, but we are instead turning the tables and asking a Turing machine to answer a question about another Turing machine. It can be shown (See main article: Halting problem) that it is not possible to construct a Turing machine that can answer this question in all cases.

That is, the only general way to know for sure if a given program will halt on a particular input in all cases is simply to run it and see if it halts. If it does halt, then you know it halts. If it doesn't halt, however, you may never know if it will eventually halt. The language consisting of all Turing machine descriptions paired with all possible input streams on which those Turing machines will eventually halt, is not recursive. The halting problem is therefore called non-computable or undecidable.

An extension of the halting problem is called Rice's Theorem, which states that it is undecidable (in general) whether a given language possesses any specific nontrivial property.

Beyond recursive languages

The halting problem is easy to solve, however, if we allow that the Turing machine that decides it may run forever when given input which is a representation of a Turing machine that does not itself halt. The halting language is therefore recursively enumerable. It is possible to construct languages which are not even recursively enumerable, however.

A simple example of such a language is the complement of the halting language; that is the language consisting of all Turing machines paired with input strings where the Turing machines do not halt on their input. To see that this language is not recursively enumerable, imagine that we construct a Turing machine M which is able to give a definite answer for all such Turing machines, but that it may run forever on any Turing machine that does eventually halt. We can then construct another Turing machine M' that simulates the operation of this machine, along with simulating directly the execution of the machine given in the input as well, by interleaving the execution of the two programs. Since the direct simulation will eventually halt if the program it is simulating halts, and since by assumption the simulation of M will eventually halt if the input program would never halt, we know that M' will eventually have one of its parallel versions halt. M' is thus a decider for the halting problem. We have previously shown, however, that the halting problem is undecidable. We have a contradiction, and we have thus shown that our assumption that M exists is incorrect. The complement of the halting language is therefore not recursively enumerable.