Some thoughts on future compiler features....

I am writing this message to get a response from compiler designers as
to the viability and possibility of implimentation of the following
ideas in future design...:


-A common problem IMHO that leads to kludged solutions is the apparent
lack of communication between ths OS, compiler and hardware
companies...a good example is the use of larger register files (the
Merced for example), while large register files are great for
increasing inidvidual program speed, things like process swap overhead
have to be taken into account. A nice solution that I have developed
for a small embedded systems project is the use of "virutal" save and
resotre functions per thread...allowing optimization by allocating and
restoring only those regs which are used, the problem of course is
that assembler level optimization has to be done to take advantage of
this feature, obviously out of scope for the application level
programmer, as it should be. I suppose this really ties into dyanmic
code generation (which doesn't seem to be readily available/easy to
use in current mainstream), but will we ever see compilers that are
smart enough to do things like this (i.e. formulate the optimum save
restore functions for a thread given it's code)


-Yet another common problem in software in cross platform is calling
convention.. although C++ does provide a nice interface that allows
specification of two other calling conventions, will we ever see a
sort of general procedure where the calling convention can be
specified on a per method basis? As an embedded systems programmer I
sometimes find it difficult calling useful code from a high level
since, in order for efficiency a particular register calling
convention is used, that cannot be specified at the high level. Note
the Watcom compilers seem to have a nice way of doing this, although I
am not sure how cross platform the mehtod applies (multiple blocks
conventions should be able to be specified for different platforms).


-To emphasize the first point, will we ever see platform independant
dyanic code generation? By this I mean this as a usable (possibly
transparent?) to the app programmer, I am aware that it is possible in
Java, but in terms of automatic opimization, not terribly useful


The other view is that hardware and memory just keep getting better
and cheaper, so why bother with all this nuts and bolts optimzation?
Apart from the elgance factor, I think thta we would ultimately reach
a speed bottleneck from primitive code generation....


Well I am done ranting, any thoughts?
--

Return to the comp.compilers page.
Search the comp.compilers archives again.