Loop ROLLING

I'm looking for information on loop ROLLING, and no-one I've talked to can
recall seeing anything specific about this topic. Why, you ask?


Well, consider the following scenario:


Peter Programmer writes a FORTRAN (or other language) application for the
BitMuncher/1970. The compiler Peter is using (for whatever reason - could
be a bug, or just something the optimizer doesn't do) doesn't unroll
loops. Since this application is used A LOT, Peter wants to improve the
performance of his code. So he digs out his architecture manual, looks at
the expanded listings, and decides that if he unrolls the loop BY HAND, he
can speed the whole thing up, and tunes the application to both the
compiler and the machine.


Time passes, Peter moves to a new job, and the BitMuncher/1970 finally
goes to the great chip factory in the sky. Which means that to use said
application, it may need to be recompiled (depending on upwards
compatability, etc). It is conceivable that the performance for the
application (due to compiler, architecture, and hand-unrolling) could be
WORSE on the new machine than it was on the old machine. Which means that
to tune the source for the new machine, the new victim (oops, programmer)
would need to become familiar with the compiler used, and the architecture
in question.


But if the optimizer were smart enough to roll the hand-unrolled mess back
into a single loop, and then unroll the loop in a fashion which was
optimal for the architecture, some of these headaches disappear. I would
think that code originally written with vectorizing machines could also
fall into this category when [back-]ported to a uniprocessor.


So, basically, I'm looking for information on loop rolling, or re-rolling
and then unrolling, and also wondering if any compilers currently out
there in the field actually do this.


Richard Gorton rcg@lpi.liant.com (508) 626-0006
Liant Software Corp. Framingham, MA 01760 USA
--

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