compiler: Keep the outer Dimension parallel on a short par-tile

When a multi `par-tile` entry is shorter than the blocked nest, the
innermost Dimensions consume the available block sizes and the outermost
one runs into a StopIteration. It was then dropped into `compact`, which
promotes it back to its root Dimension, discarding its BlockDimension.

On a device that is a serialization: the Dimension ends up outside the
blocked nest, `filter_iterations` rejects it as non-parallel, and the
kernel is launched over a 2D grid from a host loop iterating the outer
Dimension one slice at a time.

Block such a Dimension reusing the innermost block size instead, so that
it stays parallel. This applies to multi par-tiles only, since a single
user-supplied par-tile defines the block rank on purpose.

Author: mloubout

devito/passes/clusters/blocking.py

@@ -625,7 +625,8 @@ def apply_par_tiles(clusters, options, **kwargs):
     if not options['par-tile']:
         return clusters
 
-    blk_size_gen = BlockSizeGenerator(options['par-tile'])
+    par_tile = options['par-tile']
+    blk_size_gen = BlockSizeGenerator(par_tile)
 
     key = lambda c: c.ispace.project(lambda d: d.is_Block)
 
@@ -642,13 +643,21 @@ def apply_par_tiles(clusters, options, **kwargs):
 
         subs = {}
         compact = []
+        last = None
         for d in reversed(bdims):
             try:
-                step = sympify(umt.next())
-                subs.update(d._rebuild_hierarchy(step=step))
+                step = last = sympify(umt.next())
             except StopIteration:
-                # No more par-tile sizes available, so we drop the BlockDimensions
-                compact.append(d)
+                if last is None or not par_tile.is_multi or \
+                   not is_on_device(g[0].functions, options.get('gpu-fit', ())):
+                    # No more par-tile sizes available, so we drop the
+                    # BlockDimensions
+                    compact.append(d)
+                    continue
+                # On a device, dropping it would serialize `d`, so reuse the
+                # innermost block size instead
+                step = last
+            subs.update(d._rebuild_hierarchy(step=step))
 
         processed.extend(c.subs(subs, compact) for c in g)