Home > Archive > Compilers > March 2007 > The development tendency of compilation tech?
You are viewing an archived Text-only version of the thread.
To view this thread in it's original format and/or if you want to reply to
this thread please [click here]
| Author |
The development tendency of compilation tech?
|
|
| Yunzhi Xue 2007-01-15, 7:09 pm |
| Hey all,
I'm working on a survey of the development tendency of compilation
technology. But there are too many issues and I am such a Green
Hand. So could anybody please tell my about the possible major trend
of compilation tech?
Best wishes
Yunzhi
[So what's new in compilers this year? -John]
| |
| Derek M. Jones 2007-01-15, 7:09 pm |
| Hello Yunzhi Xue,
> I'm working on a survey of the development tendency of compilation
> technology. But there are too many issues and I am such a Green
> Hand. So could anybody please tell my about the possible major trend
> of compilation tech?
>
> Best wishes
> Yunzhi
> [So what's new in compilers this year? -John]
The only really new thing in compilers over the last few years has
been optimizing for low power consumption.
Will this be the year that gcc or some other industry strength
compiler supports a -opt_power optimizer switch?
I have not seen any research on compilers automatically searching for
header files that are not found in the specified directories to
search.
But the question was about major trends.
Can we predict how long it will be before gcc is the world's only C
compiler? It provides tough competition and there are not many
commercial vendors left.
What other major trends?
o People will continue to invent what they claim to be new
languages.
o the effort required to write a commercial quality compiler
will continue to grow and fewer and fewer of them will be written.
o Most of the world's source code will still be written in a
language for which there is no decent open source compiler (ie,
Cobol).
| |
| Jürgen Kahrs 2007-01-15, 7:09 pm |
| Derek M. Jones wrote:
>
> The only really new thing in compilers over the last few years has
> been optimizing for low power consumption.
Really ? Compiling from high-level languages to hardware description
languages looks like another new thing that began in the late 1990s.
Exploiting multiple CPU cores while avoiding the threading problems
seems to be another active field. But one can argue if this field is
new or if it is rather a problem of language design.
Compiling for hardware like the Physics Co-Processors looks like a new
field. Here, one can argue about the distinction between compiling for
physics co-processors and for graphics co-processors.
http://www.ageia.com/physx/faqs.html#2
| |
| Walter Banks 2007-01-16, 10:09 pm |
| "Derek M. Jones" wrote:
> Hello Yunzhi Xue,
>
>
>
>
> Can we predict how long it will be before gcc is the world's only C
> compiler? It provides tough competition and there are not many
> commercial vendors left.
GCC is showing its age. It does make the risk of new compiler idea's
much higher. It also shows that support provides a viable revenue
stream.
GCC has made few inroads in application areas where tool price is a
small percentage of development costs.
GCC based tools have made very little inroads into volume small
embedded applications, processors with unusual instruction sets or
multiple processor applications
> o the effort required to write a commercial quality compiler
> will continue to grow and fewer and fewer of them will be written.
No argument. Good compiler implementation is a labor intensive activity.
My trend choice is multiprocessor support from a single source
application. It is happening now in specialized applications.
w..
Byte Craft Limited
| |
|
| One tendency that has come during the last ten years, is that of
compiling to byte code for virtual machines. This is not new, but with
Java it has become widespread. This has in turn spawned the "just in
time" breed of compilers, which compile platform neutral byte code to
target platform code, for faster execution.
Does this qualify as a major trend? I think it does.
Another trend, not in compilers as such, but related, is the tendency,
due to ever faster machines, to write larger and larger programs in
interpreted code. In the old days, everyone had experienced slow BASIC
interpreters, and moving forward to compiled code (pascal or C),
together of course with better hardware, made a huge difference in
throughput. Whereas now, with powerful hardware, interpreted code is in
many cases sufficient to solve many problems, such as PHP and
Javascript.
[In the really old days in the 1950s, byte code like interpreters were very
popular, mostly to provide a higher level instruction set than the simple
computers of the day had, e.g., adding floating point and stacks. -John]
| |
| Amit Gupta 2007-01-22, 8:20 am |
| > > [So what's new in compilers this year? -John]
How about compiling to fine grained, local memory, parallel computing
machines (like FPGA). With the memory access being the bottleneck in
current computing machines and fine grained parallelism can be
dramatically less power too, we might see this catching up sometime
soon.
| |
|
| > One tendency that has come during the last ten years, is that of
> compiling to byte code for virtual machines.
> Another trend, not in compilers as such, but related, is the tendency,
> due to ever faster machines, to write larger and larger programs in
> interpreted code.
What's new in compilers? Very little. I think in 10 years, compiling
will be largely forgotten.
Diversity in computing is over. Long gone are the days of
free-spirited innovation, today hardware and software development
appear to be in a sort of lock step. More and more computing is done
with the products of Big Brothers 1 and 2, and management appears to
have been conditioned not to accept anything outside of the
mainstream.
Except maybe where there is lots to be gained by more performant and
non-conformant application software, there is reduced incentive to
accept or develop anything like a new language, let alone compile it.
What ever happened to massively parallel and array architectures, or
more accurately, why doesn't any of this ever reach the mainstream?
Generally, the average workstation or laptop spends most of its time
waiting on mouse clicks, as computing horsepower is much more than
enough for the average user. Thus applications written in interpreted
languages perform acceptably, where this would not have been the case
before say the introduction of the 386.
Compilation is the economic necessity of underperforming hardware.
| |
| Peter Flass 2007-01-31, 7:14 pm |
| Nick wrote:
>
>
> What's new in compilers? Very little. I think in 10 years, compiling
> will be largely forgotten.
Hard to get along without it, eh? At some point you're still going to
need a compiler. Bytecode-type languages are still compilers, written
for a specific (virtual machine) architecture, which could be
implemented in hardware, software, microcode, or any combination. In
any case, you still have to compile the interpreter somehow.
| |
| Brandon J. Van Every 2007-01-31, 7:14 pm |
| On Jan 27, 10:41 pm, "Nick" <Ibeam2...@gmail.com> wrote:
>
> What ever happened to massively parallel and array architectures, or
> more accurately, why doesn't any of this ever reach the mainstream?
Because it is a complicated programming model. People haven't even
mastered simpler programming models yet. People have been doing dual
CPU - and nowadays dual core CPU - programming badly for quite a
number of years. This is merely at the level of coarse grained thread
programming with different task allocations, and people haven't been
getting it right. There is no market incentive for them to do so: the
CPUs keep getting faster every year, so they can just keep writing
their code to 1 CPU. Moore's Law really hasn't abated, despite the
gloom and doom.
Only now are starting to see 8-core CPUs such as the Cell Broadband
Engine. Only now are such architectures being commodified, such as in
the Playstation3. You really can't get intelligence on such problems
until a lot of people are pursuing them, for everyday commercial
reasons. 8-core is a different focus than 2-core, especially when the
SPEs of a Cell are designd for intensive single precision floating
point 4-vector tasks, not general purpose processing. It shifts the
rational focus of a problem away from coarse threads implementing
different tasks, and towards finer threads partitioning the same
task. Without industrial commodification, there will be no wisdom on
such tasks. We're in very early days for what the cheap HW can
actually support, so I say all your gloom and doom for nothing. We
have to pass through necessary stages of evolution where we get the
basics of parallel computing models correct, and then scale up. 2
cores is not 8 cores is not 80 cores. Nor are multiple cores on a
CPU, the same as multiple CPUs on a board, the same as multiple
computers in a network. We have a lot of memory access models to
consider also.
> Compilation is the economic necessity of underperforming hardware.
Some application domains - 3D graphics, AI - always underperform.
It's not an accident that the Cell BE is being commodified in a game
console.
Cheers,
Brandon Van Every
| |
| Steve Murray 2007-01-31, 7:14 pm |
| Yunzhi Xue wrote:
> Hey all,
>
> I'm working on a survey of the development tendency of compilation
> technology. But there are too many issues and I am such a Green
> Hand. So could anybody please tell my about the possible major trend
> of compilation tech?
>
> Best wishes
> Yunzhi
> [So what's new in compilers this year? -John]
Hmm, not sure about this year, but looking at the short-term future of
compilation as a computerscience/engineering activity, I'd expect that
we'd see a continuation of development effort in back-ends over the next
few years - nothing radical perhaps, but ongoing work on re-targeting
compilers for processors/devices as they seemingly routinely enter the
market.
Steve
| |
| Tom Copeland 2007-01-31, 7:14 pm |
| On Sun, 2007-01-28 at 01:41 -0500, Nick wrote:
> Except maybe where there is lots to be gained by more performant and
> non-conformant application software, there is reduced incentive to
> accept or develop anything like a new language,
Hm, from where I sit, the Ruby language is relatively new and is coming
on strong. Also, it's introducing lots of people to all sorts of nifty
things that have been around for a long time, e.g., closures.
> let alone compile it.
One of the more recent Ruby developments is YARV, which compiles Ruby to
a bytecode format. All the usual compiler theory things apply, even if
the target is a VM rather than a "real machine".
So perhaps all hope is not yet lost :-)
Yours,
Tom
| |
| Hans-Peter Diettrich 2007-01-31, 7:14 pm |
| Brandon J. Van Every wrote:
> We
> have to pass through necessary stages of evolution where we get the
> basics of parallel computing models correct, and then scale up.
Or we have to find out how human information processing works, so that
we can both develop hardware to implement the same techniques, and
programming models that come closer to human intuition.
Once a system can be instructed verbally, about what to do for us, the
research will continue into the differences, how different humans
express their needs differently. Then context sensitive languages will
be on topic - and now look at which (Chomsky) level current research
takes place...
DoDi
| |
| Brooks Moses 2007-02-16, 4:17 am |
| Nick wrote:
> What's new in compilers? Very little. I think in 10 years, compiling
> will be largely forgotten.
>
> Diversity in computing is over. Long gone are the days of
> free-spirited innovation, today hardware and software development
> appear to be in a sort of lock step. More and more computing is done
> with the products of Big Brothers 1 and 2, and management appears to
> have been conditioned not to accept anything outside of the
> mainstream.
>
> Except maybe where there is lots to be gained by more performant and
> non-conformant application software, there is reduced incentive to
> accept or develop anything like a new language, let alone compile it.
> What ever happened to massively parallel and array architectures, or
> more accurately, why doesn't any of this ever reach the mainstream?
I'm not at all convinced that this is especially relevant. It may
well be true that advances in compiler technology (as separate from
advances in languages) do not matter to the vast majority of desktop
computers, but there are other computers in the world....
In particular, it seems to me (although I'm too young to have been
there) that there was a substantial amount of work being put into
compiler technology in the time period between 1950 and 1970. It also
seems to me that the market for multiprocessor compute servers -- not
web servers, but research machines doing physics simulations and the
like -- is at least as large now as it was then, and those are still
just as much situations where there is lots to be gained by higher
compiler performance.
(See also: Google, who seem to have no problems with embracing language
innovation, are going to be in desperate need of more computing power
for the forseeable future, and alone probably buy more computers in a
year than existed in the late 1960s.)
So it seems to me that if you're looking in the large pile of desktop
and laptop internet-and-Word-appliance computers for the future of
compilers, the reason you're not seeing much future is just that that's
the wrong place to look!
- Brooks, who's perfectly happy with a 300MHz laptop, these days.
--
The "bmoses-nospam" address is valid; no unmunging needed.
| |
| codeplay@gmail.com 2007-02-25, 7:09 pm |
| > What's new in compilers? Very little. I think in 10 years, compiling
> will be largely forgotten.
Parallelism. Processors are going parallel and there is no clear
solution to that problem. The future of processor architecture is
unclear.
> Diversity in computing is over. Long gone are the days of
> free-spirited innovation, today hardware and software development
> appear to be in a sort of lock step. More and more computing is done
> with the products of Big Brothers 1 and 2, and management appears to
> have been conditioned not to accept anything outside of the
> mainstream.
I don't think this is the best time to say this. We're having massive
and unpredictable changes in processor architectures as we switch from
single-core to massively parallel. Look at what Ageia, Intel, AMD/ATI,
nvidia, Tarari, Clearspeed, everyone really, is doing in processor
design. It's all going parallel but in lots of different ways. The
future processing power of PCs and mobile devices is going to be
predominantly in the parallel devices and there is no clear
architectural model for those devices. They're all different.
> Except maybe where there is lots to be gained by more performant and
> non-conformant application software, there is reduced incentive to
> accept or develop anything like a new language, let alone compile it.
> What ever happened to massively parallel and array architectures, or
> more accurately, why doesn't any of this ever reach the mainstream?
They're everywhere. And about to get even more everywhere. Apart from
maybe the desktop in the office. But Microsoft's new Vista is trying
to make GPUs standard for office desktop machines. GPUs, Cell, Physics
processors, FPGAs, they're all over the place and they're all parallel
devices. Dual-core x86 CPUs are standard for PCs now, quad-core to
follow, and then what? Increasing clock speed in the past has
increased power consumption. And we have now maxed out on power
consumption, so processor designers have to concentrate on increasing
performance without increasing power consumption.
> Generally, the average workstation or laptop spends most of its time
> waiting on mouse clicks, as computing horsepower is much more than
> enough for the average user. Thus applications written in interpreted
> languages perform acceptably, where this would not have been the case
> before say the introduction of the 386.
Everyone always says that! I remember saying it about the 386. Bill
Gates said it about 640K of RAM. We always want more processing power.
Maybe not for running Word. But for digital media: HD TV or games, or
for being able to speak to your computer, or engineering, or medical
imaging, or financial modelling, there are loads of situations where
more processing power will give significant improvements.
> Compilation is the economic necessity of underperforming hardware.
Compilation is pretty much necessary for software development. I do
remember the days of programming in assembly and I know people who
still do. I can see what you're saying, but it's the wrong time to be
saying it. People are really struggling to develop software for multi-
core processors (beyond the very simple). We're about to release some
new compiler technology to deal with parallelism and I know others are
too.
--
Andrew Richards
Codeplay
| |
| Ira Baxter 2007-03-01, 4:19 am |
| <codeplay@gmail.com> wrote in message news:07-02-060@comp.compilers...
>
> Parallelism. Processors are going parallel and there is no clear
> solution to that problem. The future of processor architecture is
> unclear.
>
Amen.
> Compilation is pretty much necessary for software development. I do
> remember the days of programming in assembly and I know people who
> still do. I can see what you're saying, but it's the wrong time to be
> saying it. People are really struggling to develop software for multi-
> core processors (beyond the very simple). We're about to release some
> new compiler technology to deal with parallelism and I know others are
> too.
Compiling for such architectures is actually pretty hard, and conventional
languages clearly aren't the right answer, as many of them (C and C++
notably) have no model of parallelism at all. Small SIMD vector CPUs
are everywhere, but it is very hard to get current compilers to used the
SIMD instructions effectively.
Other application areas require other techniques. For symbolic computing,
we've made a bet that medium-to-small granules of computation are
the right concept to support the type of SMP parallellism we are seeing
(4 CPUs today, 32 CPUs ... soon) in desktops. We started making
that bet back in 1996, and developed PARLANSE, a parallel programming
language. PARLANSE addresses the problem of irregular parallelism,
where you may have lots of small tasks of uneven size with complex
dependencies. Our application is automated program analysis
and transformation, where the scale of our artifacts are large
(systems of source code), and irregularity comes from the shape of the
data structures that represent it.
Today we are running 500K SLOC programs in generated PARLANSE programs
that run on Wintel boxes, to support our DMS Software Reengineering
Toolkit. They seem to scale nicely.
Compiling code for irregular parallelism is an interesting topic.
How do you identify the parallelism? How do you estimate the cost of
grains?
How do you schedule them on a small but indefinite number of CPUs?
How do you keep context switching time low enough to make it
worth the trouble? How do grains interact efficiently?
How do you handle exceptions that cross parallelism boundaries?
Efficiently? PARLANSE is a point answer in this space.
I'm sure there are other, but our particular experiment is just
beginning to be interesting.
--
Ira Baxter, CTO
www.semanticdesigns.com
| |
| Mayan Moudgill 2007-03-17, 7:14 pm |
| Yunzhi Xue wrote:
> I'm working on a survey of the development tendency of compilation
> technology. But there are too many issues and I am such a Green
> Hand. So could anybody please tell my about the possible major trend
> of compilation tech?
>
> Best wishes
> Yunzhi
> [So what's new in compilers this year? -John]
FWIW: changes in compilers arise when new language concepts are
introduced, or when application domains change, or when the target
changes, or when the compilation environment changes. (And, of course,
when the benchmarks change.)
In the last category (environment), I put changes such as:
- profile directed feedback
- JIT
- additional resources (memory/execution speed).
Unfortunately, while each of these had great impact on the practice of
compilers, they didn't have much impact on the theory. For instance,
greater resources enabled the wide-spread application of
resource-hungry optimization techniques that, in the past, could be
applied to only small snippets of code and/or in the largest
supercomputers.
Target changes arise when a new ISA is introduced, or an old one is
extended, and the ISA/extension is radically different. There is
little such change in the mainstream; the latest changes (ARM+Cortex,
PowerPC+Altivec, x86+SSE2) have all been simple SIMD extensions, with
nothing very challenging.
Out of the mainstream, it is not clear that the demand exists to
support a compiler effort that extends compiler technology. Consider
extensible architectures such as Tensilica or ARC: the different
extensions might be generally exploitable by a compiler. However, the
extensions are concieved of as accelerators for a single kernel, and
it makes more economic sense to rewrite that one kernel in assembler.
Three target changes which people have mentioned as possible drivers
of innovation are GPUs, FPGAs, and multi-core. These are all
interesting areas of research, with wide deployment of the
target. However, note that there is a fairly large amount of
compilation technology that is applicable to these targets. Obviously,
any innovations on multi-core have to be built on the prior history of
multi-processor compilation research. FPGA compilation can be viewed
as an instance of behavioral synthesis. I don't know enough about
current GPUs to comment.
Language feature changes can cause disruptions in compiler technology,
as it s s to exploit the information provided by the change (e.g.
restrict/type-aliasing in C) or to overcome a performance inhibitor
(e.g. virtual function calls in C++/Java etc.). A recent example of
research in this area is the streaming language stuff from
MIT/Stanford.
New languages are, in some cases, driven by focus on a new application
domain. Streaming, for instance, arises from multi-media/signal
processing applications. Of course, the new application domain must
have concepts that are not conveniently expressible in an existing
language, or in a minor extension to the existing
language. (Occaisionally, high-level languages are created to expose
the internals of the hardware - the graphics processing languages are
an instance of that.)
Of course, the fact that there is an opportunity for a compiler to do
something, does not mean that it is possible to implement that. For
instance, it may require a large amount of infrastructure that may not
be economically viable to implement.
Its very hard to come up with anything that drives real innovation in
the compiler area - our company, for instance, is building a compiler
that compiles from C to a multi-threaded/multi-core processor focused
on digital signal-processing algorithms. We're developed a
sophisticated compilation infrastructure. Despite all that, the number
of true innovations we've developed can be counted on the fingers of
one hand.
|
|
|
|
|