Superblock optimizations

Hi,


couple of days ago, I've found a paper about the construction
of a "superblock"[1] and its use in compiler optimizations. The
superblock is built based on profiling data where frequently
executed paths are merged into an extended block by tail
duplication. This provides more instruction level parallelism
and is especially exploited by instruction schedulers for
superscalar and VLIW architectures.


The original work as well as any related works exploiting this data
structure use a compiler low-level intermediate representation
(host-dependent assembly-like representation) where they apply
optimizations like loop unrolling etc. Do you know any works/projects
which use compiler optimizations based on the superblock paradigm at
the source code (or host-independent intermediate representation)?


I'm asking since I'm curious if the idea of superblocks can be also
applied to the source code representation where basic blocks
are not clearly defined as they are for the low-level.


In general, I was wondering if there are any profile-based compiler
optimizations which are preformed at the source code level (high-level
IR)? Anything I've found so far (gcc optimizations, Sun compiler ...)
apply their profile-based stuff to low-level basic blocks. Did I
miss something or are there any significant reasons why the source code
level is not sufficient for this sort of optimizations? I mean when
you for example use for example gprof you also get the profiling data for
the source code, so I see no reason why optimizations at that level should
not profit from profiling data as well?


Best regards,
Tim


[1] The superblock: An effective technique for VLIW and
superscalar compilation - Wen -Mei W. Hwu et al.

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