diff --git a/include/polly/ScheduleOptimizer.h b/include/polly/ScheduleOptimizer.h
index cac1113..1056b74 100644
--- a/include/polly/ScheduleOptimizer.h
+++ b/include/polly/ScheduleOptimizer.h
@@ -10,66 +10,13 @@
 #define POLLY_SCHEDULEOPTIMIZER_H
 
 #include "polly/ScopPass.h"
-#include "llvm/ADT/ArrayRef.h"
-#include "isl/isl-noexceptions.h"
 
 namespace llvm {
 class Pass;
 class PassRegistry;
-class TargetTransformInfo;
 } // namespace llvm
 
-struct isl_schedule_node;
-
-/// Parameters of the micro kernel.
-///
-/// Parameters, which determine sizes of rank-1 (i.e., outer product) update
-/// used in the optimized matrix multiplication.
-struct MicroKernelParamsTy {
-  int Mr;
-  int Nr;
-};
-
-/// Parameters of the macro kernel.
-///
-/// Parameters, which determine sizes of blocks of partitioned matrices
-/// used in the optimized matrix multiplication.
-struct MacroKernelParamsTy {
-  int Mc;
-  int Nc;
-  int Kc;
-};
-
 namespace polly {
-struct Dependences;
-class MemoryAccess;
-class Scop;
-
-/// Additional parameters of the schedule optimizer.
-///
-/// Target Transform Info and the SCoP dependencies used by the schedule
-/// optimizer.
-struct OptimizerAdditionalInfoTy {
-  const llvm::TargetTransformInfo *TTI;
-  const Dependences *D;
-};
-
-/// Parameters of the matrix multiplication operands.
-///
-/// Parameters, which describe access relations that represent operands of the
-/// matrix multiplication.
-struct MatMulInfoTy {
-  MemoryAccess *A = nullptr;
-  MemoryAccess *B = nullptr;
-  MemoryAccess *ReadFromC = nullptr;
-  MemoryAccess *WriteToC = nullptr;
-  int i = -1;
-  int j = -1;
-  int k = -1;
-};
-
-extern bool DisablePollyTiling;
-
 llvm::Pass *createIslScheduleOptimizerWrapperPass();
 
 struct IslScheduleOptimizerPass
@@ -91,273 +38,6 @@
   llvm::raw_ostream &OS;
 };
 
-} // namespace polly
-
-namespace llvm {
-void initializeIslScheduleOptimizerWrapperPassPass(llvm::PassRegistry &);
-}
-
-class ScheduleTreeOptimizer {
-public:
-  /// Apply schedule tree transformations.
-  ///
-  /// This function takes an (possibly already optimized) schedule tree and
-  /// applies a set of additional optimizations on the schedule tree. The
-  /// transformations applied include:
-  ///
-  ///   - Tiling
-  ///   - Prevectorization
-  ///
-  /// @param Schedule The schedule object the transformations will be applied
-  ///                 to.
-  /// @param OAI      Target Transform Info and the SCoP dependencies.
-  /// @returns        The transformed schedule.
-  static isl::schedule
-  optimizeSchedule(isl::schedule Schedule,
-                   const polly::OptimizerAdditionalInfoTy *OAI = nullptr);
-
-  /// Apply schedule tree transformations.
-  ///
-  /// This function takes a node in an (possibly already optimized) schedule
-  /// tree and applies a set of additional optimizations on this schedule tree
-  /// node and its descendants. The transformations applied include:
-  ///
-  ///   - Tiling
-  ///   - Prevectorization
-  ///
-  /// @param Node The schedule object post-transformations will be applied to.
-  /// @param OAI  Target Transform Info and the SCoP dependencies.
-  /// @returns    The transformed schedule.
-  static isl::schedule_node
-  optimizeScheduleNode(isl::schedule_node Node,
-                       const polly::OptimizerAdditionalInfoTy *OAI = nullptr);
-
-  /// Decide if the @p NewSchedule is profitable for @p S.
-  ///
-  /// @param S           The SCoP we optimize.
-  /// @param NewSchedule The new schedule we computed.
-  ///
-  /// @return True, if we believe @p NewSchedule is an improvement for @p S.
-  static bool isProfitableSchedule(polly::Scop &S, isl::schedule NewSchedule);
-
-  /// Isolate a set of partial tile prefixes.
-  ///
-  /// This set should ensure that it contains only partial tile prefixes that
-  /// have exactly VectorWidth iterations.
-  ///
-  /// @param Node A schedule node band, which is a parent of a band node,
-  ///             that contains a vector loop.
-  /// @return Modified isl_schedule_node.
-  static isl::schedule_node isolateFullPartialTiles(isl::schedule_node Node,
-                                                    int VectorWidth);
-
-private:
-  /// Tile a schedule node.
-  ///
-  /// @param Node            The node to tile.
-  /// @param Identifier      An name that identifies this kind of tiling and
-  ///                        that is used to mark the tiled loops in the
-  ///                        generated AST.
-  /// @param TileSizes       A vector of tile sizes that should be used for
-  ///                        tiling.
-  /// @param DefaultTileSize A default tile size that is used for dimensions
-  ///                        that are not covered by the TileSizes vector.
-  static isl::schedule_node tileNode(isl::schedule_node Node,
-                                     const char *Identifier,
-                                     llvm::ArrayRef<int> TileSizes,
-                                     int DefaultTileSize);
-
-  /// Tile a schedule node and unroll point loops.
-  ///
-  /// @param Node            The node to register tile.
-  /// @param TileSizes       A vector of tile sizes that should be used for
-  ///                        tiling.
-  /// @param DefaultTileSize A default tile size that is used for dimensions
-  static isl::schedule_node applyRegisterTiling(isl::schedule_node Node,
-                                                llvm::ArrayRef<int> TileSizes,
-                                                int DefaultTileSize);
-
-  /// Apply the BLIS matmul optimization pattern.
-  ///
-  /// Make the loops containing the matrix multiplication be the innermost
-  /// loops and apply the BLIS matmul optimization pattern. BLIS implements
-  /// gemm as three nested loops around a macro-kernel, plus two packing
-  /// routines. The macro-kernel is implemented in terms of two additional
-  /// loops around a micro-kernel. The micro-kernel is a loop around a rank-1
-  /// (i.e., outer product) update.
-  ///
-  /// For a detailed description please see [1].
-  ///
-  /// The order of the loops defines the data reused in the BLIS implementation
-  /// of gemm ([1]). In particular, elements of the matrix B, the second
-  /// operand of matrix multiplication, are reused between iterations of the
-  /// innermost loop. To keep the reused data in cache, only elements of matrix
-  /// A, the first operand of matrix multiplication, should be evicted during
-  /// an iteration of the innermost loop. To provide such a cache replacement
-  /// policy, elements of the matrix A can, in particular, be loaded first and,
-  /// consequently, be least-recently-used.
-  ///
-  /// In our case matrices are stored in row-major order instead of
-  /// column-major order used in the BLIS implementation ([1]). It affects only
-  /// on the form of the BLIS micro kernel and the computation of its
-  /// parameters. In particular, reused elements of the matrix B are
-  /// successively multiplied by specific elements of the matrix A.
-  ///
-  /// Refs.:
-  /// [1] - Analytical Modeling is Enough for High Performance BLIS
-  /// Tze Meng Low, Francisco D Igual, Tyler M Smith, Enrique S Quintana-Orti
-  /// Technical Report, 2014
-  /// http://www.cs.utexas.edu/users/flame/pubs/TOMS-BLIS-Analytical.pdf
-  ///
-  /// @see ScheduleTreeOptimizer::createMicroKernel
-  /// @see ScheduleTreeOptimizer::createMacroKernel
-  /// @see getMicroKernelParams
-  /// @see getMacroKernelParams
-  ///
-  /// TODO: Implement the packing transformation.
-  ///
-  /// @param Node The node that contains a band to be optimized. The node
-  ///             is required to successfully pass
-  ///             ScheduleTreeOptimizer::isMatrMultPattern.
-  /// @param TTI  Target Transform Info.
-  /// @param MMI  Parameters of the matrix multiplication operands.
-  /// @returns    The transformed schedule.
-  static isl::schedule_node
-  optimizeMatMulPattern(isl::schedule_node Node,
-                        const llvm::TargetTransformInfo *TTI,
-                        polly::MatMulInfoTy &MMI);
-
-  /// Check if this node is a band node we want to tile.
-  ///
-  /// We look for innermost band nodes where individual dimensions are marked as
-  /// permutable.
-  ///
-  /// @param Node The node to check.
-  static bool isTileableBandNode(isl::schedule_node Node);
-
-  /// Pre-vectorizes one scheduling dimension of a schedule band.
-  ///
-  /// prevectSchedBand splits out the dimension DimToVectorize, tiles it and
-  /// sinks the resulting point loop.
-  ///
-  /// Example (DimToVectorize=0, VectorWidth=4):
-  ///
-  /// | Before transformation:
-  /// |
-  /// | A[i,j] -> [i,j]
-  /// |
-  /// | for (i = 0; i < 128; i++)
-  /// |    for (j = 0; j < 128; j++)
-  /// |      A(i,j);
-  ///
-  /// | After transformation:
-  /// |
-  /// | for (it = 0; it < 32; it+=1)
-  /// |    for (j = 0; j < 128; j++)
-  /// |      for (ip = 0; ip <= 3; ip++)
-  /// |        A(4 * it + ip,j);
-  ///
-  /// The goal of this transformation is to create a trivially vectorizable
-  /// loop.  This means a parallel loop at the innermost level that has a
-  /// constant number of iterations corresponding to the target vector width.
-  ///
-  /// This transformation creates a loop at the innermost level. The loop has
-  /// a constant number of iterations, if the number of loop iterations at
-  /// DimToVectorize can be divided by VectorWidth. The default VectorWidth is
-  /// currently constant and not yet target specific. This function does not
-  /// reason about parallelism.
-  static isl::schedule_node prevectSchedBand(isl::schedule_node Node,
-                                             unsigned DimToVectorize,
-                                             int VectorWidth);
-
-  /// Apply additional optimizations on the bands in the schedule tree.
-  ///
-  /// We are looking for an innermost band node and apply the following
-  /// transformations:
-  ///
-  ///  - Tile the band
-  ///      - if the band is tileable
-  ///      - if the band has more than one loop dimension
-  ///
-  ///  - Prevectorize the schedule of the band (or the point loop in case of
-  ///    tiling).
-  ///      - if vectorization is enabled
-  ///
-  /// @param Node The schedule node to (possibly) optimize.
-  /// @param User A pointer to forward some use information
-  ///        (currently unused).
-  static isl_schedule_node *optimizeBand(isl_schedule_node *Node, void *User);
-
-  /// Apply additional optimizations on the bands in the schedule tree.
-  ///
-  /// We apply the following
-  /// transformations:
-  ///
-  ///  - Tile the band
-  ///  - Prevectorize the schedule of the band (or the point loop in case of
-  ///    tiling).
-  ///      - if vectorization is enabled
-  ///
-  /// @param Node The schedule node to (possibly) optimize.
-  /// @param User A pointer to forward some use information
-  ///        (currently unused).
-  static isl::schedule_node standardBandOpts(isl::schedule_node Node,
-                                             void *User);
-
-  /// Check if this node contains a partial schedule that could
-  ///        probably be optimized with analytical modeling.
-  ///
-  /// isMatrMultPattern tries to determine whether the following conditions
-  /// are true:
-  /// 1. the partial schedule contains only one statement.
-  /// 2. there are exactly three input dimensions.
-  /// 3. all memory accesses of the statement will have stride 0 or 1, if we
-  ///    interchange loops (switch the variable used in the inner loop to
-  ///    the outer loop).
-  /// 4. all memory accesses of the statement except from the last one, are
-  ///    read memory access and the last one is write memory access.
-  /// 5. all subscripts of the last memory access of the statement don't
-  ///    contain the variable used in the inner loop.
-  /// If this is the case, we could try to use an approach that is similar to
-  /// the one used to get close-to-peak performance of matrix multiplications.
-  ///
-  /// @param Node The node to check.
-  /// @param D    The SCoP dependencies.
-  /// @param MMI  Parameters of the matrix multiplication operands.
-  static bool isMatrMultPattern(isl::schedule_node Node,
-                                const polly::Dependences *D,
-                                polly::MatMulInfoTy &MMI);
-
-  /// Create the BLIS macro-kernel.
-  ///
-  /// We create the BLIS macro-kernel by applying a combination of tiling
-  /// of dimensions of the band node and interchanging of two innermost
-  /// modified dimensions. The values of of MacroKernelParams's fields are used
-  /// as tile sizes.
-  ///
-  /// @param Node The schedule node to be modified.
-  /// @param MacroKernelParams Parameters of the macro kernel
-  ///                          to be used as tile sizes.
-  static isl::schedule_node
-  createMacroKernel(isl::schedule_node Node,
-                    MacroKernelParamsTy MacroKernelParams);
-
-  /// Create the BLIS macro-kernel.
-  ///
-  /// We create the BLIS macro-kernel by applying a combination of tiling
-  /// of dimensions of the band node and interchanging of two innermost
-  /// modified dimensions. The values passed in MicroKernelParam are used
-  /// as tile sizes.
-  ///
-  /// @param Node The schedule node to be modified.
-  /// @param MicroKernelParams Parameters of the micro kernel
-  ///                          to be used as tile sizes.
-  /// @see MicroKernelParamsTy
-  static isl::schedule_node
-  createMicroKernel(isl::schedule_node Node,
-                    MicroKernelParamsTy MicroKernelParams);
-};
-
 /// Build the desired set of partial tile prefixes.
 ///
 /// We build a set of partial tile prefixes, which are prefixes of the vector
@@ -377,4 +57,10 @@
 /// @param ScheduleRange A range of a map, which describes a prefix schedule
 ///                      relation.
 isl::set getPartialTilePrefixes(isl::set ScheduleRange, int VectorWidth);
+} // namespace polly
+
+namespace llvm {
+void initializeIslScheduleOptimizerWrapperPassPass(llvm::PassRegistry &);
+}
+
 #endif // POLLY_SCHEDULEOPTIMIZER_H
diff --git a/lib/Transform/ScheduleOptimizer.cpp b/lib/Transform/ScheduleOptimizer.cpp
index 96248d7..9849f84 100644
--- a/lib/Transform/ScheduleOptimizer.cpp
+++ b/lib/Transform/ScheduleOptimizer.cpp
@@ -295,6 +295,311 @@
 STATISTIC(MatMulOpts,
           "Number of matrix multiplication patterns detected and optimized");
 
+namespace {
+/// Parameters of the micro kernel.
+///
+/// Parameters, which determine sizes of rank-1 (i.e., outer product) update
+/// used in the optimized matrix multiplication.
+struct MicroKernelParamsTy {
+  int Mr;
+  int Nr;
+};
+
+/// Parameters of the macro kernel.
+///
+/// Parameters, which determine sizes of blocks of partitioned matrices
+/// used in the optimized matrix multiplication.
+struct MacroKernelParamsTy {
+  int Mc;
+  int Nc;
+  int Kc;
+};
+
+/// Additional parameters of the schedule optimizer.
+///
+/// Target Transform Info and the SCoP dependencies used by the schedule
+/// optimizer.
+struct OptimizerAdditionalInfoTy {
+  const llvm::TargetTransformInfo *TTI;
+  const Dependences *D;
+};
+
+/// Parameters of the matrix multiplication operands.
+///
+/// Parameters, which describe access relations that represent operands of the
+/// matrix multiplication.
+struct MatMulInfoTy {
+  MemoryAccess *A = nullptr;
+  MemoryAccess *B = nullptr;
+  MemoryAccess *ReadFromC = nullptr;
+  MemoryAccess *WriteToC = nullptr;
+  int i = -1;
+  int j = -1;
+  int k = -1;
+};
+
+extern bool DisablePollyTiling;
+
+class ScheduleTreeOptimizer {
+public:
+  /// Apply schedule tree transformations.
+  ///
+  /// This function takes an (possibly already optimized) schedule tree and
+  /// applies a set of additional optimizations on the schedule tree. The
+  /// transformations applied include:
+  ///
+  ///   - Tiling
+  ///   - Prevectorization
+  ///
+  /// @param Schedule The schedule object the transformations will be applied
+  ///                 to.
+  /// @param OAI      Target Transform Info and the SCoP dependencies.
+  /// @returns        The transformed schedule.
+  static isl::schedule
+  optimizeSchedule(isl::schedule Schedule,
+                   const OptimizerAdditionalInfoTy *OAI = nullptr);
+
+  /// Apply schedule tree transformations.
+  ///
+  /// This function takes a node in an (possibly already optimized) schedule
+  /// tree and applies a set of additional optimizations on this schedule tree
+  /// node and its descendants. The transformations applied include:
+  ///
+  ///   - Tiling
+  ///   - Prevectorization
+  ///
+  /// @param Node The schedule object post-transformations will be applied to.
+  /// @param OAI  Target Transform Info and the SCoP dependencies.
+  /// @returns    The transformed schedule.
+  static isl::schedule_node
+  optimizeScheduleNode(isl::schedule_node Node,
+                       const OptimizerAdditionalInfoTy *OAI = nullptr);
+
+  /// Decide if the @p NewSchedule is profitable for @p S.
+  ///
+  /// @param S           The SCoP we optimize.
+  /// @param NewSchedule The new schedule we computed.
+  ///
+  /// @return True, if we believe @p NewSchedule is an improvement for @p S.
+  static bool isProfitableSchedule(polly::Scop &S, isl::schedule NewSchedule);
+
+  /// Isolate a set of partial tile prefixes.
+  ///
+  /// This set should ensure that it contains only partial tile prefixes that
+  /// have exactly VectorWidth iterations.
+  ///
+  /// @param Node A schedule node band, which is a parent of a band node,
+  ///             that contains a vector loop.
+  /// @return Modified isl_schedule_node.
+  static isl::schedule_node isolateFullPartialTiles(isl::schedule_node Node,
+                                                    int VectorWidth);
+
+private:
+  /// Tile a schedule node.
+  ///
+  /// @param Node            The node to tile.
+  /// @param Identifier      An name that identifies this kind of tiling and
+  ///                        that is used to mark the tiled loops in the
+  ///                        generated AST.
+  /// @param TileSizes       A vector of tile sizes that should be used for
+  ///                        tiling.
+  /// @param DefaultTileSize A default tile size that is used for dimensions
+  ///                        that are not covered by the TileSizes vector.
+  static isl::schedule_node tileNode(isl::schedule_node Node,
+                                     const char *Identifier,
+                                     llvm::ArrayRef<int> TileSizes,
+                                     int DefaultTileSize);
+
+  /// Tile a schedule node and unroll point loops.
+  ///
+  /// @param Node            The node to register tile.
+  /// @param TileSizes       A vector of tile sizes that should be used for
+  ///                        tiling.
+  /// @param DefaultTileSize A default tile size that is used for dimensions
+  static isl::schedule_node applyRegisterTiling(isl::schedule_node Node,
+                                                llvm::ArrayRef<int> TileSizes,
+                                                int DefaultTileSize);
+
+  /// Apply the BLIS matmul optimization pattern.
+  ///
+  /// Make the loops containing the matrix multiplication be the innermost
+  /// loops and apply the BLIS matmul optimization pattern. BLIS implements
+  /// gemm as three nested loops around a macro-kernel, plus two packing
+  /// routines. The macro-kernel is implemented in terms of two additional
+  /// loops around a micro-kernel. The micro-kernel is a loop around a rank-1
+  /// (i.e., outer product) update.
+  ///
+  /// For a detailed description please see [1].
+  ///
+  /// The order of the loops defines the data reused in the BLIS implementation
+  /// of gemm ([1]). In particular, elements of the matrix B, the second
+  /// operand of matrix multiplication, are reused between iterations of the
+  /// innermost loop. To keep the reused data in cache, only elements of matrix
+  /// A, the first operand of matrix multiplication, should be evicted during
+  /// an iteration of the innermost loop. To provide such a cache replacement
+  /// policy, elements of the matrix A can, in particular, be loaded first and,
+  /// consequently, be least-recently-used.
+  ///
+  /// In our case matrices are stored in row-major order instead of
+  /// column-major order used in the BLIS implementation ([1]). It affects only
+  /// on the form of the BLIS micro kernel and the computation of its
+  /// parameters. In particular, reused elements of the matrix B are
+  /// successively multiplied by specific elements of the matrix A.
+  ///
+  /// Refs.:
+  /// [1] - Analytical Modeling is Enough for High Performance BLIS
+  /// Tze Meng Low, Francisco D Igual, Tyler M Smith, Enrique S Quintana-Orti
+  /// Technical Report, 2014
+  /// http://www.cs.utexas.edu/users/flame/pubs/TOMS-BLIS-Analytical.pdf
+  ///
+  /// @see ScheduleTreeOptimizer::createMicroKernel
+  /// @see ScheduleTreeOptimizer::createMacroKernel
+  /// @see getMicroKernelParams
+  /// @see getMacroKernelParams
+  ///
+  /// TODO: Implement the packing transformation.
+  ///
+  /// @param Node The node that contains a band to be optimized. The node
+  ///             is required to successfully pass
+  ///             ScheduleTreeOptimizer::isMatrMultPattern.
+  /// @param TTI  Target Transform Info.
+  /// @param MMI  Parameters of the matrix multiplication operands.
+  /// @returns    The transformed schedule.
+  static isl::schedule_node
+  optimizeMatMulPattern(isl::schedule_node Node,
+                        const llvm::TargetTransformInfo *TTI,
+                        MatMulInfoTy &MMI);
+
+  /// Check if this node is a band node we want to tile.
+  ///
+  /// We look for innermost band nodes where individual dimensions are marked as
+  /// permutable.
+  ///
+  /// @param Node The node to check.
+  static bool isTileableBandNode(isl::schedule_node Node);
+
+  /// Pre-vectorizes one scheduling dimension of a schedule band.
+  ///
+  /// prevectSchedBand splits out the dimension DimToVectorize, tiles it and
+  /// sinks the resulting point loop.
+  ///
+  /// Example (DimToVectorize=0, VectorWidth=4):
+  ///
+  /// | Before transformation:
+  /// |
+  /// | A[i,j] -> [i,j]
+  /// |
+  /// | for (i = 0; i < 128; i++)
+  /// |    for (j = 0; j < 128; j++)
+  /// |      A(i,j);
+  ///
+  /// | After transformation:
+  /// |
+  /// | for (it = 0; it < 32; it+=1)
+  /// |    for (j = 0; j < 128; j++)
+  /// |      for (ip = 0; ip <= 3; ip++)
+  /// |        A(4 * it + ip,j);
+  ///
+  /// The goal of this transformation is to create a trivially vectorizable
+  /// loop.  This means a parallel loop at the innermost level that has a
+  /// constant number of iterations corresponding to the target vector width.
+  ///
+  /// This transformation creates a loop at the innermost level. The loop has
+  /// a constant number of iterations, if the number of loop iterations at
+  /// DimToVectorize can be divided by VectorWidth. The default VectorWidth is
+  /// currently constant and not yet target specific. This function does not
+  /// reason about parallelism.
+  static isl::schedule_node prevectSchedBand(isl::schedule_node Node,
+                                             unsigned DimToVectorize,
+                                             int VectorWidth);
+
+  /// Apply additional optimizations on the bands in the schedule tree.
+  ///
+  /// We are looking for an innermost band node and apply the following
+  /// transformations:
+  ///
+  ///  - Tile the band
+  ///      - if the band is tileable
+  ///      - if the band has more than one loop dimension
+  ///
+  ///  - Prevectorize the schedule of the band (or the point loop in case of
+  ///    tiling).
+  ///      - if vectorization is enabled
+  ///
+  /// @param Node The schedule node to (possibly) optimize.
+  /// @param User A pointer to forward some use information
+  ///        (currently unused).
+  static isl_schedule_node *optimizeBand(isl_schedule_node *Node, void *User);
+
+  /// Apply additional optimizations on the bands in the schedule tree.
+  ///
+  /// We apply the following
+  /// transformations:
+  ///
+  ///  - Tile the band
+  ///  - Prevectorize the schedule of the band (or the point loop in case of
+  ///    tiling).
+  ///      - if vectorization is enabled
+  ///
+  /// @param Node The schedule node to (possibly) optimize.
+  /// @param User A pointer to forward some use information
+  ///        (currently unused).
+  static isl::schedule_node standardBandOpts(isl::schedule_node Node,
+                                             void *User);
+
+  /// Check if this node contains a partial schedule that could
+  ///        probably be optimized with analytical modeling.
+  ///
+  /// isMatrMultPattern tries to determine whether the following conditions
+  /// are true:
+  /// 1. the partial schedule contains only one statement.
+  /// 2. there are exactly three input dimensions.
+  /// 3. all memory accesses of the statement will have stride 0 or 1, if we
+  ///    interchange loops (switch the variable used in the inner loop to
+  ///    the outer loop).
+  /// 4. all memory accesses of the statement except from the last one, are
+  ///    read memory access and the last one is write memory access.
+  /// 5. all subscripts of the last memory access of the statement don't
+  ///    contain the variable used in the inner loop.
+  /// If this is the case, we could try to use an approach that is similar to
+  /// the one used to get close-to-peak performance of matrix multiplications.
+  ///
+  /// @param Node The node to check.
+  /// @param D    The SCoP dependencies.
+  /// @param MMI  Parameters of the matrix multiplication operands.
+  static bool isMatrMultPattern(isl::schedule_node Node,
+                                const polly::Dependences *D, MatMulInfoTy &MMI);
+
+  /// Create the BLIS macro-kernel.
+  ///
+  /// We create the BLIS macro-kernel by applying a combination of tiling
+  /// of dimensions of the band node and interchanging of two innermost
+  /// modified dimensions. The values of of MacroKernelParams's fields are used
+  /// as tile sizes.
+  ///
+  /// @param Node The schedule node to be modified.
+  /// @param MacroKernelParams Parameters of the macro kernel
+  ///                          to be used as tile sizes.
+  static isl::schedule_node
+  createMacroKernel(isl::schedule_node Node,
+                    MacroKernelParamsTy MacroKernelParams);
+
+  /// Create the BLIS macro-kernel.
+  ///
+  /// We create the BLIS macro-kernel by applying a combination of tiling
+  /// of dimensions of the band node and interchanging of two innermost
+  /// modified dimensions. The values passed in MicroKernelParam are used
+  /// as tile sizes.
+  ///
+  /// @param Node The schedule node to be modified.
+  /// @param MicroKernelParams Parameters of the micro kernel
+  ///                          to be used as tile sizes.
+  /// @see MicroKernelParamsTy
+  static isl::schedule_node
+  createMicroKernel(isl::schedule_node Node,
+                    MicroKernelParamsTy MicroKernelParams);
+};
+
 /// Create an isl::union_set, which describes the isolate option based on
 /// IsolateDomain.
 ///
@@ -319,7 +624,6 @@
   return isl::union_set(IsolateOption);
 }
 
-namespace {
 /// Create an isl::union_set, which describes the specified option for the
 /// dimension of the current node.
 ///
@@ -332,7 +636,6 @@
   DimOption = DimOption.set_tuple_id(Id);
   return isl::union_set(DimOption);
 }
-} // namespace
 
 /// Create an isl::union_set, which describes the option of the form
 /// [isolate[] -> unroll[x]].
@@ -367,8 +670,10 @@
   ExtConstr = ExtConstr.set_coefficient_si(isl::dim::set, Dims - 1, -1);
   return Set.add_constraint(ExtConstr);
 }
+} // namespace
 
-isl::set getPartialTilePrefixes(isl::set ScheduleRange, int VectorWidth) {
+isl::set polly::getPartialTilePrefixes(isl::set ScheduleRange,
+                                       int VectorWidth) {
   unsigned Dims = ScheduleRange.dim(isl::dim::set);
   isl::set LoopPrefixes =
       ScheduleRange.drop_constraints_involving_dims(isl::dim::set, Dims - 1, 1);
@@ -379,6 +684,7 @@
   return LoopPrefixes.subtract(BadPrefixes);
 }
 
+namespace {
 isl::schedule_node
 ScheduleTreeOptimizer::isolateFullPartialTiles(isl::schedule_node Node,
                                                int VectorWidth) {
@@ -918,7 +1224,6 @@
   return {Mr, Nr};
 }
 
-namespace {
 /// Determine parameters of the target cache.
 ///
 /// @param TTI Target Transform Info.
@@ -954,7 +1259,6 @@
           static_cast<int>(SecondCacheLevelDefaultAssociativity);
   }
 }
-} // namespace
 
 /// Get parameters of the BLIS macro kernel.
 ///
@@ -1381,8 +1685,6 @@
   return changed;
 }
 
-namespace {
-
 class IslScheduleOptimizerWrapperPass : public ScopPass {
 public:
   static char ID;
@@ -1410,7 +1712,6 @@
   std::shared_ptr<isl_ctx> IslCtx;
   isl::schedule LastSchedule;
 };
-} // namespace
 
 char IslScheduleOptimizerWrapperPass::ID = 0;
 
@@ -1692,6 +1993,8 @@
   AU.addPreserved<DependenceInfo>();
 }
 
+} // namespace
+
 Pass *polly::createIslScheduleOptimizerWrapperPass() {
   return new IslScheduleOptimizerWrapperPass();
 }
diff --git a/unittests/ScheduleOptimizer/ScheduleOptimizerTest.cpp b/unittests/ScheduleOptimizer/ScheduleOptimizerTest.cpp
index b7fed0b..daa59cd 100644
--- a/unittests/ScheduleOptimizer/ScheduleOptimizerTest.cpp
+++ b/unittests/ScheduleOptimizer/ScheduleOptimizerTest.cpp
@@ -12,6 +12,8 @@
 #include "isl/val.h"
 
 using namespace isl;
+using namespace polly;
+
 namespace {
 
 TEST(ScheduleOptimizer, getPartialTilePrefixes) {