doug@xdos.UUCP (Doug Merritt) (11/29/89)
In article <4737@nigel.udel.EDU> acm131@eric.ccs.northeastern.edu (Craig Scott Lennox) writes: > >Since people seem to be posting their favourite lies from computer >reps, I thought I'd add this one I heard from an IBM demo guy [...] >Motorola 68020 vs. the Intel '386, and he came out with this beauty: > >"Well, of course segmented architecture enables you to produce tighter, >more modular code." Devil's advocate coming up. But first: I *HATE* segmented architectures! Ok, that said, he's not altogether wrong. But it should be rephrased: "...*forces* you to write more modular code". Mostly :-) about that part. There's nothing wonderful about being forced to break huge data structures into smaller 64K chunks. Nor for code, for that matter. But. He's (partially) right on target about tighter code. Granted segments are a pain in the ass, but code written using 16 bit pointers plus pain-in-the-ass workarounds for dealing with other 64K segments *IS* often tighter than code that uses purely 32 bit pointers. Such code can maybe a third smaller on the 68000, and smaller yet on 80x86's (due to sometimes more compact instruction coding). My usual rebuttal to *that* argument is: sure, but you *can* use 16 bit offsets rather than 32 bit pointers on the 68000, too, and for small programs, people often tell the C compiler to use small model to do exactly that. But there's a counter-rebuttal: it's much, much harder to do this for *large* programs on the 68000, due in part to the 68000's architecture (16 bit offsets are not supported by all instructions that allow 32 bit pointers), and in part due to limited support by C compilers, and even in part by the definition of the C language (i.e. it's more feasible to do this for large programs in assembler than in C). And more to the point, people usually don't try to use "small model" constructs/compiler modes with large programs, whether written in C or not. But then it gets complex, because if someone *does* make the attempt, then you can counter-argue that the result will be tighter on the 68000 than on the 80x86 due to the larger register set and more orthogonal architecture. And in my experience, this tends to be the last word. The Intel architecture *forces* people to use more compact constructs than does the 68000, but when people try to be compact on the 68000, it's an even bigger win than it is on the 80x86. It's a really big win to have lots of registers. This is part of the reason that RISC machines do well on benchmarks (not the only reason, but look at the kludgy Clipper processor...it's very slow for a RISC in part because of its small register set). So back to the salesman: he's right, and he's wrong. Doug -- Doug Merritt {pyramid,apple}!xdos!doug Member, Crusaders for a Better Tomorrow Professional Wildeyed Visionary