Package Logical performance optimizations

Package Logical performance optimizations

[Al Niessner]

Has anyone written the body for package logical (from the PAL) using
package machine code for the 680x0 and/or the intel x86 family of
processors?

If so could you please post or send them to me.


Al Niessner

Re: Package Logical performance optimizations

[Robert Dewar]

Al asks

<<Has anyone written the body for package logical (from the PAL) using
package machine code for the 680x0 and/or the intel x86 family of
processors?
 
If so could you please post or send them to me.>>

You need to say what compiler you are using, since package Machine_Code
will vary from one compiler to another. Also note that in Ada 95, the
implementation of package Machine_Code is not required, even if you
support annex C, since it is possible to provide (the much more useful
approach) of machine intrinsics instead (GNAT provides both).

The one exception is the Motorola 88000. For this machine, the official
ABI includes a specification of what package Machine_Code should look
like in Ada compilers for this machine, so presumably there would be
no portability issue with this machine (unfortunately, as far as I know
there are virtually no computers using this chip any more, the manufacturer
has abandoned the chip, and there are no Ada compilers available -- although
a GNAT compiler could easily be constructed, so this is all a bit academic).

It would be nice to standardize machine code, but it is tough. For example,
in GNAT, we directly interface to the gcc capability, which is extremely
flexible, since it allows linking directly into the RTL structure, using
symbolic registers if you want), but it is highly gcc dependent.

The old Alsys 386 compiler had what I thought was a very nice set of
instrinsics (I designed them :-) which were reasonably compiler independent,
but I don't think anyone followed them (I don't even know if Object Ada
duplicates this facility ...)

Re: Package Logical performance optimizations

[Richard Kenner]

In article <dewar.865943105@merv> dewar@merv.cs.nyu.edu (Robert Dewar) writes:
>The one exception is the Motorola 88000. (unfortunately, as far as I know
>there are virtually no computers using this chip any more, the manufacturer
>has abandoned the chip, and there are no Ada compilers available -- although
>a GNAT compiler could easily be constructed, so this is all a bit academic).

Indeed, I used to build GNAT on an 88k when I used the Data General
machine much more than I do now.  It worked fine, but that was without
tasking, of course.

Re: Package Logical performance optimizations

[Ed Falis]

Robert Dewar <dewar@merv.cs.nyu.edu> wrote in article
<dewar.865943105@merv>...
> The old Alsys 386 compiler had what I thought was a very nice set of
> instrinsics (I designed them :-) which were reasonably compiler
independent,
> but I don't think anyone followed them (I don't even know if Object Ada
> duplicates this facility ...)
> 
> 

Yes, they' re in all the Intel targeted versions of ObjectAda.

- Ed

Aonix

Re: Package Logical performance optimizations

[Robert Dewar]

Ed said

<<Yes, they' re in all the Intel targeted versions of ObjectAda.
>>


(talking of the x86 intrinsics).

That's nice to hear, since as I said I think that was a nice design. One
thing to realize however, is that whenever you use such facilities, you
are introducing not just machine dependence, but also compiler dependence.

As I noted before, there is no standardization of the Machine_Code package
or equivalent intrinsics, even on a particular target, and different
compilers may differ very widely.

GNAT also provides a complete implementation of package Machine_Code and
machine code intrinsics on all targets, but at a quite different level,
which has advantages and disadvantages.

The Object Ada facility is basically raw assembly language, the code generator
does not really know what you are doing, and it is up to you to generate an
appropriate set of instructions which fits in with what is going on around
the code. The advantage of this approach is that it really is very similar
to just writing assembler, and so if you know ASM and Ada well, you can easily
use this facility.

GNAT on the other hand, uses the gcc facilities for machine code. These hook
into the gcc code generator, since basically you are generating RTL, and for
example, you can use symbolic registers, and have the code generator pick the
right registers, fitting in with other use (and optimization) going on around.
You can control absolute registers if you want on a machine like the x86,
where all registers are different, but you don't have to. This approach is
a little more flexible, but it requires a fair amount of understanding of how
machine instructions are represented at the RTL level, which means you have to
know something about GCC, as well as about ASM and Ada.