compiler: Implement integer block shapes

devito/core/cpu.py

@@ -1,6 +1,6 @@
 from functools import partial
 
-from devito.core.operator import CoreOperator, CustomOperator
+from devito.core.operator import CoreOperator, CustomOperator, ParTile
 from devito.exceptions import InvalidOperator
 from devito.passes.equations import collect_derivatives
 from devito.passes.clusters import (Lift, blocking, buffering, cire, cse,
@@ -34,11 +34,6 @@ class Cpu64OperatorMixin(object):
     situations where the performance impact might be detrimental.
     """
 
-    BLOCK_STEP = None
-    """
-    The loop blocking step size. None => symbolic.
-    """
-
     CIRE_MINGAIN = 10
     """
     Minimum operation count reduction for a redundant expression to be optimized
@@ -103,8 +98,8 @@ def _normalize_kwargs(cls, **kwargs):
         o['blockeager'] = oo.pop('blockeager', cls.BLOCK_EAGER)
         o['blocklazy'] = oo.pop('blocklazy', not o['blockeager'])
         o['blockrelax'] = oo.pop('blockrelax', cls.BLOCK_RELAX)
-        o['blockstep'] = oo.pop('blockstep', cls.BLOCK_STEP)
         o['skewing'] = oo.pop('skewing', False)
+        o['par-tile'] = ParTile(oo.pop('par-tile', False), default=16)
 
         # CIRE
         o['min-storage'] = oo.pop('min-storage', False)
@@ -193,7 +188,7 @@ def _specialize_clusters(cls, clusters, **kwargs):
 
         # Blocking to improve data locality
         if options['blockeager']:
-            clusters = blocking(clusters, options)
+            clusters = blocking(clusters, sregistry, options)
 
         # Reduce flops
         clusters = extract_increments(clusters, sregistry)
@@ -209,7 +204,7 @@ def _specialize_clusters(cls, clusters, **kwargs):
 
         # Blocking to improve data locality
         if options['blocklazy']:
-            clusters = blocking(clusters, options)
+            clusters = blocking(clusters, sregistry, options)
 
         return clusters
 
@@ -292,7 +287,7 @@ def callback(f):
 
         return {
             'buffering': lambda i: buffering(i, callback, sregistry, options),
-            'blocking': lambda i: blocking(i, options),
+            'blocking': lambda i: blocking(i, sregistry, options),
             'factorize': factorize,
             'fission': fission,
             'fuse': lambda i: fuse(i, options=options),

devito/core/gpu.py

@@ -2,7 +2,7 @@
 
 import numpy as np
 
-from devito.core.operator import CoreOperator, CustomOperator
+from devito.core.operator import CoreOperator, CustomOperator, ParTile
 from devito.exceptions import InvalidOperator
 from devito.passes.equations import collect_derivatives
 from devito.passes.clusters import (Lift, Streaming, Tasker, blocking, buffering,
@@ -37,11 +37,6 @@ class DeviceOperatorMixin(object):
     situations where the performance impact might be detrimental.
     """
 
-    BLOCK_STEP = None
-    """
-    The loop blocking step size. None => symbolic.
-    """
-
     CIRE_MINGAIN = 10
     """
     Minimum operation count reduction for a redundant expression to be optimized
@@ -86,7 +81,6 @@ def _normalize_kwargs(cls, **kwargs):
         o['blockeager'] = oo.pop('blockeager', cls.BLOCK_EAGER)
         o['blocklazy'] = oo.pop('blocklazy', not o['blockeager'])
         o['blockrelax'] = oo.pop('blockrelax', cls.BLOCK_RELAX)
-        o['blockstep'] = oo.pop('blockstep', cls.BLOCK_STEP)
         o['skewing'] = oo.pop('skewing', False)
 
         # CIRE
@@ -98,7 +92,7 @@ def _normalize_kwargs(cls, **kwargs):
         o['cire-schedule'] = oo.pop('cire-schedule', cls.CIRE_SCHEDULE)
 
         # GPU parallelism
-        o['par-tile'] = oo.pop('par-tile', False)  # Control tile parallelism
+        o['par-tile'] = ParTile(oo.pop('par-tile', False), default=(32, 4))
         o['par-collapse-ncores'] = 1  # Always collapse (meaningful if `par-tile=False`)
         o['par-collapse-work'] = 1  # Always collapse (meaningful if `par-tile=False`)
         o['par-chunk-nonaffine'] = oo.pop('par-chunk-nonaffine', cls.PAR_CHUNK_NONAFFINE)
@@ -183,7 +177,7 @@ def _specialize_clusters(cls, clusters, **kwargs):
 
         # Blocking to define thread blocks
         if options['blockeager']:
-            clusters = blocking(clusters, options)
+            clusters = blocking(clusters, sregistry, options)
 
         # Reduce flops
         clusters = extract_increments(clusters, sregistry)
@@ -199,7 +193,7 @@ def _specialize_clusters(cls, clusters, **kwargs):
 
         # Blocking to define thread blocks
         if options['blocklazy']:
-            clusters = blocking(clusters, options)
+            clusters = blocking(clusters, sregistry, options)
 
         return clusters
 
@@ -270,7 +264,7 @@ def callback(f):
 
         return {
             'buffering': lambda i: buffering(i, callback, sregistry, options),
-            'blocking': lambda i: blocking(i, options),
+            'blocking': lambda i: blocking(i, sregistry, options),
             'tasking': Tasker(runs_on_host).process,
             'streaming': Streaming(reads_if_on_host).process,
             'factorize': factorize,

devito/core/operator.py

@@ -3,10 +3,12 @@
 from devito.logger import warning
 from devito.parameters import configuration
 from devito.operator import Operator
-from devito.tools import as_tuple, timed_pass
+from devito.tools import as_tuple, is_integer, timed_pass
 from devito.types import NThreads
 
-__all__ = ['CoreOperator', 'CustomOperator']
+__all__ = ['CoreOperator', 'CustomOperator',
+           # Optimization options
+           'ParTile']
 
 
 class BasicOperator(Operator):
@@ -208,3 +210,31 @@ def _specialize_iet(cls, graph, **kwargs):
             passes_mapper['linearize'](graph)
 
         return graph
+
+
+# Wrappers for optimization options
+
+
+class OptOption(object):
+    pass
+
+
+class ParTile(tuple, OptOption):
+
+    def __new__(cls, items, default=None):
+        if not items:
+            return None
+        elif isinstance(items, bool):
+            if not default:
+                raise ValueError("Expected `default` value, got None")
+            items = (as_tuple(default),)
+        elif isinstance(items, tuple):
+            # Normalize to tuple of tuples
+            if is_integer(items[0]):
+                items = (items,)
+            else:
+                items = tuple(tuple(i) for i in items)
+        else:
+            raise ValueError("Expected bool or tuple, got %s instead" % type(items))
+
+        return super().__new__(cls, items)

devito/ir/clusters/queue.py

@@ -57,7 +57,7 @@ def _process_fdta(self, clusters, level, prefix=None, **kwargs):
 
         return processed
 
-    def _process_fatd(self, clusters, level, **kwargs):
+    def _process_fatd(self, clusters, level, prefix=None, **kwargs):
         """
         fatd -> First Apply Then Divide
         """
@@ -72,7 +72,7 @@ def _process_fatd(self, clusters, level, **kwargs):
                 # Apply callback
                 _clusters = self.callback(list(g), pfx, **kwargs)
                 # Recursion
-                processed.extend(self._process_fatd(_clusters, level + 1, **kwargs))
+                processed.extend(self._process_fatd(_clusters, level + 1, pfx, **kwargs))
 
         return processed