Path: utzoo!utgpu!watserv1!watmath!att!pacbell!pacbell.com!ucsd!sdd.hp.com!elroy.jpl.nasa.gov!ncar!midway!tank!stephen From: stephen@estragon.uchicago.edu (Stephen P Spackman) Newsgroups: comp.arch Subject: Re: Why FP at all? (was: Re: Killer Micro II) Message-ID: Date: 7 Sep 90 03:59:28 GMT References: <527@llnl.LLNL.GOV> <603@array.UUCP> <2482@l.cc.purdue.edu> <1632@lhr.Morgan.COM> Sender: news@midway.uchicago.edu (News Administrator) Organization: University of Chicago CILS Lines: 59 In-Reply-To: amull@Morgan.COM's message of 5 Sep 90 14:26:13 GMT Let me try to rephrase my question in a less controversial form. And please understand that I *do* appreciate the importance of weather forecasting, and te fact there there is a genuine *need* for supercomputing for that and all the other applications that involve the simulation of large dynamical systems. But it does seem to me that most cycles really do go on operating systems and user interface, and putting integrated floating point into a silly little workstation like a Sparc or an 80486 machine is serious overkill (and I'm almost serious: these machines aren't fast enough for editing anymore) and a poor use of gates. Especially since, I conjecture, emulation could theoretically be faster. So here's the restatement: SUPPOSE that hardware floating point were NOT a given. Suppose we were completely free to choose how to support the user. But users have these needs involving non-integral numbers. What should we do? Well, any fast conventional architecture will have good support for non-negative integers, at least - they're needed for addressing. And it'll have good support for function call - that's needed to execute code. So the question is, what ELSE do we have to put in to get good coverage? All I'm thinking is that an FPU *may not* be the best answer. It's 1990 now; we can rely on the compiler. Language-driven architecture is dead (though language-tuned architecture is another story). Semantic gap is, if not a myth, then a strength - compilers need elbowroom in which to optimise. Is it so absurd to suggest that outside of the supercomputer market, scaled integers might honestly be a better solution for the problems that need solving (assuming that there is proper compiler support for them, and it isn't all hand-coded at every step)? Is it so absurd to suggest that there might be PARTS of floating point instructions that, in the hands of a good optimiser, might be used to generate better code than their wholes (remembering the VAX CALLS linkage... :-)? Is it so absurd to suggest, in sum, that exposing separate mantissa and exponent to the optimiser might result in *speedup* due to constant propagation and expression-rearrangement, while at the same time increasing expressivity by allowing an INDEPENDENT choice of mantissa and exponent sizes? Is it so absurd to suggest that the effort and the silicon that go into an FPU might be better spent on supporting some other datatype that is of more _general_ applicability? Maybe this has all been tried and I just haven't heard about it. If *that's* the case, please point me at some references. But I have the distinct impression that we're coasting along on research that was done thirty years ago or more, and that may need to be updated in the light of changing technology. stephen p spackman stephen@estragon.uchicago.edu 312.702.3982