def _tile(self):
        """Tile consecutive loops over different iteration sets characterized
        by RAW and WAR dependencies. This requires interfacing with the SLOPE
        library."""
        try:
            backend_map = {'sequential': 'SEQUENTIAL', 'openmp': 'OMP'}
            slope_backend = backend_map[configuration['backend']]
            slope.set_exec_mode(slope_backend)
            log_info("SLOPE backend set to %s" % slope_backend)
        except KeyError:
            warning("Unable to set backend %s for SLOPE" % configuration['backend'])

        inspector = slope.Inspector()

        # Build arguments types and values
        arguments = []
        insp_sets, insp_maps, insp_loops = set(), {}, []
        for loop in self._loop_chain:
            slope_desc = set()
            # Add sets
            insp_sets.add((loop.it_space.name, loop.it_space.core_size))
            for a in loop.args:
                maps = as_tuple(a.map, Map)
                # Add maps (there can be more than one per argument if the arg
                # is actually a Mat - in which case there are two maps - or if
                # a MixedMap) and relative descriptors
                if not maps:
                    slope_desc.add(('DIRECT', a.access._mode))
                    continue
                for i, map in enumerate(maps):
                    for j, m in enumerate(map):
                        map_name = "%s%d_%d" % (m.name, i, j)
                        insp_maps[m.name] = (map_name, m.iterset.name,
                                             m.toset.name, m.values)
                        slope_desc.add((map_name, a.access._mode))
            # Add loop
            insp_loops.append((loop.kernel.name, loop.it_space.name, list(slope_desc)))
        # Provide structure of loop chain to the SLOPE's inspector
        arguments.extend([inspector.add_sets(insp_sets)])
        arguments.extend([inspector.add_maps(insp_maps.values())])
        inspector.add_loops(insp_loops)
        # Get type and value of any additional arguments that the SLOPE's inspector
        # expects
        arguments.extend([inspector.set_external_dats()])

        # Set a specific tile size
        arguments.extend([inspector.set_tile_size(self._tile_size)])

        # Arguments types and values
        argtypes, argvalues = zip(*arguments)

        # Generate inspector C code
        src = inspector.generate_code()

        # Return type of the inspector
        rettype = slope.Executor.meta['py_ctype_exec']

        # Compiler and linker options
        slope_dir = os.environ['SLOPE_DIR']
        compiler = coffee.plan.compiler.get('name')
        cppargs = slope.get_compile_opts(compiler)
        cppargs += [(slope_dir, slope.get_include_dir()) % '-I%s/%s']
        ldargs = ['-L%s/%s' % (slope_dir, slope.get_lib_dir()),
                  '-l%s' % slope.get_lib_name()]

        # Compile and run inspector
        fun = compilation.load(src, "cpp", "inspector", cppargs, ldargs,
                               argtypes, rettype, compiler)
        inspection = fun(*argvalues)

        # Finally, get the Executor representation, to be used at executor
        # code generation time
        executor = slope.Executor(inspector)

        self._schedule = TilingSchedule(self._schedule, inspection, executor)
dataset/ETHPy150Open OP2/PyOP2/pyop2/fusion.py/Inspector._tile/swapped operands of `%`