🚀 go-pugleaf

In article <12236@mentor.cc.purdue.edu>, hrubin@pop.stat.purdue.edu (Herman Rubin) writes:

|> Why do we have separate integer and floating units, especially without 
|> communication between them?  I suggest those who push this horror look
|> at how difficult conversion between them is.  I have already pointed out
|> that every trigonometic and exponential routine does, in some way, 
|> float/float -> integer, remainder.  The integer is also used.
|> 
|> Even putting integerization, addition, and subtraction in floating units
|> is not the answer.  Boolean operations using floats are useful.  Packing
|> and unpacking should be hardware operations.  If there is a dichotomy, it
|> is address/loop versus arithmetic, not integer versus floating.  There
|> have been machines with this feature.  But even if one has this, it is
|> still necessary to have good communication between the units.
|> 

We have separate integer and floating units because it helps make the
machines fast.  It provides an easily-detected form of parallelism.

Good communication between the units requires both the hardware real-
estate for the data paths and, when such communication is used, the
synchronization of the two units.  Good communication, like any other
architectural feature isn't "necessary".  It is desirable, if the
cost is low enough.  One must compute the expected performance return
from adding such features.  As with any such computation of an expectation,
this would include

   (1) how often such a feature would be used
   (2) the performance improvement it would provide, when used
 & (3) what performance degradation the machine would suffer from
         having such a feature, even if it is not used (e.g., the
         loss of other ways of spending the chip area)

Does anyone have any suggestions about what these numbers are?

|> The user may not see the use of more sophisticated hardware, but that does
|> not mean the casual user does not use it.  In many situations, on the RS/6000
|> I would keep two copies of an integer loop variable if it will be used in 
|> floating arithmetic in order to avoid the cost of converting.  I wonder if
|> the compiler writers have thought of that?

Yes, we have.
-- 
                                   Dan Prener (prener @ watson.ibm.com)