Channels ▼

Al Williams

Dr. Dobb's Bloggers

The CPU Crawl

May 08, 2013

I occasionally hear people use the phrase "crawl, walk, run" when describing early steps in a project. The idea is you can't expect a baby to just start running. Even the greatest Olympic runner starts with — literally — baby steps, and builds on those.

Recently, I've been talking about a very simple computer that was built using cardboard by Bell Labs back in the 1960s. That computer, CARDIAC, is simple enough that I thought it might be useful for teaching students (even lifelong ones) about simple logic design.

Last time, I talked about CARDIAC's internal structure and presented a partial implementation in Verilog. This time, I want to talk a bit more about Verilog and how it is different from simply writing something using software.

Sticking to "crawl, walk, run", let's consider a simple half adder circuit. You can build these out of relays even, so they aren't very complicated. The idea is to take two binary digits and produce a sum and a carry bit.

There are many ways you could develop a half adder circuit. Traditionally, you'd draw a schematic:

For a simple circuit like that, this isn't especially onerous. However, for a big circuit like a CPU, or even a modestly complex circuit like a LED display driver, it gets old fast.

Most modern FPGAs implement logic like this using a look-up table. So even if you draw the schematic, you wind up with a table inside the FPGA that looks like this (courtesy of the FPGA tools that convert your input into a bit stream to configure the FPGA):

Again, this is easy to figure out for this simple case, but not so easy when you have a very complex circuit. That's why most designers use an HDL (hardware definition language) like Verilog or VHDL. A complex circuit is easier to describe than it is to draw. Of course, there are many ways you can describe something.

Here's one (pretty silly) implementation of a half adder in Verilog:

module halfadd(input a, input b, output reg sum, output reg cy);
always @(a,b)
case ({a,b})

That's nothing more than writing the table in a different format. A few notes on syntax, though. The {a,b} construct forms a word that is a and b joined together. In this case, since a and b are one bit each, the result is two bits.

The syntax of 2'b00 and 1'b0 tells the Verilog translator that you are writing a binary word with two bits (in the first case) and one bit in the last case. The "b" is for binary. You could write a hex constant like 16'hff, for example, which would be 255 in a 16-bit word.

You may notice in some Verilog that you see a mix of "=" and "<=" for assignment. There is a subtle but important difference. Inside a block, the <= operator only takes effect at the end of the block. Imagine you had the code:


If x already contained, say, zero, then at the end of the block x would equal 4, but y would equal 0 because the <= operator doesn't take effect until the end of the block. If z were equal to zero at the start, zz would equal 9 at the end of the block because the = operator takes effect immediately.

You may think you don't care about this, but you do. Remember that Verilog is just a description of what you want and, usually, what you want is going to wind up in a piece of hardware where everything occurs together. In English, the statements above say something like this: "At the exact same time, set y to x and x to 4. Also set z to 9 and then set zz to z." The and then is what gives you trouble. In software, not only is that natural, it is very difficult to do things at the exact same time. In hardware, it is difficult to define that sequence, and the translator has to add extra circuitry to make sure zz gets the correct value. Of course, even in hardware things don't happen exactly at the same time, but that's a topic for a bit later.

How else could you describe the half adder? You could describe it by the gates it uses, but that's not much better (and maybe even harder) than drawing the schematic:

and and1(a,b,carry);
xor summer(a,b,sum);

Or you could write:

assign sum=a^b;
assign carry=a&b;

Related Reading

More Insights

Currently we allow the following HTML tags in comments:

Single tags

These tags can be used alone and don't need an ending tag.

<br> Defines a single line break

<hr> Defines a horizontal line

Matching tags

These require an ending tag - e.g. <i>italic text</i>

<a> Defines an anchor

<b> Defines bold text

<big> Defines big text

<blockquote> Defines a long quotation

<caption> Defines a table caption

<cite> Defines a citation

<code> Defines computer code text

<em> Defines emphasized text

<fieldset> Defines a border around elements in a form

<h1> This is heading 1

<h2> This is heading 2

<h3> This is heading 3

<h4> This is heading 4

<h5> This is heading 5

<h6> This is heading 6

<i> Defines italic text

<p> Defines a paragraph

<pre> Defines preformatted text

<q> Defines a short quotation

<samp> Defines sample computer code text

<small> Defines small text

<span> Defines a section in a document

<s> Defines strikethrough text

<strike> Defines strikethrough text

<strong> Defines strong text

<sub> Defines subscripted text

<sup> Defines superscripted text

<u> Defines underlined text

Dr. Dobb's encourages readers to engage in spirited, healthy debate, including taking us to task. However, Dr. Dobb's moderates all comments posted to our site, and reserves the right to modify or remove any content that it determines to be derogatory, offensive, inflammatory, vulgar, irrelevant/off-topic, racist or obvious marketing or spam. Dr. Dobb's further reserves the right to disable the profile of any commenter participating in said activities.

Disqus Tips To upload an avatar photo, first complete your Disqus profile. | View the list of supported HTML tags you can use to style comments. | Please read our commenting policy.