\usepackage{listings}
\usepackage{hyperref}
+\usepackage{xspace}
+\newcommand\PIPS{PIPS\xspace}
-\title{PIPS~--- List of code transformations}
+
+\title{\PIPS~--- List of code transformations}
\section{SGuelton}
\begin{itemize}
+% memory allocation alteration
+\item scalar renaming
+% loop transformations
\item loop unrolling
-\item inlining
-\item forward substitution
\item loop fusion
\item loop tiling
-\item reduction detection
-\item parallelism detection
-\item parallelism extraction
-\item directive generation
-\item constant propagation
-\item instruction selection
-\item goto elimination
-\item outlining
-\item common subexpression elimination
+\item loop rerolling
\item loop interchange
-\item loop unszitching
-\item statement isolation
+\item loop normalization
+% inter procedural transformations
+\item inlining
+% basic bloc transformations
+\item forward substitution
+% dead code removal
+\item constant propagation
\item dead code elimination
+
+% ??
\item array linearization
-\item privatization
-\item loop normalization
-\item iteration clamping
+\item common subexpression elimination
+\item directive generation
\item flatten code
-\item strengh reduction
-\item split update operator
-\item n adress code generation
+\item goto elimination
+\item instruction selection
+\item invariant code motion
+\item iteration clamping
+\item loop unswitching
\item memory footprint reduction
+\item n adress code generation
+\item outlining
+\item parallelism detection
+\item parallelism extraction
+\item privatization
+\item reduction detection
\item redundant load-store elimination
-\item invariant code motion
-\item scalar renaming
-\item loop rerolling
+\item split update operator
+\item statement isolation
+\item strengh reduction
\end{itemize}
\section{Teraops}
\begin{itemize}
+% memory allocation alteration
\item scalar renaming
\item scalar/array expansion
\item scalar/array privatization
\item scalarization
\item variable copying
+% loop transformations
\item index set splitting
\item loop peeling
\item loop unrolling
\item loop invariant code motion
\item software pipelining
\item locality increazing
+% inter procedural transformations
\item loop embedding/loop jamming
\item procedure inlining
\item procedure cloning
+% basic bloc transformations
\item node splitting
\item forward expression substitution
\item induction variable substitution
\item statement reordering
\item expression optimization
\item partial redundancy elimination
+% dead code removal
\item unreachable code
\item semantically uneachable code
\item if and loop elimination
\item constant propagation
\end{itemize}
-\chapter{List of Pips transformations}
+\chapter{List of \PIPS transformations}
\section{Memory allocation alteration}
\begin{description}
\item[loop unrolling]{
- is a loop transformation.
- Unrolling a loop by a factor of $n$ consists in the substitution of a loop
- body by itself, replicated $n$ times. A prelude and/or postlude are
+ is a loop transformation.
+ Unrolling a loop by a factor of \(n\) consists in the substitution of a loop
+ body by itself, replicated \(n\) times. A prelude and/or postlude are
added to preserve the number of iteration.}
\item[loop fusion]{
containing the loop without the test in both true and false branch.}
\item[loop normalization]{is a loop transformation that changes
- the loop initial increment value or the loop range to enforce certain values,
+ the loop initial increment value or the loop range to enforce certain values,
generally~1.}
\end{description}
\item[goto elimination]{
is the process of replacing \texttt{goto} instructions by a hierarchical control flow
graph.}
+
\item[outlining]{
is the process of extracting part of a function body into a new function
and replacing it in the initial function by a function call.}
operator by its expanded form.}
\item[n address code generation]{is the process of splitting
- complex expression in simpler ones that take at most $n$ operands.}
+ complex expression in simpler ones that take at most \(n\) operands.}
\item[memory footprint reduction]{is the process of tiling a loop
to make sure the iteration over the tile has a memory footprint bounded by