diff --git a/loopy/__init__.py b/loopy/__init__.py
index ce6cdca03dc4dd9b56338f65662926011a94ad4c..8975674442f049f51f724bfcb818fc6e8a441c88 100644
--- a/loopy/__init__.py
+++ b/loopy/__init__.py
@@ -66,6 +66,7 @@ from loopy.transform.iname import (
         split_reduction_inward, split_reduction_outward,
         affine_map_inames, find_unused_axis_tag,
         make_reduction_inames_unique,
+        has_schedulable_iname_nesting, get_iname_duplication_options,
         add_inames_to_insn)
 
 from loopy.transform.instruction import (
@@ -170,6 +171,7 @@ __all__ = [
         "split_reduction_inward", "split_reduction_outward",
         "affine_map_inames", "find_unused_axis_tag",
         "make_reduction_inames_unique",
+        "has_schedulable_iname_nesting", "get_iname_duplication_options",
         "add_inames_to_insn",
 
         "add_prefetch", "change_arg_to_image",
diff --git a/loopy/check.py b/loopy/check.py
index 8587ad04336131a902638db24a72a97ced66f0b2..2f48211da430b42e8000467f070b1633ab3a4f38 100644
--- a/loopy/check.py
+++ b/loopy/check.py
@@ -332,6 +332,22 @@ def check_write_destinations(kernel):
                     or wvar in kernel.arg_dict) and wvar not in kernel.all_params():
                 raise LoopyError
 
+
+def check_has_schedulable_iname_nesting(kernel):
+    from loopy.transform.iname import (has_schedulable_iname_nesting,
+                                       get_iname_duplication_options)
+    if not has_schedulable_iname_nesting(kernel):
+        import itertools as it
+        opt = get_iname_duplication_options(kernel)
+        opt_str = "\n".join("* Duplicate %s within instructions %s" % (i, w)
+                            for i, w in it.islice(opt, 3))
+        raise LoopyError("Kernel does not have a schedulable iname nesting. "
+                "In order for there to exist a feasible loop nesting, you "
+                "may need to duplicate an iname. To do so, call "
+                "loopy.duplicate_iname. Use loopy.get_iname_duplication_options "
+                "to get hints about which iname to duplicate. Here are some "
+                "options:\n%s" % opt_str)
+
 # }}}
 
 
@@ -348,6 +364,7 @@ def pre_schedule_checks(kernel):
         check_for_data_dependent_parallel_bounds(kernel)
         check_bounds(kernel)
         check_write_destinations(kernel)
+        check_has_schedulable_iname_nesting(kernel)
 
         logger.info("%s: pre-schedule check: done" % kernel.name)
     except KeyboardInterrupt:
diff --git a/loopy/transform/iname.py b/loopy/transform/iname.py
index 105219c8cf8300563a364f0d5511c7ceab70b4da..1914b8d677af4cd0a5683d90ff5ac1168a660063 100644
--- a/loopy/transform/iname.py
+++ b/loopy/transform/iname.py
@@ -48,6 +48,10 @@ __doc__ = """
 
 .. autofunction:: duplicate_inames
 
+.. autofunction:: get_iname_duplication_options
+
+.. autofunction:: has_schedulable_iname_nesting
+
 .. autofunction:: rename_iname
 
 .. autofunction:: remove_unused_inames
@@ -825,6 +829,170 @@ def duplicate_inames(knl, inames, within, new_inames=None, suffix=None,
 # }}}
 
 
+# {{{ iname duplication for schedulability
+
+def _get_iname_duplication_options(insn_deps, old_common_inames=frozenset([])):
+    # Remove common inames of the current insn_deps, as they are not relevant
+    # for splitting.
+    common = frozenset([]).union(*insn_deps).intersection(*insn_deps)
+
+    # If common inames were found, we reduce the problem and go into recursion
+    if common:
+        # Remove the common inames from the instruction dependencies
+        insn_deps = (
+            frozenset(dep - common for dep in insn_deps)
+            -
+            frozenset([frozenset([])]))
+        # Join the common inames with those previously found
+        common = common.union(old_common_inames)
+
+        # Go into recursion
+        for option in _get_iname_duplication_options(insn_deps, common):
+            yield option
+        # Do not yield anything beyond here!
+        return
+
+    # Try finding a partitioning of the remaining inames, such that all instructions
+    # use only inames from one of the disjoint sets from the partitioning.
+    def join_sets_if_not_disjoint(sets):
+        for s1 in sets:
+            for s2 in sets:
+                if s1 != s2 and s1.intersection(s2):
+                    return (
+                        (sets - frozenset([s1, s2]))
+                        | frozenset([s1 | s2])
+                        ), False
+
+        return sets, True
+
+    partitioning = insn_deps
+    stop = False
+    while not stop:
+        partitioning, stop = join_sets_if_not_disjoint(partitioning)
+
+    # If a partitioning was found we recursively apply this algorithm to the
+    # subproblems
+    if len(partitioning) > 1:
+        for part in partitioning:
+            working_set = frozenset(s for s in insn_deps if s.issubset(part))
+            for option in _get_iname_duplication_options(working_set,
+                                                         old_common_inames):
+                yield option
+    # If exactly one set was found, an iname duplication is necessary
+    elif len(partitioning) == 1:
+        inames, = partitioning
+
+        # There are splitting options for all inames
+        for iname in inames:
+            iname_insns = frozenset(
+                    insn for insn in insn_deps if frozenset([iname]).issubset(insn))
+
+            import itertools as it
+            # For a given iname, the set of instructions containing this iname
+            # is inspected.  For each element of the power set without the
+            # empty and the full set, one duplication option is generated.
+            for insns_to_dup in it.chain.from_iterable(
+                    it.combinations(iname_insns, l)
+                    for l in range(1, len(iname_insns))):
+                yield (
+                    iname,
+                    tuple(insn.union(old_common_inames) for insn in insns_to_dup))
+
+    # If partitioning was empty, we have recursed successfully and yield nothing
+
+
+def get_iname_duplication_options(knl, use_boostable_into=False):
+    """List options for duplication of inames, if necessary for schedulability
+
+    :returns: a generator listing all options to duplicate inames, if duplication
+        of an iname is necessary to ensure the schedulability of the kernel.
+        Duplication options are returned as tuples (iname, within) as
+        understood by :func:`duplicate_inames`. There is no guarantee, that the
+        transformed kernel will be schedulable, because multiple duplications
+        of iname may be necessary.
+
+    Some kernels require the duplication of inames in order to be schedulable, as the
+    forced iname dependencies define an over-determined problem to the scheduler.
+    Consider the following minimal example:
+
+        knl = lp.make_kernel(["{[i,j]:0<=i,j<n}"],
+                             \"\"\"
+                             mat1[i,j] = mat1[i,j] + 1 {inames=i:j, id=i1}
+                             mat2[j] = mat2[j] + 1 {inames=j, id=i2}
+                             mat3[i] = mat3[i] + 1 {inames=i, id=i3}
+                             \"\"\")
+
+    In the example, there are four possibilities to resolve the problem:
+    * duplicating i in instruction i3
+    * duplicating i in instruction i1 and i3
+    * duplicating j in instruction i2
+    * duplicating i in instruction i2 and i3
+
+    Use :func:`has_schedulable_iname_nesting` to decide, whether an iname needs to be
+    duplicated in a given kernel.
+    """
+    # First we extract the minimal necessary information from the kernel
+    if use_boostable_into:
+        insn_deps = (
+            frozenset(insn.forced_iname_deps.union(
+                insn.boostable_into if insn.boostable_into is not None
+                else frozenset([]))
+                for insn in knl.instructions)
+            -
+            frozenset([frozenset([])]))
+    else:
+        insn_deps = (
+            frozenset(insn.forced_iname_deps for insn in knl.instructions)
+            -
+            frozenset([frozenset([])]))
+
+    # Get the duplication options as a tuple of iname and a set
+    for iname, insns in _get_iname_duplication_options(insn_deps):
+        # Check whether this iname has a parallel tag and discard it if so
+        from loopy.kernel.data import ParallelTag
+        if (iname in knl.iname_to_tag
+                    and isinstance(knl.iname_to_tag[iname], ParallelTag)):
+            continue
+
+        # If we find a duplication option and fo not use boostable_into
+        # information, we restart this generator with use_boostable_into=True
+        if not use_boostable_into:
+            for option in get_iname_duplication_options(knl, True):
+                yield option
+
+            # Emit a warning that we needed boostable_into
+            from warnings import warn
+            from loopy.diagnostic import LoopyWarning
+            warn("Kernel '%s' required the deprecated 'boostable_into"
+                 "field in order to be schedulable!" % knl.name, LoopyWarning)
+
+            # Return to avoid yielding the duplication
+            # options without boostable_into
+            return
+
+        # Reconstruct an object that may be passed to the within parameter of
+        # loopy.duplicate_inames
+        from loopy.match import Id, Or
+        within = Or(tuple(
+            Id(insn.id) for insn in knl.instructions
+            if insn.forced_iname_deps in insns))
+
+        # Only yield the result if an instruction matched. With use_boostable_into=True
+        # this is not always true.
+        if within.children:
+            yield iname, within
+
+
+def has_schedulable_iname_nesting(knl):
+    """
+    :returns: a :class:`bool` indicating whether this kernel needs
+        an iname duplication in order to be schedulable.
+    """
+    return not bool(next(get_iname_duplication_options(knl), False))
+
+# }}}
+
+
 # {{{ rename_inames
 
 def rename_iname(knl, old_iname, new_iname, existing_ok=False, within=None):
diff --git a/test/library_for_test.py b/test/library_for_test.py
index c8ff56e9dad568313a7762c74480d7612b2990c3..b2de0d40262babe6a56f0bb076b2d096200e8ed1 100644
--- a/test/library_for_test.py
+++ b/test/library_for_test.py
@@ -1,3 +1,5 @@
+# This exists because function handles can't be pickled.
+
 def no_ret_f_mangler(kernel, name, arg_dtypes):
     if not isinstance(name, str):
         return None
@@ -15,5 +17,6 @@ def no_ret_f_preamble_gen(preamble_info):
             r"""
             void f()
             {
+                printf("Hi!\n");
             }
             """)
diff --git a/test/test_loopy.py b/test/test_loopy.py
index b050280839dd92c50eb0cab1d7ea5735736606ec..cd6305e57eb1b174cff647186b31759fe23f9c9a 100644
--- a/test/test_loopy.py
+++ b/test/test_loopy.py
@@ -1280,6 +1280,8 @@ def test_finite_difference_expr_subst(ctx_factory):
     evt, _ = precomp_knl(queue, u=u, h=h)
 
 
+# {{{ call without returned values
+
 def test_call_with_no_returned_value(ctx_factory):
     import pymbolic.primitives as p
 
@@ -1297,6 +1299,38 @@ def test_call_with_no_returned_value(ctx_factory):
 
     evt, _ = knl(queue)
 
+# }}}
+
+
+def test_unschedulable_kernel_detection():
+    knl = lp.make_kernel(["{[i,j]:0<=i,j<n}"],
+                         """
+                         mat1[i,j] = mat1[i,j] + 1 {inames=i:j, id=i1}
+                         mat2[j] = mat2[j] + 1 {inames=j, id=i2}
+                         mat3[i] = mat3[i] + 1 {inames=i, id=i3}
+                         """)
+
+    knl = lp.preprocess_kernel(knl)
+
+    # Check that loopy can detect the unschedulability of the kernel
+    assert not lp.has_schedulable_iname_nesting(knl)
+    assert len(list(lp.get_iname_duplication_options(knl))) == 4
+
+    for inames, insns in lp.get_iname_duplication_options(knl):
+        fixed_knl = lp.duplicate_inames(knl, inames, insns)
+        assert lp.has_schedulable_iname_nesting(fixed_knl)
+
+    knl = lp.make_kernel(["{[i,j,k,l,m]:0<=i,j,k,l,m<n}"],
+                         """
+                         mat1[l,m,i,j,k] = mat1[l,m,i,j,k] + 1 {inames=i:j:k:l:m}
+                         mat2[l,m,j,k] = mat2[l,m,j,k] + 1 {inames=j:k:l:m}
+                         mat3[l,m,k] = mat3[l,m,k] + 11 {inames=k:l:m}
+                         mat4[l,m,i] = mat4[l,m,i] + 1 {inames=i:l:m}
+                         """)
+
+    assert not lp.has_schedulable_iname_nesting(knl)
+    assert len(list(lp.get_iname_duplication_options(knl))) == 10
+
 
 def test_regression_no_ret_call_removal(ctx_factory):
     # https://github.com/inducer/loopy/issues/32
diff --git a/test/test_sem_reagan.py b/test/test_sem_reagan.py
index f4b91b236a16a8a30f2962d92b83780343fe801a..0571e41910020aa0a60cd911a63b6ce2984ed939 100644
--- a/test/test_sem_reagan.py
+++ b/test/test_sem_reagan.py
@@ -45,10 +45,10 @@ def test_tim2d(ctx_factory):
 
     # K - run-time symbolic
     knl = lp.make_kernel(
-            "[K] -> {[i,j,e,m,o,gi]: 0<=i,j,m,o<%d and 0<=e<K and 0<=gi<3}" % n,
+            "{[i,j,e,m,o,o2,gi]: 0<=i,j,m,o,o2<n and 0<=e<K and 0<=gi<3}",
             [
                 "ur(a,b) := simul_reduce(sum, o, D[a,o]*u[e,o,b])",
-                "us(a,b) := simul_reduce(sum, o, D[b,o]*u[e,a,o])",
+                "us(a,b) := simul_reduce(sum, o2, D[b,o2]*u[e,a,o2])",
 
                 #"Gu(mat_entry,a,b) := G[mat_entry,e,m,j]*ur(m,j)",
 
@@ -70,6 +70,7 @@ def test_tim2d(ctx_factory):
                 ],
             name="semlap2D", assumptions="K>=1")
 
+    knl = lp.fix_parameters(knl, n=n)
     knl = lp.duplicate_inames(knl, "o", within="id:ur")
     knl = lp.duplicate_inames(knl, "o", within="id:us")