19 Aug
2001
19 Aug
'01
12:35 p.m.
You're exactly right, Paul. There are few reasons to argue price/performance
issues between two processors so different when a task that either could do is
the target. However, if one knows enough about the processor and enough about
the task, one isn't saddled with such tasks as could be better done on the other
architecture. Once in a while, however, you have to do what's got to be done
with what you're already using for the rest of the task, and that's when the
inefficiency of using a big guy to do the small job bites you. The majority of
tasks done by micros can be handled quite easily with small, underimplemented,
8-bitters.
When you do have to use a bigger processor, it's often preferable to use a
co-processor of some sort. The MOT folks realized this and provided a part just
for that sort of task, in the form of the 68120/121, which is a 6803 CPU with
peripherals, with a built-in 6834 two-ported RAM (semaphore registers).
more below ...
Dick
----- Original Message -----
From: "Paul R. Santa-Maria" <paul(a)orchard.wccnet.org>
To: <classiccmp(a)classiccmp.org>
Sent: Sunday, August 19, 2001 2:07 PM
Subject: 6502 vs 68000
Yes, and the 80x86's of the late-'70's-early '80's fell between
the two, being a
"Chinese fire drill" either way.
It was astonishing, however, to find that a $6 8-bitter performed simple tasks
10x as fast as a $150 "32-bitter."
Date: Sun, 19
Aug 2001 07:26:19 -0600
From: "Richard Erlacher" <edick(a)idcomm.com>
Subject: Re: SemiOT: Mourning for Classic Computing
There are lots of things one CPU could do more simply than another,
but, normally, there were others that went the other way. I remember,
back in '80 or so, demonstrating that the 4 MHz 6502 was considerably
faster and more code efficient than the 8 MHz 68000. This was, of
course, because the 8 MHz 68K had to fetch two words just to get its
opcode, though it didn't take long to execute it once the opcode and
operands were in place.
In 1980, most 8-bit CPUs were more efficient that the 68000 in terms of
code size as long as you limited yourself to 64K. When you got past 64K,
the 68000 scaled smoothly while programming the 8-bitters became a Chinese
fire drill.
Paul R. Santa-Maria
Monroe, Michigan USA