Rep Specs - Need user input

Rep Specs - Need user input

[Burch Seymour]

I would like to hear from Ada users (by e-mail preferred, I'll post
summary if enough response) about their use and expectation of rep-spec
implementations. 

The basic problem from my point of view (working on the Ada runtime
library) is that it is a non-trivial problem to manipulate non-byte
multiple data items with an instruction set that deals with byte,
2 byte, 4 byte, and 8 byte items. A simple Ada instruction such as

    x := 5;

where x is a rep spec'd item of, say, 17 bits, causes a call to a
library routine which has to do a lot of masking and shifting to
generate the result.

The question then is, how important is eeking the last bit of speed
out of rep specs? Or are people just doing conversions to/from more
conventional data representations and doing the speed critical stuff
with those items?

Any thoughts on these questions, other Rep Spec issues, or performance
in general would be appreciated.

You can try the following mail paths, we've been disconnected from the
net for a while due to modem problems at our feed, but I think my
dot sig file is still mostly correct.

Thanks,
--------------------------------------------------------------------------------
    #####              Gould Computer Systems Division
      ###                  in Sunny South Florida
#####   #####                   Burch Seymour
#####    ####     =>  ...!{uunet,sun,pur-ee,brl-bmd}!gould!bseymour
#####   #####     =>  ...!{ihnp4!codas,allegra}!novavax!gould!bseymour
      ##          => NOTE: Disregard header info. Email to above paths only.
    ####          => The opinions expressed are probably not worth disclaiming
================================================================================

Re: Rep Specs - Need user input

[stt]

Here is a general comment:  given that the hardware provides
shift and mask instructions, there seems no reason why bit-field
assignments/fetches need be out-of-line.  C-compilers have
been doing this kind of bit-field manipulations in-line
since 1976 or before.  Take a look at the
Gould C compiler, or others, and I am sure you will see reasonable
code for such bit-field operations.  I'm sure Jovial, etc. do the same.
(Concatenating unaligned slices of packed bit arrays is another
matter, of course ...)

Tucker Taft
Intermetrics, Inc.
Cambridge, Mass  02138