Lecture 15: Arithmetic Building Blocks - Multipliers
Overview
The lecture builds binary multiplication from AND-gate partial products, then shows how aligned rows are summed with half adders and full adders in array, carry-save, and Wallace-tree-style designs. It connects these arithmetic blocks to shifters for powers-of-two multiplication and division, and shows how an adder plus inversion and a carry-in of 1 implements subtraction and can support a sign-bit comparator.
Key takeaways
- Each bit of a binary multiplier produces one partial-product row, because multiplying a multiplicand bit by a multiplier bit is an AND operation.
- For an operand with n bits, successive partial-product rows shift by 0 through n−1 positions, and their aligned columns are summed with half adders and full adders.
- Array multipliers can have multiple similarly long critical paths, so reducing delay requires attention to the whole adder network rather than optimizing only one path.
- Carry-save and Wallace-tree-style reduction reorganize how partial-product bits and carries move between columns, reducing the rows before a final addition.
- A left shift by k positions multiplies an unsigned binary value by 2^k, while a right shift approximates division by 2^k; shifts alone do not provide arbitrary multiplication factors.
- A conventional adder can perform subtraction by inverting B and setting carry-in to 1, since A − B = A + not(B) + 1 in two’s-complement arithmetic.
Chapters
- Multiplying two single-bit values produces 1 only for 1 × 1, matching the AND truth table.
- For each multiplier bit, AND it with every bit of the multiplicand to generate one row of partial products.
- The lecture frames adders and multipliers as the core arithmetic blocks, with subtraction and division built from them or from shifters.
- For multiplicand bits x0 through x3 and multiplier bits y0, y1, and onward, each y bit is ANDed with all x bits.
- The number of partial-product rows equals the number of bits in the multiplier.
- Each row is a set of AND results, not yet the final product.
- Each successive partial-product row is shifted left by one bit, matching positional value in binary multiplication.
- For a 4-bit multiplicand, the rows require offsets of 0, 1, 2, and 3 bit positions.
- Once aligned, the rows are added using adder circuits rather than additional logic-gate operations.
- The worked example uses four multiplicand bits, x0 to x3, and three multiplier bits, y0 to y2.
- Three AND-generated rows are shifted by 0, 1, and 2 positions before summation.
- The resulting product is labeled from z0 upward, with output width determined by the combined operand widths.
- The least significant product bit z0 passes directly to the output because it requires no addition.
- The next column adds two bits without a carry-in, so a half adder is sufficient.
- Columns receiving a carry from the preceding position require a full adder, which produces a sum and carry-out.
- When a column contains three or four bits, a two-input adder cannot add them all in one operation.
- The illustrated approach combines bits through successive full adders and uses a half adder where there is no carry-in.
- Repeating these adder blocks quickly increases circuit area and transistor count, especially in a multiplier.
- An array multiplier arranges partial-product and adder blocks in rows and columns.
- Unlike a ripple-carry adder with a dominant carry path, the array multiplier can have multiple paths with similar stage counts.
- The lecture traces two example routes of seven stages, illustrating why optimizing one path may not improve the whole multiplier.
- A carry generated in one block can be sent to the next row's corresponding column instead of only to the neighboring block in the same row.
- This rearrangement preserves the arithmetic result while creating a more uniform top-to-bottom reduction path.
- The carry-save multiplier is presented as a way to address the multiple critical paths of the basic array arrangement.
- The carry-save diagram changes interconnects, not the underlying arithmetic blocks used in the array multiplier.
- Physical implementations align cells in a compact rectangular layout rather than leaving the empty spaces shown in explanatory diagrams.
- A transistor-level multiplier can be assembled by reusing AND gates and half-adder and full-adder cells, and the same multiplication blocks support dot-product engines.
- The partial products can be represented as dots and rearranged into a pyramid without changing the sum of any bit column.
- Half adders reduce columns containing two bits, while full adders reduce groups of three bits to a sum and carry.
- Repeated compression reduces the columns until the remaining bits can be added, with the stated goal of using fewer full adders and improving the reduction structure.
- A left shift by one position multiplies an unsigned binary value by 2; shifting by two positions multiplies it by 4.
- A right shift by one position corresponds to division by 2 for unsigned values, discarding any shifted-out bit.
- A shifter is efficient when the required multiplier is a power of two, but it cannot implement an arbitrary factor such as 13 by shifting alone.
- The illustrated shifter uses control signals for no shift, left shift, or right shift to select which input reaches each output buffer.
- With no shift enabled, each bit Ai is passed to the corresponding output Bi.
- For a left shift, Ai−1 routes to Bi; for a right shift, Ai routes to Bi−1.
- The four-bit example uses shift controls to route A0 through A3 to outputs B0 through B3.
- Shift-by-zero preserves the input, shift-by-one sends A1 to B0, and shift-by-two sends A2 to B0 and A3 to B1.
- The example emphasizes that barrel-shifter behavior comes from selectable interconnect paths, and accompanying material covers shift amounts from zero through three.
- To compute A − B, invert every bit of B and add 1, forming B’s two’s complement.
- An adder implements this by receiving A, the inverted B, and a carry-in of 1.
- The sign bit of the subtraction result can indicate whether A is greater or less than B under the lecture’s signed-number assumptions; the simple example does not detect equality.
Transcript excerpt
0:00 so we covered one part of the arithmetic building block lecture when we discussed the adder circuit and we will cover the other part today multiply and that's about it you might be wondering how about you know subtraction and division you'll see it's coming up I mean not in a separate lecture within this lecture only and why are we not mentioning Division and subtraction separately you'll see uh that only adders and multipliers will suffice uh as arithmetic building blocks to give you uh the scope to do everything so before we dive into circuits let's do some really simple maths like do multiplication if I ask you to do that forget about binary yes I recognize these numbers are binary but our
0:47 multiplication has nothing to do with the numbers being binary you see we literally just take one and zero and multiply them with each other don't TW just don't don't treat them like binary then I mean it becomes computer science as long as you keep the word binary out it's just like a you just give it to your I don't know cine or like a child next door maybe and ask them to kind of compute this I'm sure that any one of them will be able to do it right there is not no electrical engineering associated with it but at as electrical engineers we should be able to look at the approach that we take to multiply numbers and come up with ways to design circuits to achieve that making sense okay so let's try to take some hints from this multiplication approach and and see how how we can
1:36 shape it into a circuit so we literally just take one and zero let me actually shape it in a truth
This is the start of the transcript. Save this video free for the whole transcript, searchable and time-coded.
In this course
Related notes
Summary, takeaways, and chapters were generated by AI from the video's transcript and may contain errors. The video belongs to its creator, NorDIC Lab.