From tw45639@vub.ac.be Thu 22 Jun 95 17:52:36
From: hyc@troy.la.locus.com (Howard Chu)
Newsgroups: comp.sys.hp48
Subject: Re: HP48 vs. TI92
Date: 22 Jun 1995 00:48:34 -0700
Message-ID: <3sb78i$uhv@troy.la.locus.com>
References: <3rof35$s3a@zipper.zip.com.au> <ammDAC36t.2q0@netcom.com> <803605189snz@granby.demon.co.uk> <3s5mll$mnq@hustle.rahul.net>

In article <3s5mll$mnq@hustle.rahul.net>,
Matthew Carlson  <carlson@rahul.net> wrote:
>The 68000 is a 32 bit processor with a 16 bit data bus. So putting one of 
>those in a TI 92 with static memory is really stupid. The instrucions are 
>four times as long as in a HP48 Saturn processor. By the way what is the 
>point of having instructions 32 bit? I though the point was making them 
>work on data that is 32 bit but, saving memory by having 8 bit 
>instructions? I mean come on who needs 4 Billion diff. instructions 
>besides IBM anyway. We only need the 256 provided by 8 bit code. You can 
>make 8 bit instructions opperate on 32 bit data right? 
>Maybe I am screwed up here. Does a 32 bit instruction mean the inst. is 
>32 bit or it works on 32 bit data and the instr. is smaller?
>If the are 32 bit Windows 95 is going to be a killer on ram. All the 
>instructions will be doubled in size.

It's not as simple as that, the "bitness" of a processor can refer to many
things, including instruction word size, register size, address bus width,
data bus width, or something else entirely. In the case of the 68000, only
the registers are 32 bits, the external *and internal* data buses are only
16 bits wide, the address bus is 24 bits wide, and its instructions are
only 16 bits. (So there you go, is a 68000 really a 16, 24, or 32 bit CPU?
Clearly the question and the terminology are both meaningless without added
context.)

The 68000 can operate on individual bytes, so I guess that makes it an 8-bit
CPU now, doesn't it... It doesn't truly operate on 32-bit data; everything
is 16-bit word-based - loading a 32 bit immediate operand into a register,
for example, requires a 16 bit instruction followed by two 16 bit extension
words, for the high and low order bytes ofthe 32 bit operand. Loading this
instruction requires 3 complete bus accesses, 1 for each word.

Funny you should mention Windows95. (Ack!) Believe it or not, but the entire
Intel processor family (80x86) does use only 8 bit instructions. So I guess
an 80486 and a Pentium are both really only 8 bit processors, eh? Of course
the reality isn't anywhere near that simple, because a single instruction
byte can be preceded and followed by any number of modifier bytes. (What a
nightmare. I would hate to have been on the engineering team that first tried
to design an instruction cache for the damn thing.) Obviously there's no
simple answer to the question of whether 32-bit Windows apps will be more
memory-hungry than their 16-bit counterparts. Yes, lots of address operands
and such will be larger, thus increasing space usage, but also a lot of
computations can be done more cheaply, thus reducing memory usage. (For
example - multiplying two 32-bit numbers on a 16 bit processor requires 4
multiplications and a couple shifts and adds, but requires only 1 instruction
on a 32 bit processor. Here "16-bit" and "32-bit" imply the size of a data
register, but more explicitly refers to the size of the ALU, and says nothing
at all about instruction size, bus width, etc...)

Your perception of "bitness" is probably colored by exposure to early RISC
systems, where simplicity of design was a primary goal. Looking at SPARC or
older MIPS and other RISC designs, you see 32 bit registers, 32 bit wide
instructions, 32 bit data bus, 32 bit address bus, 32 bit ALU, etc. Keeping
all paths the same width simplifies things tremendously for the hardware
designer, you don't need to worry about running multiple bus accesses just to
fetch an instruction, and your decoding logic doesn't have to try to guess
how some instruction will be modified by some modifier that's still being
fetched... In those cases it's clear that the processor is 32 bit, no more,
no less. But in this day where designers are trying to migrate to 64 bits,
the boundaries blur again, just as the 68000 blurred the distinction between
16 and 32 bit processors.

As a final illustration, consider a RISC processor in the Atari Jaguar,
a "64 bit" home video game console. The Tom processor has 32 bit registers
and 32 bit instructions, a 24 bit address bus, and 64 bit data bus. It
really should only count as a 32 bit processor, but the 64 bit bus allows it
to fetch 2 instructions per bus cycle, and it has multiple execution units
so it can process both instructions at once, so in many ways, it provides the
computational performance of a 64 bit processor. (The Jaguar has other
processors though, with varying degrees of 64-bitness, including a graphics
unit with 64 bit registers, ALU, and 64 bit data bus. This chip is clearly a
64 bit processor by any meaningful measure.)

Are you sorry you asked yet?
-- 
Howard Chu                              Senior Member of Technical Staff
hyc@locus.com                           Locus Computing Corporation

