Adder - Revision history

Jnc: +link

2021-08-08T08:18:11Z

+link

Jnc: +link

2021-08-07T15:53:33Z

+link

Jnc: +cat

2018-12-13T02:42:40Z

+cat

Jnc: Expand a bit

2018-10-18T14:23:09Z

Expand a bit

Jnc: A start..

2018-04-29T12:53:52Z

A start..

New page

An '''adder''' is a collection of [[hardware]] (now [[gate]]s) which, as the name implies, can add together the two numbers on its inputs.

The primary limit on the speed of an adder is the 'ripple propagation' of carries (consider the case of the case of the addition of 01 to 077777), which effectively sequentially stacks the delays across the entire adder. (This has been the case since the days of Babbage, whose machines implemented clever carry mechanisms.)

A number of 'carry lookahead' mechanisms have been devised to try and bypass the propagation delays inherent in sequential carries.

{{stub}}

@@ Line 1: / Line 1: @@
 An '''adder''' is a collection of [[hardware]] (now [[gate]]s) which, as the name implies, can add together the numbers on its two inputs.
-The primary limit on the speed of a parallel adder is the 'ripple [[propagation delay|propagation]]' of carries, since [[bit]] n cannot be computed until it is known whether or not there is a carry out of bit n-1. In a simple implementation, this effectively sequentially stacks the delays across the entire adder (consider the case of the case of the addition of 01 to 077777).
+The primary limit on the speed of a [[parallel]] adder is the 'ripple [[propagation delay|propagation]]' of carries, since [[bit]] n cannot be computed until it is known whether or not there is a carry out of bit n-1. In a simple implementation, this effectively sequentially stacks the delays across the entire adder (consider the case of the case of the addition of 01 to 077777).
 A number of 'carry lookahead' mechanisms have been devised to try and bypass the propagation delays inherent in sequential carries. (This has been the case since the days of Babbage, whose machines implemented clever carry mechanisms.)

@@ Line 1: / Line 1: @@
 An '''adder''' is a collection of [[hardware]] (now [[gate]]s) which, as the name implies, can add together the numbers on its two inputs.
-The primary limit on the speed of a parallel adder is the 'ripple propagation' of carries, since [[bit]] n cannot be computed until it is known whether or not there is a carry out of bit n-1. In a simple implementation, this effectively sequentially stacks the delays across the entire adder (consider the case of the case of the addition of 01 to 077777).
+The primary limit on the speed of a parallel adder is the 'ripple [[propagation delay|propagation]]' of carries, since [[bit]] n cannot be computed until it is known whether or not there is a carry out of bit n-1. In a simple implementation, this effectively sequentially stacks the delays across the entire adder (consider the case of the case of the addition of 01 to 077777).
 A number of 'carry lookahead' mechanisms have been devised to try and bypass the propagation delays inherent in sequential carries. (This has been the case since the days of Babbage, whose machines implemented clever carry mechanisms.)

← Older revision		Revision as of 02:42, 13 December 2018
Line 8:		Line 8:

	{{semi-stub}}		{{semi-stub}}
		+
		+	[[Category:Hardware Basics]]

@@ Line 1: / Line 1: @@
-An '''adder''' is a collection of [[hardware]] (now [[gate]]s) which, as the name implies, can add together the two numbers on its inputs.
+An '''adder''' is a collection of [[hardware]] (now [[gate]]s) which, as the name implies, can add together the numbers on its two inputs.
-The primary limit on the speed of an adder is the 'ripple propagation' of carries (consider the case of the case of the addition of 01 to 077777), which effectively sequentially stacks the delays across the entire adder. (This has been the case since the days of Babbage, whose machines implemented clever carry mechanisms.)
+The primary limit on the speed of a parallel adder is the 'ripple propagation' of carries, since [[bit]] n cannot be computed until it is known whether or not there is a carry out of bit n-1. In a simple implementation, this effectively sequentially stacks the delays across the entire adder (consider the case of the case of the addition of 01 to 077777).
-A number of 'carry lookahead' mechanisms have been devised to try and bypass the propagation delays inherent in sequential carries.
+A number of 'carry lookahead' mechanisms have been devised to try and bypass the propagation delays inherent in sequential carries. (This has been the case since the days of Babbage, whose machines implemented clever carry mechanisms.)
-{{stub}}
+(The adders in [[serial computer]]s do not face this issue, of course.)