Instruction Sets

A computer. Without an instruction set. Is nothing.

Possibly because even the techies don’t know much about them and you know the old saw, better to keep your mouth shut and all that.

What’s an instruction set? Well, it’s the language your processor speaks and its ‘words’ are composed of strings of binary digits, commonly referred to as machine code. At its basic level, this code is responsible for enabling and disabling where control pulses are directed in the micro. Back in the good old days, memory was expensive and clock cycles were valuable. The only way to program a computer was explicitly with machine code- there were no compilers or high level languages. Even operating systems were rare. They sucked up valuable resources.

Adding A to B and printing the result might look something like this…

10000001             Data in following addr to register A

00001010             Addr for A

10000010             Data in following addr to register B

00001011             Addr for B

00100001             ADD A to B; Result into C

11011000             Print Register C

11000000             Halt

The text to the right is simply comments, the machine of course only understands the binary code. While this is actually pretty compact, writing anything more than a simple program becomes a frustrating and error-prone process. Imagine debugging a program like this without any comments. And programs could easily exceed 100,000 lines.

If only there were a way to make the computer understand more human-like language and automatically convert..or..compile.. its own program. And so came Fortran (formula translator) for scientific work and COBOL (common business orientated language) for business uses, like invoicing and payroll.  And of course a myriad of other languages. For example, BASIC. The same instructions to the computer would look like this:

A=5

B=7

A+B=C

Print C

Now that’s programming! The downside is, the computer has to first examine all of our code and interpret it according to the rules. This means it might not always interpret what we want correctly, it also means our program will end up larger then intended with non-value added code, and because it’s larger and has more lines of code, it will run slower. It sees numbers that aren’t in parenthesis and so it assumes these will be variables. It sees the plus sign and so it assumes an addition will be performed. It looks for any characters after the word Print to determine if the output will be a variable or literal text. And then it writes its own binary code (just like we did above) to perform this. But no bets if the compiler will end up with the same code as we did.

Granted, there’s not much open to interpretation in something like A+B. But imagine a complex algorithm that used multiple constants. The programmer would know which storage locations were no longer needed as one-time use variables were used. But the compiler wouldn’t. It might just keep reassigning new locations as variables were called. It may end up using more memory and more cycles accessing them than is necessary, but today, we don’t care. We have Gigs of RAM and GHz processors. In fact, the whole GUI environment is a valid parallel of this. What would take one line to type in DOS to launch a program, requires a complete graphical environment with a pointing device, video mapping, a graphical file hierarchy, etc. etc. But again we don’t care, we have horsepower to compensate.

Imagine if we couldn’t make B=7. If all our variables had to go through A first.

First Set A=7. Then Move A to B. Then Set A=5. Now Add.

Imagine the bottleneck this would create if we had a list of numbers to assign!

Nobody says an instruction set is going to be easy to work with. A good instruction set translates into faster throughput. A faster machine. More flexible programming. Anyone that went through the Mac vs. PC wars of the 1990’s will remember how the PC with the faster Intel chip was getting smoked by the Mac’s PowerPC. I won’t go into those details here but it’s an interesting story. And as computers evolved and compilers became popular, the instruction sets took on a decided bent towards accommodating those languages. 

So while guys are beating their chests and boasting about their latest processor speeds, hard drive capacities and RAM figures, you’d do well to ask them about the efficiency of their instruction set.

[Incidentally, the binary code in the example above is real. It’s part of the instruction set of my computer]