Statement instance order and lex order map

doc/ref_kernel.rst

@@ -220,6 +220,8 @@ Tag                             Meaning
 Identifiers
 -----------
 
+.. _reserved-identifiers:
+
 Reserved Identifiers
 ^^^^^^^^^^^^^^^^^^^^
 

doc/ref_other.rst

@@ -26,9 +26,16 @@ Automatic Testing
 
 .. autofunction:: auto_test_vs_ref
 
+Checking Dependencies at the Statement-Instance Level
+-----------------------------------------------------
+
+.. automodule:: loopy.schedule.checker
+
 Troubleshooting
 ---------------
 
+.. currentmodule:: loopy
+
 Printing :class:`LoopKernel` objects
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 

loopy/__init__.py

@@ -129,6 +129,9 @@
 from loopy.schedule import (
     generate_loop_schedules, get_one_scheduled_kernel,
     get_one_linearized_kernel, linearize)
+from loopy.schedule.checker import (
+    get_pairwise_statement_orderings,
+)
 from loopy.statistics import (ToCountMap, ToCountPolynomialMap, CountGranularity,
         stringify_stats_mapping, Op, MemAccess, get_op_map, get_mem_access_map,
         get_synchronization_map, gather_access_footprints,
@@ -268,6 +271,7 @@
         "generate_loop_schedules",
         "get_one_scheduled_kernel", "get_one_linearized_kernel",
         "linearize",
+        "get_pairwise_statement_orderings",
 
         "GeneratedProgram", "CodeGenerationResult",
         "PreambleInfo",

loopy/isl_helpers.py

@@ -823,29 +823,33 @@ def add_eq_constraint_from_names(isl_obj, var1, var2):
 # }}}
 
 
-# {{{ find_and_rename_dim
+# {{{ find_and_rename_dims
 
-def find_and_rename_dim(isl_obj, dt, old_name, new_name):
-    """Rename a dimension in an ISL object.
+def find_and_rename_dims(isl_obj, dt, rename_dict):
+    """Rename dimensions in an ISL object.
 
     :arg isl_obj: An :class:`islpy.Set` or  :class:`islpy.Map` containing the
         dimension to be renamed.
 
     :arg dt: An :class:`islpy.dim_type` (i.e., :class:`int`) specifying the
         dimension type containing the dimension to be renamed.
 
-    :arg old_name: A :class:`str` specifying the name of the dimension to be
-        renamed.
+    :arg rename_dict: A :class:`dict` mapping current :class:`string` dimension
+        names to replacement names.
 
-    :arg new_name: A :class:`str` specifying the new name of the dimension to
-        be renamed.
-
-    :returns: An object of the same type as *isl_obj* with the dimension
-        *old_name* renamed to *new_name*.
+    :returns: An object of the same type as *isl_obj* with the dimension names
+        changed according to *rename_dict*.
 
     """
-    return isl_obj.set_dim_name(
+    for old_name, new_name in rename_dict.items():
+        idx = isl_obj.find_dim_by_name(dt, old_name)
+        if idx == -1:
+            raise ValueError(
+                "find_and_rename_dims did not find dimension %s"
+                % (old_name))
+        isl_obj = isl_obj.set_dim_name(
             dt, isl_obj.find_dim_by_name(dt, old_name), new_name)
+    return isl_obj
 
 # }}}
 

loopy/schedule/checker/__init__.py

@@ -0,0 +1,161 @@
+"""
+.. autofunction:: get_pairwise_statement_orderings
+
+.. automodule:: loopy.schedule.checker.schedule
+"""
+
+
+__copyright__ = "Copyright (C) 2019 James Stevens"
+
+__license__ = """
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+"""
+
+
+# {{{ get pairwise statement orderings
+
+def get_pairwise_statement_orderings(
+        knl,
+        lin_items,
+        stmt_id_pairs,
+        perform_closure_checks=False,
+        ):
+    r"""For each statement pair in a subset of all statement pairs found in a
+    linearized kernel, determine the (relative) order in which the statement
+    instances are executed. For each pair, represent this relative ordering
+    using three ``statement instance orderings`` (SIOs):
+
+    - The intra-thread SIO: A :class:`islpy.Map` from each instance of the
+      first statement to all instances of the second statement that occur
+      later, such that both statement instances in each before-after pair are
+      executed within the same work-item (thread).
+
+    - The intra-group SIO: A :class:`islpy.Map` from each instance of the first
+      statement to all instances of the second statement that occur later, such
+      that both statement instances in each before-after pair are executed
+      within the same work-group (though potentially by different work-items).
+
+    - The global SIO: A :class:`islpy.Map` from each instance of the first
+      statement to all instances of the second statement that occur later, even
+      if the two statement instances in a given before-after pair are executed
+      within different work-groups.
+
+    :arg knl: A preprocessed :class:`loopy.LoopKernel` containing the
+        linearization items that will be used to create the SIOs.
+
+    :arg lin_items: A list of :class:`loopy.schedule.ScheduleItem`
+        (to be renamed to `loopy.schedule.LinearizationItem`) containing all
+        linearization items for which SIOs will be created. To allow usage of
+        this routine during linearization, a truncated (i.e. partial)
+        linearization may be passed through this argument.
+
+    :arg stmt_id_pairs: A sequence containing pairs of statement identifiers.
+
+    :returns: A dictionary mapping each two-tuple of statement identifiers
+        provided in `stmt_id_pairs` to a
+        :class:`~loopy.schedule.checker.schedule.StatementOrdering`, which
+        contains the three SIOs described above.
+
+    .. doctest:
+
+        >>> import loopy as lp
+        >>> import numpy as np
+        >>> # Make kernel -----------------------------------------------------------
+        >>> knl = lp.make_kernel(
+        ...     "{[j,k]: 0<=j<pj and 0<=k<pk}",
+        ...     [
+        ...         "a[j] = j  {id=stmt_a}",
+        ...         "b[k] = k+a[0]  {id=stmt_b,dep=stmt_a}",
+        ...     ])
+        >>> knl = lp.add_and_infer_dtypes(knl, {"a": np.float32, "b": np.float32})
+        >>> # Preprocess
+        >>> knl = lp.preprocess_kernel(knl)
+        >>> # Get a linearization
+        >>> knl = lp.get_one_linearized_kernel(
+        ...     knl["loopy_kernel"], knl.callables_table)
+        >>> # Get pairwise order info -----------------------------------------------
+        >>> from loopy.schedule.checker import get_pairwise_statement_orderings
+        >>> sio_dict = get_pairwise_statement_orderings(
+        ...     knl,
+        ...     knl.linearization,
+        ...     [("stmt_a", "stmt_b")],
+        ...     )
+        >>> # Print map
+        >>> print(str(sio_dict[("stmt_a", "stmt_b")].sio_intra_thread
+        ...     ).replace("{ ", "{\n").replace(" :", "\n:"))
+        [pj, pk] -> {
+        [_lp_linchk_stmt' = 0, j'] -> [_lp_linchk_stmt = 1, k]
+        : pj > 0 and pk > 0 and 0 <= j' < pj and 0 <= k < pk }
+
+    """
+
+    # {{{ make sure kernel has been preprocessed
+
+    from loopy.kernel import KernelState
+    assert knl.state in [
+            KernelState.PREPROCESSED,
+            KernelState.LINEARIZED]
+
+    # }}}
+
+    # {{{ Find any EnterLoop inames that are tagged as concurrent
+    # so that get_pairwise_statement_orderings_inner() knows to ignore them
+    # (In the future, this should only include inames tagged with 'vec'.)
+
+    # FIXME Consider just putting this ilp/vec logic inside
+    # get_pairwise_statement_orderings_inner; passing these in as
+    # 'loops_to_ignore' made more sense when we were just dealing with the
+    # intra-thread case.
+    from loopy.schedule.checker.utils import (
+        partition_inames_by_concurrency,
+        get_EnterLoop_inames,
+    )
+    conc_inames, _ = partition_inames_by_concurrency(knl)
+    enterloop_inames = get_EnterLoop_inames(lin_items)
+    ilp_and_vec_inames = conc_inames & enterloop_inames
+
+    # The only concurrent EnterLoop inames should be Vec and ILP
+    from loopy.kernel.data import (VectorizeTag, IlpBaseTag)
+    for conc_iname in ilp_and_vec_inames:
+        # Assert that there exists an ilp or vectorize tag (out of the
+        # potentially multiple other tags on this concurrent iname).
+        assert any(
+            isinstance(tag, (VectorizeTag, IlpBaseTag))
+            for tag in knl.iname_to_tags[conc_iname])
+
+    # }}}
+
+    # {{{ Create the SIOs
+
+    from loopy.schedule.checker.schedule import (
+        get_pairwise_statement_orderings_inner
+    )
+    return get_pairwise_statement_orderings_inner(
+        knl,
+        lin_items,
+        stmt_id_pairs,
+        ilp_and_vec_inames=ilp_and_vec_inames,
+        perform_closure_checks=perform_closure_checks,
+        )
+
+    # }}}
+
+# }}}
+
+# vim: foldmethod=marker