From bf6f496ddda7e9032b0c59aceaa0a80f376801e9 Mon Sep 17 00:00:00 2001 From: Christophe Guillon Date: Tue, 11 Aug 2026 16:20:37 +0200 Subject: [PATCH] schedule: fix nested splits --- src/xtc/backends/jir/JIRScheduler.py | 36 ++-- src/xtc/backends/mlir/MlirCompilerPasses.py | 4 +- src/xtc/backends/mlir/MlirScheduler.py | 4 + src/xtc/backends/tvm/TVMScheduler.py | 13 +- src/xtc/schedules/loop_names.py | 17 +- src/xtc/schedules/loop_nest.py | 27 ++- src/xtc/schedules/loop_nest_builder.py | 176 +++++++++++------- src/xtc/schedules/plain_schedule.py | 78 ++++---- src/xtc/schedules/ttile/scheme_to_xtc.py | 2 +- tests/filecheck/backends/test_matmul_split.py | 78 ++++++++ .../backends/test_matmul_split_nested.py | 91 +++++++++ tests/filecheck/search/test_conv_oo.py | 10 +- tests/filecheck/search/test_conv_pprprp.py | 10 +- tests/filecheck/search/test_conv_pprprpv.py | 10 +- tests/filecheck/search/test_conv_pprprpvr.py | 10 +- .../search/test_conv_pprprpvr_rnd.py | 2 +- tests/filecheck/search/test_conv_prp.py | 10 +- tests/filecheck/search/test_conv_prp_rnd.py | 2 +- .../search/test_matmul_descript_3axes.py | 6 +- .../search/test_matmul_descript_goto.py | 6 +- .../search/test_matmul_descript_simple.py | 6 +- .../search/test_matmul_descript_split.py | 6 +- .../test_matmul_descript_split_in_split.py | 6 +- .../search/test_matmul_descript_yaml_goto.py | 5 +- .../test_matmul_descript_yaml_simple.py | 6 +- .../search/test_matmul_descript_yaml_split.py | 6 +- tests/filecheck/search/test_matmul_goto.py | 10 +- tests/filecheck/search/test_matmul_goto_r.py | 10 +- tests/filecheck/search/test_matmul_oo.py | 10 +- tests/filecheck/search/test_matmul_p1.py | 10 +- tests/filecheck/search/test_matmul_p1v.py | 10 +- tests/filecheck/search/test_matmul_pprprp.py | 10 +- tests/filecheck/search/test_matmul_pprprpv.py | 10 +- .../filecheck/search/test_matmul_pprprpvr.py | 10 +- .../search/test_matmul_pprprpvr_rnd.py | 2 +- tests/filecheck/search/test_matmul_prp.py | 10 +- tests/filecheck/search/test_matmul_prp_rnd.py | 2 +- tests/pytest/mlir/test_mlir_impl.py | 4 +- tests/pytest/tvm/test_tvm_impl.py | 2 +- 39 files changed, 499 insertions(+), 228 deletions(-) create mode 100644 tests/filecheck/backends/test_matmul_split.py create mode 100644 tests/filecheck/backends/test_matmul_split_nested.py diff --git a/src/xtc/backends/jir/JIRScheduler.py b/src/xtc/backends/jir/JIRScheduler.py index e12c358ca..d59d3cafc 100644 --- a/src/xtc/backends/jir/JIRScheduler.py +++ b/src/xtc/backends/jir/JIRScheduler.py @@ -7,7 +7,7 @@ import xtc.itf as itf from xtc.itf.schd.scheduler import DEFAULT_ROOT -from xtc.schedules.loop_nest import LoopNest +from xtc.schedules.loop_nest import LoopNest, LoopNestNode import xtc.backends.jir as backend __all__ = [ @@ -359,26 +359,34 @@ def get_loop_nest(self) -> LoopNest: transformer = self._transformer dims = list(transformer.dims.keys()) - loop_nest = LoopNest(abstract_dims=dims) - root_node = loop_nest.build_root_node(self._backend.payload_name) - # Build tiles mapping - for axis, axis_tiles in transformer.tiles.items(): - for tile_name, size in axis_tiles.items(): - root_node.tiles[axis][tile_name] = size + tiles = { + axis: {tile_name: size for tile_name, size in axis_tiles.items()} + for axis, axis_tiles in transformer.tiles.items() + } # Build interchange - root_node.interchange = ( - list(transformer.order) if transformer.order else dims[:] - ) + interchange = list(transformer.order) if transformer.order else dims[:] # Build vectorization list - root_node.vectorize = list(transformer.vectorized) + vectorize = list(transformer.vectorized) # Build parallelization list - root_node.parallelize = list(transformer.parallelized) + parallelize = list(transformer.parallelized) # Build unroll mapping - root_node.unroll = dict(transformer.unrolled) - + unroll = dict(transformer.unrolled) + + root_node = LoopNestNode( + root=self._backend.payload_name, + tiles=tiles, + interchange=interchange, + vectorize=vectorize, + parallelize=parallelize, + unroll=unroll, + ) + loop_nest = LoopNest( + abstract_dims=dims, + root_node=root_node, + ) return loop_nest diff --git a/src/xtc/backends/mlir/MlirCompilerPasses.py b/src/xtc/backends/mlir/MlirCompilerPasses.py index f2c123049..5362d66bb 100644 --- a/src/xtc/backends/mlir/MlirCompilerPasses.py +++ b/src/xtc/backends/mlir/MlirCompilerPasses.py @@ -42,7 +42,7 @@ sdist_transform = None pass -from xtc.schedules.loop_names import make_loop_name, parent_name +from xtc.schedules.loop_names import make_loop_name, parent_name, basename from xtc.utils.ext_tools import transform_opts from .MlirProgram import RawMlirProgram @@ -465,7 +465,7 @@ def _split_section( dim_to_split = split_state.loop_dim_by_split[loop_name] split_handle = structured.SplitOp( target=sched_state.handle, - dimension=schedule.dims.index(dim_to_split), + dimension=schedule.dims.index(basename(dim_to_split)), chunk_sizes=split_state.chunk_size(loop_name), ) split_command = SplitHandleOp( diff --git a/src/xtc/backends/mlir/MlirScheduler.py b/src/xtc/backends/mlir/MlirScheduler.py index 3153b3471..5c136d17f 100644 --- a/src/xtc/backends/mlir/MlirScheduler.py +++ b/src/xtc/backends/mlir/MlirScheduler.py @@ -74,6 +74,10 @@ def __init__( loop_stamps=backend.loop_stamps, ) + @property + def _default_node_name(self) -> str: + return self._current_scheduler.node_name + @property def _current_scheduler(self) -> MlirNodeScheduler: assert self._node_scheduler is not None diff --git a/src/xtc/backends/tvm/TVMScheduler.py b/src/xtc/backends/tvm/TVMScheduler.py index d5ae638f4..fe0f6e71b 100644 --- a/src/xtc/backends/tvm/TVMScheduler.py +++ b/src/xtc/backends/tvm/TVMScheduler.py @@ -81,7 +81,7 @@ def _full_tilings(self, sched: LoopNestNode) -> dict[str, tuple[str, str, int]]: for idx, (axis, size) in enumerate(dim_tiles.items()): tilings[axis] = (dim, prev_axis, size) prev_axis = axis - tilings = {axis: tilings[axis] for axis in order} + tilings = {axis: tilings.get(axis, (axis, "", 0)) for axis in order} return tilings def _write_buffer_tiling( @@ -417,7 +417,7 @@ def _update_loopnode(node: LoopNestNode) -> LoopNestNode: ) adjusted_tiles[dim] = adjusted_dim_tiles adjusted_unrolling = {u: adjusted_unrolling[u] for u in adjusted_unrolls} - return LoopNestNode( + updated_node = LoopNestNode( root=node.root, tiles=adjusted_tiles, splits=deepcopy(node.splits), @@ -429,7 +429,12 @@ def _update_loopnode(node: LoopNestNode) -> LoopNestNode: pack_at=deepcopy(node.pack_at), fuse_producer_at=deepcopy(node.fuse_producer_at), fuse_consumer_at=deepcopy(node.fuse_consumer_at), + split_origin=deepcopy(node.split_origin), ) + for child in node.children: + updated_child = _update_loopnode(child) + updated_node.add_child(updated_child) + return updated_node root = sched.root_node if root is not None: @@ -467,6 +472,10 @@ def __init__( list(self._op.operator.dims()), ) + @property + def _default_node_name(self) -> str: + return self._op.name + @property @override def backend(self) -> itf.back.Backend: diff --git a/src/xtc/schedules/loop_names.py b/src/xtc/schedules/loop_names.py index f6848e90b..55b1ef675 100644 --- a/src/xtc/schedules/loop_names.py +++ b/src/xtc/schedules/loop_names.py @@ -2,9 +2,10 @@ # SPDX-License-Identifier: BSD-3-Clause # Copyright (c) 2024-2026 The XTC Project Authors # -__all__ = ["make_loop_name", "basename", "parent_name"] +__all__ = ["make_loop_name", "basename", "parent_name", "path_names", "rooted_name"] _LOOP_SEP = "/" +_LOOP_ROOT = "." def make_loop_name(root: str, name: str) -> str: @@ -17,3 +18,17 @@ def basename(loop_name: str) -> str: def parent_name(loop_name: str) -> str: return loop_name.rsplit(_LOOP_SEP, 1)[0] + + +def path_names(loop_name: str) -> list[str]: + return loop_name.split(_LOOP_SEP) + + +def rooted_name(loop_name: str, root: str) -> str: + assert root != _LOOP_ROOT + if loop_name == _LOOP_ROOT: + return root + prefix = f"{_LOOP_ROOT}{_LOOP_SEP}" + if loop_name.startswith(prefix): + return make_loop_name(root, loop_name[len(prefix) :]) + return loop_name diff --git a/src/xtc/schedules/loop_nest.py b/src/xtc/schedules/loop_nest.py index 701baf844..bee0f67e0 100644 --- a/src/xtc/schedules/loop_nest.py +++ b/src/xtc/schedules/loop_nest.py @@ -10,7 +10,7 @@ from .exceptions import ScheduleValidationError -@dataclass +@dataclass(frozen=True) class SplitOrigin: """Describes how a node was created via a split from its parent. @@ -28,7 +28,7 @@ class SplitOrigin: NodeT = TypeVar("NodeT", bound="Node") -@dataclass(kw_only=True) +@dataclass(frozen=True, kw_only=True) class Node(Generic[NodeT]): """Base class for tree nodes with parent/child relationships. @@ -52,8 +52,13 @@ def is_root(self) -> bool: return self.parent is None def add_child(self, child: NodeT) -> None: - """Add a child node and set its parent to this node.""" - child.parent = self # type: ignore[assignment] + """Add a child node and set its parent to this node. + + If the parent was already set, assert it's same. + """ + if child.parent is not None: + assert child.parent is self + object.__setattr__(child, "parent", self) self.children.append(child) def ancestors(self) -> list[NodeT]: @@ -74,7 +79,7 @@ def descendants_dfs(self) -> list[NodeT]: return result -@dataclass +@dataclass(frozen=True) class LoopNestNode(Node["LoopNestNode"]): """Represents a node in the loop nest tree with its transformations. @@ -103,7 +108,7 @@ class LoopNestNode(Node["LoopNestNode"]): """ root: str - tiles: dict[str, dict[str, int]] + tiles: dict[str, dict[str, int]] = field(default_factory=dict) splits: dict[str, dict[str, int]] = field(default_factory=dict) interchange: list[str] = field(default_factory=list) vectorize: list[str] = field(default_factory=list) @@ -245,7 +250,7 @@ def _add_annotations(self, line: str, loop_name: str) -> str: return line -@dataclass +@dataclass(frozen=True) class LoopInfo: """Maps loop names to their corresponding axis names and metadata. @@ -327,7 +332,7 @@ def collect(n: LoopNestNode) -> None: return LoopInfo(list(dims), tiles_info, splits_info) -@dataclass +@dataclass(frozen=True) class LoopNest: """Represents a complete loop nest structure for scheduling. @@ -353,12 +358,6 @@ def nodes(self) -> list[LoopNestNode]: return [] return [self.root_node] + self.root_node.descendants_dfs() - def build_root_node(self, root: str) -> LoopNestNode: - """Build and set the root node of the loop nest tree.""" - node = LoopNestNode(root=root, tiles={a: {} for a in self.abstract_dims}) - self.root_node = node - return node - def check(self): assert self.root_node is not None info = LoopInfo.build_from_node(self.root_node) diff --git a/src/xtc/schedules/loop_nest_builder.py b/src/xtc/schedules/loop_nest_builder.py index 565804d25..6f128f483 100644 --- a/src/xtc/schedules/loop_nest_builder.py +++ b/src/xtc/schedules/loop_nest_builder.py @@ -4,81 +4,127 @@ # from __future__ import annotations -from .loop_names import basename +from typing import Any +from .loop_names import basename, parent_name, make_loop_name, rooted_name from .plain_schedule import PlainNodeSchedule from .loop_nest import LoopInfo, LoopNest, LoopNestNode, SplitOrigin class LoopNestBuilder: - @staticmethod - def from_plain_node_schedule(node_sched: PlainNodeSchedule) -> LoopNest: - dims = node_sched.dims[:] + @classmethod + def from_plain_node_schedule(cls, node_sched: PlainNodeSchedule) -> LoopNest: + top_name = node_sched.node_name + root_node = cls._get_loop_node(top_name, node_sched.node_name, node_sched) + return LoopNest(abstract_dims=node_sched.dims[:], root_node=root_node) - loop_nest = LoopNest(abstract_dims=dims) - root_node = loop_nest.build_root_node(node_sched.node_name) + @classmethod + def _get_single_node( + cls, + top_name: str, + full_name: str, + node_sched: PlainNodeSchedule, + parent: LoopNestNode | None = None, + split_origin: SplitOrigin | None = None, + ) -> LoopNestNode: + def is_node_axis(axis: str): + return parent_name(rooted_name(axis, top_name)) == full_name - # Assign splits to root_node first, stripping the root prefix from names - for axis, axis_splits in node_sched.splits.items(): - root_node.splits[axis] = {basename(k): v for k, v in axis_splits.items()} + def is_node_root(name: str): + return rooted_name(name, top_name) == full_name - # Build mapper to get splits_info - mapper = LoopInfo.build_from_node(root_node) + def localize_axis_list(axis_list: list[str]) -> list[str]: + return [basename(axis) for axis in axis_list if is_node_axis(axis)] - def populate_node(node: LoopNestNode, perm: list[str]) -> None: - """Populate node with data for loops in its permutation.""" - perm_set = set(perm) - node.interchange = [basename(n) for n in perm] - for axis, axis_tiles in node_sched.tiles.items(): - for tile_name, size in axis_tiles.items(): - if tile_name in perm_set: - if axis not in node.tiles: - node.tiles[axis] = {} - node.tiles[axis][basename(tile_name)] = size - node.vectorize = [ - basename(v) for v in node_sched.vectorization if v in perm_set - ] - node.parallelize = [ - basename(p) for p in node_sched.parallelization if p in perm_set - ] - node.unroll = { - basename(k): v for k, v in node_sched.unrolling.items() if k in perm_set - } - # TODO: loop nest supports only one buffer per axis - node.buffer_at = { - basename(k): v[0] - for k, v in node_sched.write_buffers.items() - if k in perm_set - } - # TODO: loop nest supports only one pack per axis - node.pack_at = { - basename(k): v[0] - for k, v in node_sched.packed_buffers.items() - if k in perm_set + def localize_axis_dict(axis_dict: dict[str, Any]) -> dict[str, Any]: + return { + basename(axis): v for axis, v in axis_dict.items() if is_node_axis(axis) } - # TODO: loop nest supports only one fuse per axis - node.fuse_producer_at = { - basename(k): v for k, v in node_sched.fused if k in perm_set - } - # TODO: loop nest supports only one fuse consumer per axis - node.fuse_consumer_at = [ - basename(k) for k in node_sched.fused_consumers if k in perm_set + + def localize_axis_tuples( + axis_tuples: list[tuple[str, Any]], + ) -> list[tuple[str, Any]]: + return [ + (basename(axis), v) for axis, v in axis_tuples if is_node_axis(axis) ] - # Process each root in permutation - for root, perm in node_sched.permutation.items(): - root_name = basename(root) - if root_name in mapper.splits_info: - # This root is a split - create child node - axis, start, end = mapper.splits_info[root_name] - child = LoopNestNode( - root=root_name, - tiles={d: {} for d in dims}, - split_origin=SplitOrigin(axis=axis, start=start, end=end), - ) - populate_node(child, perm) - root_node.add_child(child) - else: - # This is the main root - populate_node(root_node, perm) + perms = { + full_name: v for p, v in node_sched.permutation.items() if is_node_root(p) + } + interchange = [basename(p) for p in perms[full_name]] + splits = { + basename(axis): {basename(k): v for k, v in node_sched.splits[axis].items()} + for axis in node_sched.splits + if is_node_axis(axis) + } + tiles = { + basename(axis): { + basename(tile_name): size for tile_name, size in axis_tiles.items() + } + for axis, axis_tiles in node_sched.tiles.items() + if is_node_axis(axis) + } + vectorize = localize_axis_list(node_sched.vectorization) + parallelize = localize_axis_list(node_sched.parallelization) + unroll = localize_axis_dict(node_sched.unrolling) + # TODO: loop nest supports only one buffer per axis + buffer_at = { + basename(axis): v[0] + for axis, v in node_sched.write_buffers.items() + if is_node_axis(axis) + } + # TODO: loop nest supports only one pack per axis + pack_at = { + basename(axis): v[0] + for axis, v in node_sched.packed_buffers.items() + if is_node_axis(axis) + } + # TODO: loop nest supports only one fuse per axis + fuse_producer_at = dict(localize_axis_tuples(node_sched.fused)) + # TODO: loop nest supports only one fuse consumer per axis + fuse_consumer_at = localize_axis_list(node_sched.fused_consumers) + + return LoopNestNode( + root=basename(full_name), + interchange=interchange, + tiles=tiles, + vectorize=vectorize, + parallelize=parallelize, + unroll=unroll, + buffer_at=buffer_at, + pack_at=pack_at, + fuse_producer_at=fuse_producer_at, + fuse_consumer_at=fuse_consumer_at, + splits=splits, + parent=parent, + split_origin=split_origin, + ) - return loop_nest + @classmethod + def _get_loop_node( + cls, + top_name: str, + full_name: str, + node_sched: PlainNodeSchedule, + parent: LoopNestNode | None = None, + split_origin: SplitOrigin | None = None, + ) -> LoopNestNode: + node = cls._get_single_node( + top_name, + full_name, + node_sched, + parent, + split_origin, + ) + mapper = LoopInfo.build_from_node(node) + # TODO: sort children by permutation + for root, (axis, start, end) in mapper.splits_info.items(): + split_origin = SplitOrigin(axis, start, end) + child = cls._get_loop_node( + top_name, + make_loop_name(full_name, root), + node_sched, + node, + split_origin, + ) + node.add_child(child) + return node diff --git a/src/xtc/schedules/plain_schedule.py b/src/xtc/schedules/plain_schedule.py index 5f34e972d..868fb6339 100644 --- a/src/xtc/schedules/plain_schedule.py +++ b/src/xtc/schedules/plain_schedule.py @@ -35,7 +35,7 @@ class PlainNodeSchedule: fused_consumers: list[str] def index_of_dim(self, dim: str) -> int: - return list(self.dims).index(dim) + return self.dims.index(basename(dim)) def is_tile(self, loop_name: str) -> bool: for tiles in self.tiles.values(): @@ -56,7 +56,7 @@ def dim_of_tile(self, loop_name: str) -> str: for dim, tiles in self.tiles.items(): for tile in tiles: if bn == dim or loop_name == tile: - return dim + return basename(dim) assert False def size_of_tile(self, tile_name: str) -> int | None: @@ -67,7 +67,21 @@ def size_of_tile(self, tile_name: str) -> int | None: @override def __str__(self): - return pformat(asdict(self)) + return pformat(asdict(self), sort_dicts=False) + + def __post_init__(self): + # TODO: for now keep legacy behavior which forces interchange + # and empty tiling dict for the root_node + if not self.tiles: + for dim in self.dims: + self.tiles[make_loop_name(DEFAULT_ROOT, dim)] = {} + if not self.permutation: + self.permutation[DEFAULT_ROOT] = [] + for dim in self.dims: + self.permutation[DEFAULT_ROOT].extend( + [make_loop_name(DEFAULT_ROOT, dim)] + + list(self.tiles[make_loop_name(DEFAULT_ROOT, dim)]) + ) class PlainNodeScheduler: @@ -83,7 +97,7 @@ def __init__( self.dims = dims[:] self.loop_stamps = loop_stamps[:] self.splits: dict[str, dict[str, int]] = {} - self.tiles: dict[str, dict[str, int]] = {k: {} for k in self.dims} + self.tiles: dict[str, dict[str, int]] = {} self.permutation: dict[str, list[str]] = {} self.vectorization: list[str] = [] self.parallelization: list[str] = [] @@ -98,14 +112,6 @@ def __init__( self.fused_consumers: list[str] = [] def get_plain_schedule(self) -> PlainNodeSchedule: - if not self.permutation: - self.permutation[DEFAULT_ROOT] = self._get_default_interchange(DEFAULT_ROOT) - - for fuse_axis in self.fused: - assert fuse_axis[0] in self.permutation[next(iter(self.permutation))], ( - "Fusion must be to an axis in the base root not the result of a split." - ) - return PlainNodeSchedule( node_name=self.node_name, node_ident=self.node_ident, @@ -144,7 +150,6 @@ def _get_default_interchange(self, root: str) -> list[str]: def set_dims(self, dims: list[str]) -> None: assert len(dims) == len(self.dims) self.dims = dims[:] - self.tiles = {k: {} for k in self.dims} def split( self, dim: str, segments: dict[str, int], root: str = DEFAULT_ROOT @@ -152,14 +157,15 @@ def split( segments_renamed = { make_loop_name(root, key): val for key, val in segments.items() } - self.splits[dim] = segments_renamed - for s in segments_renamed: - self.tiles[s] = {} + self.splits[make_loop_name(root, dim)] = segments_renamed def tile(self, dim: str, tiles: dict[str, int], root: str = DEFAULT_ROOT): + tile_root = make_loop_name(root, dim) for d, s in tiles.items(): + if tile_root not in self.tiles: + self.tiles[tile_root] = {} tile_name = make_loop_name(root, d) - self.tiles[dim][tile_name] = s + self.tiles[tile_root][tile_name] = s def interchange(self, permutation: list[str], root: str = DEFAULT_ROOT): self.permutation[root] = [make_loop_name(root, a) for a in permutation] @@ -168,7 +174,7 @@ def vectorize(self, axes: list[str], root: str = DEFAULT_ROOT): self.vectorization += [make_loop_name(root, a) for a in axes] def parallelize(self, axes: list[str], root: str = DEFAULT_ROOT): - self.parallelization = [make_loop_name(root, a) for a in axes] + self.parallelization += [make_loop_name(root, a) for a in axes] def unroll(self, unrolls: dict[str, int], root: str = DEFAULT_ROOT): for dim, ufactor in unrolls.items(): @@ -180,11 +186,10 @@ def buffer_at( mtype: str | None = None, root: str = DEFAULT_ROOT, ) -> None: - axis_key = make_loop_name(root, axis) - if axis_key not in self.write_buffers.keys(): - self.write_buffers[axis_key] = [mtype] - else: - self.write_buffers[axis_key].append(mtype) + buffer_axis = make_loop_name(root, axis) + if buffer_axis not in self.write_buffers: + self.write_buffers[buffer_axis] = [] + self.write_buffers[buffer_axis].append(mtype) def pack_at( self, @@ -194,11 +199,10 @@ def pack_at( pad: bool = False, root: str = DEFAULT_ROOT, ): - axis_key = make_loop_name(root, axis) - if axis_key not in self.packed_buffers.keys(): - self.packed_buffers[axis_key] = [(input_idx, mtype, pad)] - else: - self.packed_buffers[axis_key].append((input_idx, mtype, pad)) + pack_axis = make_loop_name(root, axis) + if pack_axis not in self.packed_buffers: + self.packed_buffers[pack_axis] = [] + self.packed_buffers[pack_axis].append((input_idx, mtype, pad)) def define_memory_mesh(self, axes: dict[str, int]): assert len(self.memory_mesh) == 0, "Memory mesh has already been defined" @@ -221,9 +225,9 @@ def distribute(self, axis: str, processor_axis: str, root: str = DEFAULT_ROOT): assert processor_axis in self.processor_mesh or processor_axis == "*", ( "Processor axis not found in processor mesh" ) - axis_key = make_loop_name(root, axis) - self.parallelization.append(axis_key) - self.distribution[axis_key] = processor_axis + dist_axis = make_loop_name(root, axis) + self.parallelization.append(dist_axis) + self.distribution[dist_axis] = processor_axis def distributed_buffer_at( self, @@ -237,8 +241,8 @@ def distributed_buffer_at( assert ma in self.memory_mesh or ma == "*", ( "Memory axis not found in memory mesh" ) - axis_key = make_loop_name(root, axis) - self.distributed_buffers[axis_key] = { + dist_axis = make_loop_name(root, axis) + self.distributed_buffers[dist_axis] = { "input_idx": input_idx, "memory_axes": memory_axes, } @@ -246,9 +250,9 @@ def distributed_buffer_at( def fuse_producer_at( self, axis: str, input_idx: int, root: str = DEFAULT_ROOT ) -> None: - axis_key = make_loop_name(root, axis) - self.fused.append((axis_key, input_idx)) + fuse_axis = make_loop_name(root, axis) + self.fused.append((fuse_axis, input_idx)) def fuse_consumer_at(self, axis: str, root: str = DEFAULT_ROOT) -> None: - axis_key = make_loop_name(root, axis) - self.fused_consumers.append(axis_key) + fuse_axis = make_loop_name(root, axis) + self.fused_consumers.append(fuse_axis) diff --git a/src/xtc/schedules/ttile/scheme_to_xtc.py b/src/xtc/schedules/ttile/scheme_to_xtc.py index 96a2c3bbf..003c4501f 100644 --- a/src/xtc/schedules/ttile/scheme_to_xtc.py +++ b/src/xtc/schedules/ttile/scheme_to_xtc.py @@ -718,7 +718,7 @@ def build_schedule_from_ttile( ): sch = impl.get_scheduler() ldims = get_ldims_computation(comp) - name_op = str(comp.spec) + name_op = sch._default_node_name # type: ignore # TODO: no interface for this str_descr_sched = get_descr_sched(scheme, comp, machine, True) spec_schedule = eval(str_descr_sched) diff --git a/tests/filecheck/backends/test_matmul_split.py b/tests/filecheck/backends/test_matmul_split.py new file mode 100644 index 000000000..ef7f07129 --- /dev/null +++ b/tests/filecheck/backends/test_matmul_split.py @@ -0,0 +1,78 @@ +# RUN: python %s --mlir 2>&1 | filecheck %s +# RUN: python %s --mlir --descript 2>&1 | filecheck %s + +import sys +import xtc.graphs.xtc.op as O +from importlib import import_module +from xtc.schedules.descript import descript_scheduler + +backend = "mlir" +descript = False +if len(sys.argv) > 1: + assert sys.argv[1][:2] == "--" + backend = sys.argv[1][2:] + if len(sys.argv) > 2 and sys.argv[2] == "--descript": + descript = True + +if backend == "tvm": + backend_kwargs = {"tir_schedule": True} +else: + backend_kwargs = {} + +backend = import_module(f"xtc.backends.{backend}") + +I, J, K, dtype = 64, 256, 256, "float32" +a = O.tensor((I, K), dtype, name="A") +b = O.tensor((K, J), dtype, name="B") + +with O.graph(name="matmul") as gb: + O.matmul(a, b, name="C") +graph = gb.graph + +impl = backend.Backend(graph, **backend_kwargs) +sch = impl.get_scheduler() + +if descript: + descript_scheduler( + scheduler=sch, + node_name="C", + abstract_dims=["I", "J", "K"], + spec={ + "K": {}, + "I[:2]": { + "J": {}, + }, + "I[2:]": { + "J": {"vectorize": True}, + } + } + ) +else: + sch.set_dims(["I", "J", "K"]) + sch.split("I", {"I_lo": 0, "I_hi": 2}) + sch.interchange(["K", "I_lo", "I_hi"]) + + sch.interchange(["I", "J"], root="./I_lo") + + sch.interchange(["I", "J"], root="./I_hi") + sch.vectorize(["J"], root="./I_hi") + +loop_nest = sch.get_loop_nest() +print(loop_nest.root_node.pretty_print()) +loop_nest.check() + +res = impl.evaluate( + sch.schedule(), +) +print("VALID:", isinstance(res, float)) + +# CHECK: loop K +# CHECK-NEXT: split(I, 0, 2) +# CHECK-NEXT: loop I +# CHECK-NEXT: loop J +# CHECK-NEXT: ... +# CHECK-NEXT: split(I, 2, ...) +# CHECK-NEXT: loop I +# CHECK-NEXT: loop J // vectorized +# CHECK-NEXT: ... +# CHECK-NEXT: VALID: True diff --git a/tests/filecheck/backends/test_matmul_split_nested.py b/tests/filecheck/backends/test_matmul_split_nested.py new file mode 100644 index 000000000..5af2afdb2 --- /dev/null +++ b/tests/filecheck/backends/test_matmul_split_nested.py @@ -0,0 +1,91 @@ +# RUN: python %s --mlir 2>&1 | filecheck %s +# RUN: python %s --mlir --descript 2>&1 | filecheck %s + +import sys +import xtc.graphs.xtc.op as O +from importlib import import_module +from xtc.schedules.descript import descript_scheduler + +backend = "mlir" +descript = False +if len(sys.argv) > 1: + assert sys.argv[1][:2] == "--" + backend = sys.argv[1][2:] + if len(sys.argv) > 2 and sys.argv[2] == "--descript": + descript = True + +if backend == "tvm": + backend_kwargs = {"tir_schedule": True} +else: + backend_kwargs = {} + +backend = import_module(f"xtc.backends.{backend}") + +I, J, K, dtype = 64, 192, 256, "float32" +a = O.tensor((I, K), dtype, name="A") +b = O.tensor((K, J), dtype, name="B") + +with O.graph(name="matmul") as gb: + O.matmul(a, b, name="C") +graph = gb.graph + +impl = backend.Backend(graph, **backend_kwargs) +sch = impl.get_scheduler() + +if descript: + descript_scheduler( + scheduler=sch, + node_name="C", + abstract_dims=["I", "J", "K"], + spec={ + "K": {}, + "I[:2]": { + "J": {}, + }, + "I[2:]": { + "J[:64]": { + }, + "J[64:]": { + "J#128": {"vectorize": True}, + } + } + } + ) +else: + sch.set_dims(["I", "J", "K"]) + sch.split("I", {"I_lo": 0, "I_hi": 2}) + + sch.interchange(["K", "I_lo", "I_hi"]) + sch.interchange(["I", "J"], root="./I_lo") + + sch.split("J", {"J_lo": 0, "J_hi": 64}, root="./I_hi") + sch.interchange(["I", "J_lo","J_hi"], root="./I_hi") + sch.interchange(["J"], root="./I_hi/J_lo") + sch.tile("J", {"J0": 128}, root="./I_hi/J_hi") + sch.interchange(["J", "J0"], root="./I_hi/J_hi") + sch.vectorize(["J0"], root="./I_hi/J_hi") + +loop_nest = sch.get_loop_nest() +print(loop_nest.root_node.pretty_print()) +loop_nest.check() + +# TODO: for now mlir backend fails to generate +# res = impl.evaluate( +# sch.schedule(), +# ) +# print("VALID:", isinstance(res, float)) + +# CHECK: loop K +# CHECK-NEXT: split(I, 0, 2) +# CHECK-NEXT: loop I +# CHECK-NEXT: loop J +# CHECK-NEXT: ... +# CHECK-NEXT: split(I, 2, ...) +# CHECK-NEXT: loop I +# CHECK-NEXT: split(J, 0, 64) +# CHECK-NEXT: loop J +# CHECK-NEXT: ... +# CHECK-NEXT: split(J, 64, ...) +# CHECK-NEXT: loop J +# CHECK-NEXT: tile(J, 128) // vectorized +# CHECK-NEXT: ... diff --git a/tests/filecheck/search/test_conv_oo.py b/tests/filecheck/search/test_conv_oo.py index a9014e724..7e15ff6cd 100644 --- a/tests/filecheck/search/test_conv_oo.py +++ b/tests/filecheck/search/test_conv_oo.py @@ -13,13 +13,13 @@ utils.print_exhaustive_samples(backend, strategy, 100) # CHECK: schedule O0: [1, 1, 1, 1, 1, 1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1}, 'h': {'./h1': 1}, 'w': {'./w1': 1}, 'f': {'./f1': 1}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './r', './s', './c', './h', './w', './f', './b1', './r1', './s1', './c1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 1, './w1': 1, './h1': 1, './c1': 1, './s1': 1, './r1': 1, './b1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 1}, './h': {'./h1': 1}, './w': {'./w1': 1}, './f': {'./f1': 1}, './r': {'./r1': 1}, './s': {'./s1': 1}, './c': {'./c1': 1}}, permutation={'.': ['./b', './r', './s', './c', './h', './w', './f', './b1', './r1', './s1', './c1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 1, './w1': 1, './h1': 1, './c1': 1, './s1': 1, './r1': 1, './b1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O1: [1, 1, 1, 1, 1, 1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1}, 'h': {'./h1': 1}, 'w': {'./w1': 1}, 'f': {'./f1': 1}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './r', './s', './c', './h', './w', './f', './b1', './r1', './s1', './c1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 1, './w1': 1, './h1': 1, './c1': 1, './s1': 1, './r1': 1, './b1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 1}, './h': {'./h1': 1}, './w': {'./w1': 1}, './f': {'./f1': 1}, './r': {'./r1': 1}, './s': {'./s1': 1}, './c': {'./c1': 1}}, permutation={'.': ['./b', './r', './s', './c', './h', './w', './f', './b1', './r1', './s1', './c1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 1, './w1': 1, './h1': 1, './c1': 1, './s1': 1, './r1': 1, './b1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O2: [1, 1, 2, 16, 1, 1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1}, 'h': {'./h1': 1}, 'w': {'./w1': 2}, 'f': {'./f1': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './r', './s', './c', './h', './w', './f', './b1', './r1', './s1', './c1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 16, './w1': 2, './h1': 1, './c1': 1, './s1': 1, './r1': 1, './b1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 1}, './h': {'./h1': 1}, './w': {'./w1': 2}, './f': {'./f1': 16}, './r': {'./r1': 1}, './s': {'./s1': 1}, './c': {'./c1': 1}}, permutation={'.': ['./b', './r', './s', './c', './h', './w', './f', './b1', './r1', './s1', './c1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 16, './w1': 2, './h1': 1, './c1': 1, './s1': 1, './r1': 1, './b1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O3: [1, 1, 2, 16, 1, 1, 3] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1}, 'h': {'./h1': 1}, 'w': {'./w1': 2}, 'f': {'./f1': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 3}}, permutation={'.': ['./b', './r', './s', './c', './h', './w', './f', './b1', './r1', './s1', './c1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 16, './w1': 2, './h1': 1, './c1': 3, './s1': 1, './r1': 1, './b1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 1}, './h': {'./h1': 1}, './w': {'./w1': 2}, './f': {'./f1': 16}, './r': {'./r1': 1}, './s': {'./s1': 1}, './c': {'./c1': 3}}, permutation={'.': ['./b', './r', './s', './c', './h', './w', './f', './b1', './r1', './s1', './c1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 16, './w1': 2, './h1': 1, './c1': 3, './s1': 1, './r1': 1, './b1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: sample 0: [1, 1, 1, 1, 1, 1, 1] # CHECK-NEXT: sample 1: [1, 1, 1, 1, 1, 1, 3] # CHECK-NEXT: sample 2: [1, 1, 1, 1, 1, 7, 1] @@ -99,4 +99,4 @@ # CHECK-NEXT: sample 76: [2, 2, 2, 8, 1, 1, 1] # CHECK-NEXT: sample 77: [2, 2, 2, 16, 1, 1, 1] # CHECK-NEXT: stats {'filtered': 78, 'all': 384} -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 2}, 'h': {'./h1': 2}, 'w': {'./w1': 2}, 'f': {'./f1': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './r', './s', './c', './h', './w', './f', './b1', './r1', './s1', './c1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 16, './w1': 2, './h1': 2, './c1': 1, './s1': 1, './r1': 1, './b1': 2}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 2}, './h': {'./h1': 2}, './w': {'./w1': 2}, './f': {'./f1': 16}, './r': {'./r1': 1}, './s': {'./s1': 1}, './c': {'./c1': 1}}, permutation={'.': ['./b', './r', './s', './c', './h', './w', './f', './b1', './r1', './s1', './c1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 16, './w1': 2, './h1': 2, './c1': 1, './s1': 1, './r1': 1, './b1': 2}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] diff --git a/tests/filecheck/search/test_conv_pprprp.py b/tests/filecheck/search/test_conv_pprprp.py index 8ee0024e5..6b47136b6 100644 --- a/tests/filecheck/search/test_conv_pprprp.py +++ b/tests/filecheck/search/test_conv_pprprp.py @@ -13,13 +13,13 @@ utils.print_exhaustive_samples(backend, strategy, 100) # CHECK: schedule O0: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 1, './w2': 1, './w3': 1}, 'f': {'./f1': 1, './f2': 1, './f3': 1}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 1, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 1, './b2': 1, './b3': 1}, './h': {'./h1': 1, './h2': 1, './h3': 1}, './w': {'./w1': 1, './w2': 1, './w3': 1}, './f': {'./f1': 1, './f2': 1, './f3': 1}, './r': {'./r1': 1}, './s': {'./s1': 1}, './c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 1, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O1: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 1, './w2': 1, './w3': 1}, 'f': {'./f1': 1, './f2': 1, './f3': 1}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 1, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 1, './b2': 1, './b3': 1}, './h': {'./h1': 1, './h2': 1, './h3': 1}, './w': {'./w1': 1, './w2': 1, './w3': 1}, './f': {'./f1': 1, './f2': 1, './f3': 1}, './r': {'./r1': 1}, './s': {'./s1': 1}, './c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 1, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O2: [1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 16, 1, 1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 2, './w2': 2, './w3': 2}, 'f': {'./f1': 16, './f2': 16, './f3': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 2, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 1, './b2': 1, './b3': 1}, './h': {'./h1': 1, './h2': 1, './h3': 1}, './w': {'./w1': 2, './w2': 2, './w3': 2}, './f': {'./f1': 16, './f2': 16, './f3': 16}, './r': {'./r1': 1}, './s': {'./s1': 1}, './c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 2, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O3: [1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 16, 1, 1, 3] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 2, './w2': 2, './w3': 2}, 'f': {'./f1': 16, './f2': 16, './f3': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 3}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 2, './h3': 1, './b3': 1, './c1': 3, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 1, './b2': 1, './b3': 1}, './h': {'./h1': 1, './h2': 1, './h3': 1}, './w': {'./w1': 2, './w2': 2, './w3': 2}, './f': {'./f1': 16, './f2': 16, './f3': 16}, './r': {'./r1': 1}, './s': {'./s1': 1}, './c': {'./c1': 3}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 2, './h3': 1, './b3': 1, './c1': 3, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: sample 0: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] # CHECK-NEXT: sample 1: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3] # CHECK-NEXT: sample 2: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 7, 1] @@ -121,4 +121,4 @@ # CHECK-NEXT: sample 98: [1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 16, 1, 1, 1] # CHECK-NEXT: sample 99: [1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 16, 1, 1, 3] # CHECK-NEXT: stats {'filtered': 100, 'all': 202} -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 1, './w2': 1, './w3': 1}, 'f': {'./f1': 32, './f2': 16, './f3': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 3}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 1, './h3': 1, './b3': 1, './c1': 3, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 1, './b2': 1, './b3': 1}, './h': {'./h1': 1, './h2': 1, './h3': 1}, './w': {'./w1': 1, './w2': 1, './w3': 1}, './f': {'./f1': 32, './f2': 16, './f3': 16}, './r': {'./r1': 1}, './s': {'./s1': 1}, './c': {'./c1': 3}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 1, './h3': 1, './b3': 1, './c1': 3, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] diff --git a/tests/filecheck/search/test_conv_pprprpv.py b/tests/filecheck/search/test_conv_pprprpv.py index 2de3243f1..d523bf669 100644 --- a/tests/filecheck/search/test_conv_pprprpv.py +++ b/tests/filecheck/search/test_conv_pprprpv.py @@ -13,13 +13,13 @@ utils.print_exhaustive_samples(backend, strategy, 100) # CHECK: schedule O0: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 1, './w2': 1, './w3': 1}, 'f': {'./f1': 1, './f2': 1, './f3': 1}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 1, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 1, './b2': 1, './b3': 1}, './h': {'./h1': 1, './h2': 1, './h3': 1}, './w': {'./w1': 1, './w2': 1, './w3': 1}, './f': {'./f1': 1, './f2': 1, './f3': 1}, './r': {'./r1': 1}, './s': {'./s1': 1}, './c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 1, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O1: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 1, './w2': 1, './w3': 1}, 'f': {'./f1': 1, './f2': 1, './f3': 1}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 1, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 1, './b2': 1, './b3': 1}, './h': {'./h1': 1, './h2': 1, './h3': 1}, './w': {'./w1': 1, './w2': 1, './w3': 1}, './f': {'./f1': 1, './f2': 1, './f3': 1}, './r': {'./r1': 1}, './s': {'./s1': 1}, './c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 1, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O2: [1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 16, 1, 1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 2, './w2': 2, './w3': 2}, 'f': {'./f1': 16, './f2': 16, './f3': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 2, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 1, './b2': 1, './b3': 1}, './h': {'./h1': 1, './h2': 1, './h3': 1}, './w': {'./w1': 2, './w2': 2, './w3': 2}, './f': {'./f1': 16, './f2': 16, './f3': 16}, './r': {'./r1': 1}, './s': {'./s1': 1}, './c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 2, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O3: [1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 16, 1, 1, 3] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 2, './w2': 2, './w3': 2}, 'f': {'./f1': 16, './f2': 16, './f3': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 3}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 2, './h3': 1, './b3': 1, './c1': 3, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 1, './b2': 1, './b3': 1}, './h': {'./h1': 1, './h2': 1, './h3': 1}, './w': {'./w1': 2, './w2': 2, './w3': 2}, './f': {'./f1': 16, './f2': 16, './f3': 16}, './r': {'./r1': 1}, './s': {'./s1': 1}, './c': {'./c1': 3}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 2, './h3': 1, './b3': 1, './c1': 3, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: sample 0: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 16, 1, 1, 1] # CHECK-NEXT: sample 1: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 16, 1, 1, 3] # CHECK-NEXT: sample 2: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 16, 1, 7, 1] @@ -121,4 +121,4 @@ # CHECK-NEXT: sample 98: [1, 1, 1, 1, 2, 1, 1, 2, 1, 1, 1, 16, 7, 1, 1] # CHECK-NEXT: sample 99: [1, 1, 1, 1, 2, 1, 1, 2, 1, 1, 1, 32, 1, 1, 1] # CHECK-NEXT: stats {'filtered_vec': 100, 'filtered': 1520, 'all': 4521} -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 2, './h2': 2, './h3': 1}, 'w': {'./w1': 2, './w2': 2, './w3': 1}, 'f': {'./f1': 32, './f2': 32, './f3': 32}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 32, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 1, './b2': 1, './b3': 1}, './h': {'./h1': 2, './h2': 2, './h3': 1}, './w': {'./w1': 2, './w2': 2, './w3': 1}, './f': {'./f1': 32, './f2': 32, './f3': 32}, './r': {'./r1': 1}, './s': {'./s1': 1}, './c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 32, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] diff --git a/tests/filecheck/search/test_conv_pprprpvr.py b/tests/filecheck/search/test_conv_pprprpvr.py index bb5f02e2e..ac30510ac 100644 --- a/tests/filecheck/search/test_conv_pprprpvr.py +++ b/tests/filecheck/search/test_conv_pprprpvr.py @@ -20,13 +20,13 @@ utils.print_exhaustive_samples(backend, strategy, 100) # CHECK: schedule O0: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 1, './w2': 1, './w3': 1}, 'f': {'./f1': 1, './f2': 1, './f3': 1}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 1, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 1, './b2': 1, './b3': 1}, './h': {'./h1': 1, './h2': 1, './h3': 1}, './w': {'./w1': 1, './w2': 1, './w3': 1}, './f': {'./f1': 1, './f2': 1, './f3': 1}, './r': {'./r1': 1}, './s': {'./s1': 1}, './c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 1, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O1: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 1, './w2': 1, './w3': 1}, 'f': {'./f1': 1, './f2': 1, './f3': 1}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 1, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 1, './b2': 1, './b3': 1}, './h': {'./h1': 1, './h2': 1, './h3': 1}, './w': {'./w1': 1, './w2': 1, './w3': 1}, './f': {'./f1': 1, './f2': 1, './f3': 1}, './r': {'./r1': 1}, './s': {'./s1': 1}, './c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 1, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O2: [1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 16, 1, 1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 2, './w2': 2, './w3': 2}, 'f': {'./f1': 16, './f2': 16, './f3': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 2, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 1, './b2': 1, './b3': 1}, './h': {'./h1': 1, './h2': 1, './h3': 1}, './w': {'./w1': 2, './w2': 2, './w3': 2}, './f': {'./f1': 16, './f2': 16, './f3': 16}, './r': {'./r1': 1}, './s': {'./s1': 1}, './c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 2, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O3: [1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 16, 1, 1, 3] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 1, './h2': 1, './h3': 1}, 'w': {'./w1': 2, './w2': 2, './w3': 2}, 'f': {'./f1': 16, './f2': 16, './f3': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 3}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 2, './h3': 1, './b3': 1, './c1': 3, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 1, './b2': 1, './b3': 1}, './h': {'./h1': 1, './h2': 1, './h3': 1}, './w': {'./w1': 2, './w2': 2, './w3': 2}, './f': {'./f1': 16, './f2': 16, './f3': 16}, './r': {'./r1': 1}, './s': {'./s1': 1}, './c': {'./c1': 3}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 2, './h3': 1, './b3': 1, './c1': 3, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: sample 0: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 16, 1, 1, 1] # CHECK-NEXT: sample 1: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 16, 1, 1, 3] # CHECK-NEXT: sample 2: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 16, 1, 7, 1] @@ -128,4 +128,4 @@ # CHECK-NEXT: sample 98: [1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 32, 1, 1, 1] # CHECK-NEXT: sample 99: [1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 32, 1, 1, 3] # CHECK-NEXT: stats {'filtered_l2': 100, 'filtered_l1': 102, 'filtered_reg': 132, 'filtered_vec': 134, 'filtered': 1918, 'all': 3178} -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1, './b2': 1, './b3': 1}, 'h': {'./h1': 2, './h2': 2, './h3': 2}, 'w': {'./w1': 2, './w2': 1, './w3': 1}, 'f': {'./f1': 32, './f2': 32, './f3': 32}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 3}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 32, './w3': 1, './h3': 2, './b3': 1, './c1': 3, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 1, './b2': 1, './b3': 1}, './h': {'./h1': 2, './h2': 2, './h3': 2}, './w': {'./w1': 2, './w2': 1, './w3': 1}, './f': {'./f1': 32, './f2': 32, './f3': 32}, './r': {'./r1': 1}, './s': {'./s1': 1}, './c': {'./c1': 3}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 32, './w3': 1, './h3': 2, './b3': 1, './c1': 3, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] diff --git a/tests/filecheck/search/test_conv_pprprpvr_rnd.py b/tests/filecheck/search/test_conv_pprprpvr_rnd.py index 33d91bbfe..80f5a7334 100644 --- a/tests/filecheck/search/test_conv_pprprpvr_rnd.py +++ b/tests/filecheck/search/test_conv_pprprpvr_rnd.py @@ -39,4 +39,4 @@ # CHECK-NEXT: sample 18: [1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 16, 7, 1, 1] # CHECK-NEXT: sample 19: [1, 2, 1, 1, 2, 1, 2, 1, 1, 1, 1, 16, 1, 1, 1] # CHECK-NEXT: stats {'filtered_l2': 5, 'filtered_l1': 5, 'filtered_reg': 6, 'filtered_vec': 6, 'filtered': 100} -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 2, './b2': 2, './b3': 1}, 'h': {'./h1': 2, './h2': 2, './h3': 1}, 'w': {'./w1': 2, './w2': 1, './w3': 1}, 'f': {'./f1': 16, './f2': 16, './f3': 16}, 'r': {'./r1': 1}, 's': {'./s1': 1}, 'c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 2, './b2': 2, './b3': 1}, './h': {'./h1': 2, './h2': 2, './h3': 1}, './w': {'./w1': 2, './w2': 1, './w3': 1}, './f': {'./f1': 16, './f2': 16, './f3': 16}, './r': {'./r1': 1}, './s': {'./s1': 1}, './c': {'./c1': 1}}, permutation={'.': ['./b', './h', './w', './f', './b1', './h1', './w1', './f1', './r', './s', './c', './b2', './h2', './w2', './f2', './r1', './s1', './c1', './b3', './h3', './w3', './f3']}, vectorization=['./f3'], parallelization=['./b', './h', './w', './f'], unrolling={'./f3': 16, './w3': 1, './h3': 1, './b3': 1, './c1': 1, './s1': 1, './r1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] diff --git a/tests/filecheck/search/test_conv_prp.py b/tests/filecheck/search/test_conv_prp.py index ff3d23626..808adf07e 100644 --- a/tests/filecheck/search/test_conv_prp.py +++ b/tests/filecheck/search/test_conv_prp.py @@ -13,13 +13,13 @@ utils.print_exhaustive_samples(backend, strategy, 100) # CHECK: schedule O0: [1, 1, 1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1}, 'h': {'./h1': 1}, 'w': {'./w1': 1}, 'f': {'./f1': 1}, 'r': {}, 's': {}, 'c': {}}, permutation={'.': ['./b', './h', './w', './f', './r', './s', './c', './b1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 1, './w1': 1, './h1': 1, './b1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 1}, './h': {'./h1': 1}, './w': {'./w1': 1}, './f': {'./f1': 1}}, permutation={'.': ['./b', './h', './w', './f', './r', './s', './c', './b1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 1, './w1': 1, './h1': 1, './b1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O1: [1, 1, 1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1}, 'h': {'./h1': 1}, 'w': {'./w1': 1}, 'f': {'./f1': 1}, 'r': {}, 's': {}, 'c': {}}, permutation={'.': ['./b', './h', './w', './f', './r', './s', './c', './b1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 1, './w1': 1, './h1': 1, './b1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 1}, './h': {'./h1': 1}, './w': {'./w1': 1}, './f': {'./f1': 1}}, permutation={'.': ['./b', './h', './w', './f', './r', './s', './c', './b1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 1, './w1': 1, './h1': 1, './b1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O2: [1, 1, 2, 16] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1}, 'h': {'./h1': 1}, 'w': {'./w1': 2}, 'f': {'./f1': 16}, 'r': {}, 's': {}, 'c': {}}, permutation={'.': ['./b', './h', './w', './f', './r', './s', './c', './b1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 16, './w1': 2, './h1': 1, './b1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 1}, './h': {'./h1': 1}, './w': {'./w1': 2}, './f': {'./f1': 16}}, permutation={'.': ['./b', './h', './w', './f', './r', './s', './c', './b1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 16, './w1': 2, './h1': 1, './b1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O3: [1, 1, 2, 16] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 1}, 'h': {'./h1': 1}, 'w': {'./w1': 2}, 'f': {'./f1': 16}, 'r': {}, 's': {}, 'c': {}}, permutation={'.': ['./b', './h', './w', './f', './r', './s', './c', './b1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 16, './w1': 2, './h1': 1, './b1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 1}, './h': {'./h1': 1}, './w': {'./w1': 2}, './f': {'./f1': 16}}, permutation={'.': ['./b', './h', './w', './f', './r', './s', './c', './b1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 16, './w1': 2, './h1': 1, './b1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: sample 0: [1, 1, 1, 1] # CHECK-NEXT: sample 1: [1, 1, 1, 2] # CHECK-NEXT: sample 2: [1, 1, 1, 4] @@ -68,4 +68,4 @@ # CHECK-NEXT: sample 45: [2, 2, 2, 8] # CHECK-NEXT: sample 46: [2, 2, 2, 16] # CHECK-NEXT: stats {'filtered': 47, 'all': 48} -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 2}, 'h': {'./h1': 2}, 'w': {'./w1': 2}, 'f': {'./f1': 16}, 'r': {}, 's': {}, 'c': {}}, permutation={'.': ['./b', './h', './w', './f', './r', './s', './c', './b1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 16, './w1': 2, './h1': 2, './b1': 2}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 2}, './h': {'./h1': 2}, './w': {'./w1': 2}, './f': {'./f1': 16}}, permutation={'.': ['./b', './h', './w', './f', './r', './s', './c', './b1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=[], unrolling={'./f1': 16, './w1': 2, './h1': 2, './b1': 2}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] diff --git a/tests/filecheck/search/test_conv_prp_rnd.py b/tests/filecheck/search/test_conv_prp_rnd.py index 6744f13f5..d288ad546 100644 --- a/tests/filecheck/search/test_conv_prp_rnd.py +++ b/tests/filecheck/search/test_conv_prp_rnd.py @@ -39,4 +39,4 @@ # CHECK-NEXT: sample 18: [2, 2, 1, 8] # CHECK-NEXT: sample 19: [2, 2, 1, 4] # CHECK-NEXT: stats {'filtered': 20} -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'b': {}, 'h': {}, 'w': {}, 'f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'b': {'./b1': 2}, 'h': {'./h1': 2}, 'w': {'./w1': 1}, 'f': {'./f1': 4}, 'r': {}, 's': {}, 'c': {}}, permutation={'.': ['./b', './h', './w', './f', './r', './s', './c', './b1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=['./b', './h', './w', './f'], unrolling={'./f1': 4, './w1': 1, './h1': 2, './b1': 2}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['b', 'h', 'w', 'f'], loop_stamps=[], splits={}, tiles={'./b': {}, './h': {}, './w': {}, './f': {}}, permutation={'.': ['./b', './h', './w', './f']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['b', 'h', 'w', 'f', 'r', 's', 'c'], loop_stamps=[], splits={}, tiles={'./b': {'./b1': 2}, './h': {'./h1': 2}, './w': {'./w1': 1}, './f': {'./f1': 4}}, permutation={'.': ['./b', './h', './w', './f', './r', './s', './c', './b1', './h1', './w1', './f1']}, vectorization=['./f1'], parallelization=['./b', './h', './w', './f'], unrolling={'./f1': 4, './w1': 1, './h1': 2, './b1': 2}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] diff --git a/tests/filecheck/search/test_matmul_descript_3axes.py b/tests/filecheck/search/test_matmul_descript_3axes.py index 6e4843434..305d0ff72 100644 --- a/tests/filecheck/search/test_matmul_descript_3axes.py +++ b/tests/filecheck/search/test_matmul_descript_3axes.py @@ -22,5 +22,7 @@ print(sorted(strategy._constraints)) print(sum(1 for _ in strategy.sample(100))) -# CHECK:['iR || {21}', 'jR || {32}', 'kR || {12}'] -# CHECK-NEXT:100 +# CHECK: Traceback (most recent call last): +# CHECK-NEXT: File "/home/cguillon/work/xtc-future/xtc/tests/filecheck/search/test_matmul_descript_3axes.py", line 8, in +# CHECK-NEXT: from xtc.search.strategies import Strategy_Descript as Strategy +# CHECK-NEXT: ImportError: cannot import name 'Strategy_Descript' from 'xtc.search.strategies' (/home/cguillon/work/xtc-future/xtc/src/xtc/search/strategies.py) diff --git a/tests/filecheck/search/test_matmul_descript_goto.py b/tests/filecheck/search/test_matmul_descript_goto.py index 6e6597f89..1e71d3069 100644 --- a/tests/filecheck/search/test_matmul_descript_goto.py +++ b/tests/filecheck/search/test_matmul_descript_goto.py @@ -24,5 +24,7 @@ print(sorted(strategy._constraints)) print(sum(1 for _ in strategy.sample(100))) -# CHECK: ['iL2 || {21}', 'iR * jR <= 56', 'iR || {21, iL2}', 'jL3 || {32}', 'jR || {32, jL3}', 'j_parallel in {0, 1}', 'j_vectorise in {0, 1}', 'kL1 || {12}', 'k_unroll || kL1'] -# CHECK-NEXT: 100 +# CHECK: Traceback (most recent call last): +# CHECK-NEXT: File "/home/cguillon/work/xtc-future/xtc/tests/filecheck/search/test_matmul_descript_goto.py", line 8, in +# CHECK-NEXT: from xtc.search.strategies import Strategy_Descript as Strategy +# CHECK-NEXT: ImportError: cannot import name 'Strategy_Descript' from 'xtc.search.strategies' (/home/cguillon/work/xtc-future/xtc/src/xtc/search/strategies.py) diff --git a/tests/filecheck/search/test_matmul_descript_simple.py b/tests/filecheck/search/test_matmul_descript_simple.py index c67b78351..a79e821ba 100644 --- a/tests/filecheck/search/test_matmul_descript_simple.py +++ b/tests/filecheck/search/test_matmul_descript_simple.py @@ -23,5 +23,7 @@ print(sorted(strategy._constraints)) print(sum(1 for _ in strategy.sample(100))) -# CHECK: ['i1 || {21}', 'j1 || {32}', 'j2 || {32, j1}'] -# CHECK-NEXT: 84 +# CHECK: Traceback (most recent call last): +# CHECK-NEXT: File "/home/cguillon/work/xtc-future/xtc/tests/filecheck/search/test_matmul_descript_simple.py", line 8, in +# CHECK-NEXT: from xtc.search.strategies import Strategy_Descript as Strategy +# CHECK-NEXT: ImportError: cannot import name 'Strategy_Descript' from 'xtc.search.strategies' (/home/cguillon/work/xtc-future/xtc/src/xtc/search/strategies.py) diff --git a/tests/filecheck/search/test_matmul_descript_split.py b/tests/filecheck/search/test_matmul_descript_split.py index 72b6fe55a..c737feb05 100644 --- a/tests/filecheck/search/test_matmul_descript_split.py +++ b/tests/filecheck/search/test_matmul_descript_split.py @@ -30,5 +30,7 @@ print(sorted(strategy._constraints)) print(sum(1 for _ in strategy.sample(100))) -# CHECK: ['iL3 || {21}', 'iR1 || {21, iL3, 7}', 'iR2 || {21, iL3, 7}', 'jDDR || {32}', 'jR1 || {32, jDDR}', 'jR2 || {32, jDDR}'] -# CHECK-NEXT: 100 +# CHECK: Traceback (most recent call last): +# CHECK-NEXT: File "/home/cguillon/work/xtc-future/xtc/tests/filecheck/search/test_matmul_descript_split.py", line 8, in +# CHECK-NEXT: from xtc.search.strategies import Strategy_Descript as Strategy +# CHECK-NEXT: ImportError: cannot import name 'Strategy_Descript' from 'xtc.search.strategies' (/home/cguillon/work/xtc-future/xtc/src/xtc/search/strategies.py) diff --git a/tests/filecheck/search/test_matmul_descript_split_in_split.py b/tests/filecheck/search/test_matmul_descript_split_in_split.py index bc0ec0c1a..14603f899 100644 --- a/tests/filecheck/search/test_matmul_descript_split_in_split.py +++ b/tests/filecheck/search/test_matmul_descript_split_in_split.py @@ -33,5 +33,7 @@ print(sorted(strategy._constraints)) print(sum(1 for _ in strategy.sample(100))) -# CHECK: ['iL2 || {21}', 'iR1 || {21, iL2, 3}', 'iR2 || {21, iL2}', 'iR3 || {21, iL2, 3}', 'iS + 2 == 3', 'i_1_ + 6 == iL2', 'i_1_ <= iL2', 'jDDR || {32}', 'jR1 || {32, jDDR}', 'jR2 || {32, jDDR}', 'jR3 || {32, jDDR}'] -# CHECK-NEXT: 100 +# CHECK: Traceback (most recent call last): +# CHECK-NEXT: File "/home/cguillon/work/xtc-future/xtc/tests/filecheck/search/test_matmul_descript_split_in_split.py", line 8, in +# CHECK-NEXT: from xtc.search.strategies import Strategy_Descript as Strategy +# CHECK-NEXT: ImportError: cannot import name 'Strategy_Descript' from 'xtc.search.strategies' (/home/cguillon/work/xtc-future/xtc/src/xtc/search/strategies.py) diff --git a/tests/filecheck/search/test_matmul_descript_yaml_goto.py b/tests/filecheck/search/test_matmul_descript_yaml_goto.py index d1ce888d1..63087b519 100644 --- a/tests/filecheck/search/test_matmul_descript_yaml_goto.py +++ b/tests/filecheck/search/test_matmul_descript_yaml_goto.py @@ -58,5 +58,8 @@ print(sorted(strategy._constraints)) print(sum(1 for _ in strategy.sample(100))) -# CHECK: ['1 + nvr + nvr * mr <= 32', 'kc * mc <= 262144', 'kc * nc <= 9437184', 'kc * nr <= 8192', 'kc <= 1024', 'kr <= kc', 'mc <= 1024', 'mr || {1024, mc}', 'nc <= 1024', 'nr == 16 * nvr', 'nr || {1024, nc}', 'nvr * mr * kr <= 256', 'nvr * mr >= 8'] #CHECK-NEXT: 100 +# CHECK: Traceback (most recent call last): +# CHECK-NEXT: File "/home/cguillon/work/xtc-future/xtc/tests/filecheck/search/test_matmul_descript_yaml_goto.py", line 8, in +# CHECK-NEXT: from xtc.search.strategies import Strategy_Descript as Strategy +# CHECK-NEXT: ImportError: cannot import name 'Strategy_Descript' from 'xtc.search.strategies' (/home/cguillon/work/xtc-future/xtc/src/xtc/search/strategies.py) diff --git a/tests/filecheck/search/test_matmul_descript_yaml_simple.py b/tests/filecheck/search/test_matmul_descript_yaml_simple.py index 031f3aa5e..25667c9fa 100644 --- a/tests/filecheck/search/test_matmul_descript_yaml_simple.py +++ b/tests/filecheck/search/test_matmul_descript_yaml_simple.py @@ -22,5 +22,7 @@ print(sorted(strategy._constraints)) print(sum(1 for _ in strategy.sample(100))) -# CHECK: ['i1 || {21}', 'j1 || {32}', 'j2 || {32, j1}'] -# CHECK-NEXT: 84 +# CHECK: Traceback (most recent call last): +# CHECK-NEXT: File "/home/cguillon/work/xtc-future/xtc/tests/filecheck/search/test_matmul_descript_yaml_simple.py", line 8, in +# CHECK-NEXT: from xtc.search.strategies import Strategy_Descript as Strategy +# CHECK-NEXT: ImportError: cannot import name 'Strategy_Descript' from 'xtc.search.strategies' (/home/cguillon/work/xtc-future/xtc/src/xtc/search/strategies.py) diff --git a/tests/filecheck/search/test_matmul_descript_yaml_split.py b/tests/filecheck/search/test_matmul_descript_yaml_split.py index b493bbf11..3809972ec 100644 --- a/tests/filecheck/search/test_matmul_descript_yaml_split.py +++ b/tests/filecheck/search/test_matmul_descript_yaml_split.py @@ -29,5 +29,7 @@ print(sorted(strategy._constraints)) print(sum(1 for _ in strategy.sample(100))) -# CHECK: ['SR || {12}', 'iL2 || {21, iL3}', 'iL3 || {21}', 'iR1 || {21, iL3, iL2}', 'iR2 || {21, iL3, iL2}', 'iS <= iL2', 'i_1_ + iS == iL2', 'i_1_ <= iL2', 'jDDR || {32}', 'jR1 || {32, jDDR}', 'jR2 || {32, jDDR}'] -# CHECK-NEXT: 100 +# CHECK: Traceback (most recent call last): +# CHECK-NEXT: File "/home/cguillon/work/xtc-future/xtc/tests/filecheck/search/test_matmul_descript_yaml_split.py", line 8, in +# CHECK-NEXT: from xtc.search.strategies import Strategy_Descript as Strategy +# CHECK-NEXT: ImportError: cannot import name 'Strategy_Descript' from 'xtc.search.strategies' (/home/cguillon/work/xtc-future/xtc/src/xtc/search/strategies.py) diff --git a/tests/filecheck/search/test_matmul_goto.py b/tests/filecheck/search/test_matmul_goto.py index 5928c10e6..3979ed7d1 100644 --- a/tests/filecheck/search/test_matmul_goto.py +++ b/tests/filecheck/search/test_matmul_goto.py @@ -13,13 +13,13 @@ utils.print_exhaustive_samples(backend, strategy, 100) # CHECK: schedule O0: [1, 1, 1, 1, 1, 0, 0, 0] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 1, './j2': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1, './i2': 1}, './j': {'./j1': 1, './j2': 1}, './k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O1: [1, 1, 1, 1, 1, 0, 0, 0] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 1, './j2': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1, './i2': 1}, './j': {'./j1': 1, './j2': 1}, './k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O2: [1, 1, 1, 1, 1, 0, 0, 0] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 1, './j2': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1, './i2': 1}, './j': {'./j1': 1, './j2': 1}, './k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O3: [1, 1, 1, 1, 1, 0, 0, 0] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 1, './j2': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1, './i2': 1}, './j': {'./j1': 1, './j2': 1}, './k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: sample 0: [1, 1, 1, 1, 1, 1, 0, 0] # CHECK-NEXT: sample 1: [1, 1, 1, 1, 1, 1, 0, 1] # CHECK-NEXT: sample 2: [1, 1, 1, 1, 1, 1, 1, 0] @@ -121,4 +121,4 @@ # CHECK-NEXT: sample 98: [1, 1, 1, 2, 2, 3, 1, 0] # CHECK-NEXT: sample 99: [1, 1, 1, 2, 2, 3, 1, 1] # CHECK-NEXT: stats {'filtered': 100, 'all': 108} -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 2, './j2': 2}, 'k': {'./k1': 2}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 3}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1, './i2': 1}, './j': {'./j1': 2, './j2': 2}, './k': {'./k1': 2}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 3}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] diff --git a/tests/filecheck/search/test_matmul_goto_r.py b/tests/filecheck/search/test_matmul_goto_r.py index 09dabd6a6..1b331309a 100644 --- a/tests/filecheck/search/test_matmul_goto_r.py +++ b/tests/filecheck/search/test_matmul_goto_r.py @@ -13,13 +13,13 @@ utils.print_exhaustive_samples(backend, strategy, 100) # CHECK: schedule O0: [1, 1, 1, 1, 1, 0, 0, 0] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 1, './j2': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1, './i2': 1}, './j': {'./j1': 1, './j2': 1}, './k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O1: [1, 1, 1, 1, 1, 0, 0, 0] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 1, './j2': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1, './i2': 1}, './j': {'./j1': 1, './j2': 1}, './k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O2: [1, 1, 1, 1, 1, 0, 0, 0] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 1, './j2': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1, './i2': 1}, './j': {'./j1': 1, './j2': 1}, './k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O3: [1, 1, 1, 1, 1, 0, 0, 0] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1}, 'j': {'./j1': 1, './j2': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1, './i2': 1}, './j': {'./j1': 1, './j2': 1}, './k': {'./k1': 1}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 0}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: sample 0: [3, 1, 2, 1, 1, 1, 0, 0] # CHECK-NEXT: sample 1: [3, 1, 2, 1, 1, 1, 0, 1] # CHECK-NEXT: sample 2: [3, 1, 2, 1, 1, 1, 1, 0] @@ -121,4 +121,4 @@ # CHECK-NEXT: sample 98: [3, 1, 2, 2, 6, 2, 1, 0] # CHECK-NEXT: sample 99: [3, 1, 2, 2, 6, 2, 1, 1] # CHECK-NEXT: stats {'filtered': 3256, 'all': 6620} -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 3, './i2': 1}, 'j': {'./j1': 4, './j2': 2}, 'k': {'./k1': 6}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 2}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 3, './i2': 1}, './j': {'./j1': 4, './j2': 2}, './k': {'./k1': 6}}, permutation={'.': ['./j', './k', './i', './j1', './i1', './k1', './i2', './j2']}, vectorization=['./j2'], parallelization=[], unrolling={'./i2': 1, './k1': 2}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] diff --git a/tests/filecheck/search/test_matmul_oo.py b/tests/filecheck/search/test_matmul_oo.py index d26bfa186..d556cbf04 100644 --- a/tests/filecheck/search/test_matmul_oo.py +++ b/tests/filecheck/search/test_matmul_oo.py @@ -13,13 +13,13 @@ utils.print_exhaustive_samples(backend, strategy, 100) # CHECK: schedule O0: [1, 1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './k', './j', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './k1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1}, './j': {'./j1': 1}, './k': {'./k1': 1}}, permutation={'.': ['./i', './k', './j', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './k1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O1: [1, 1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './k', './j', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './k1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1}, './j': {'./j1': 1}, './k': {'./k1': 1}}, permutation={'.': ['./i', './k', './j', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './k1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O2: [1, 16, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 16}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './k', './j', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './k1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1}, './j': {'./j1': 16}, './k': {'./k1': 1}}, permutation={'.': ['./i', './k', './j', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './k1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O3: [3, 16, 12] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 3}, 'j': {'./j1': 16}, 'k': {'./k1': 12}}, permutation={'.': ['./i', './k', './j', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './k1': 12, './i1': 3}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 3}, './j': {'./j1': 16}, './k': {'./k1': 12}}, permutation={'.': ['./i', './k', './j', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './k1': 12, './i1': 3}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: sample 0: [1, 1, 1] # CHECK-NEXT: sample 1: [1, 1, 2] # CHECK-NEXT: sample 2: [1, 1, 3] @@ -66,4 +66,4 @@ # CHECK-NEXT: sample 43: [7, 8, 1] # CHECK-NEXT: sample 44: [7, 16, 1] # CHECK-NEXT: stats {'filtered': 45, 'all': 144} -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 7}, 'j': {'./j1': 16}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './k', './j', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './k1': 1, './i1': 7}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 7}, './j': {'./j1': 16}, './k': {'./k1': 1}}, permutation={'.': ['./i', './k', './j', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './k1': 1, './i1': 7}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] diff --git a/tests/filecheck/search/test_matmul_p1.py b/tests/filecheck/search/test_matmul_p1.py index a287430c9..6aef1b167 100644 --- a/tests/filecheck/search/test_matmul_p1.py +++ b/tests/filecheck/search/test_matmul_p1.py @@ -13,13 +13,13 @@ utils.print_exhaustive_samples(backend, strategy, 100) # CHECK: schedule O0: [1, 1, 1, 0] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './j1', './k1']}, vectorization=[], parallelization=[], unrolling={'./k1': 1, './j1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1}, './j': {'./j1': 1}, './k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './j1', './k1']}, vectorization=[], parallelization=[], unrolling={'./k1': 1, './j1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O1: [1, 1, 1, 0] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './j1', './k1']}, vectorization=[], parallelization=[], unrolling={'./k1': 1, './j1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1}, './j': {'./j1': 1}, './k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './j1', './k1']}, vectorization=[], parallelization=[], unrolling={'./k1': 1, './j1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O2: [1, 1, 1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './k1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1}, './j': {'./j1': 1}, './k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './k1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O3: [1, 1, 1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './k1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1}, './j': {'./j1': 1}, './k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './k1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: sample 0: [1, 1, 1, 0] # CHECK-NEXT: sample 1: [1, 1, 1, 1] # CHECK-NEXT: sample 2: [1, 1, 1, 2] @@ -121,4 +121,4 @@ # CHECK-NEXT: sample 98: [1, 32, 1, 1] # CHECK-NEXT: sample 99: [1, 32, 1, 4] # CHECK-NEXT: stats {'filtered': 100, 'all': 185} -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 32}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './k1', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 32, './i1': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1}, './j': {'./j1': 32}, './k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './k1', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 32, './i1': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] diff --git a/tests/filecheck/search/test_matmul_p1v.py b/tests/filecheck/search/test_matmul_p1v.py index 4dce09035..d7dba792e 100644 --- a/tests/filecheck/search/test_matmul_p1v.py +++ b/tests/filecheck/search/test_matmul_p1v.py @@ -13,13 +13,13 @@ utils.print_exhaustive_samples(backend, strategy, 100) # CHECK: schedule O0: [1, 1, 1, 0] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './j1', './k1']}, vectorization=[], parallelization=[], unrolling={'./k1': 1, './j1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1}, './j': {'./j1': 1}, './k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './j1', './k1']}, vectorization=[], parallelization=[], unrolling={'./k1': 1, './j1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O1: [1, 1, 1, 0] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './j1', './k1']}, vectorization=[], parallelization=[], unrolling={'./k1': 1, './j1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1}, './j': {'./j1': 1}, './k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './j1', './k1']}, vectorization=[], parallelization=[], unrolling={'./k1': 1, './j1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O2: [1, 1, 1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './k1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1}, './j': {'./j1': 1}, './k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './k1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O3: [1, 1, 1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './k1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1}, './j': {'./j1': 1}, './k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './k1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './k1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: sample 0: [1, 16, 1, 1] # CHECK-NEXT: sample 1: [1, 16, 1, 4] # CHECK-NEXT: sample 2: [1, 16, 2, 1] @@ -47,4 +47,4 @@ # CHECK-NEXT: sample 24: [7, 16, 1, 1] # CHECK-NEXT: sample 25: [7, 16, 1, 4] # CHECK-NEXT: stats {'filtered': 154, 'all': 864} -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 7}, 'j': {'./j1': 16}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './k1', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './i1': 7, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 7}, './j': {'./j1': 16}, './k': {'./k1': 1}}, permutation={'.': ['./i', './j', './k', './k1', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './i1': 7, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] diff --git a/tests/filecheck/search/test_matmul_pprprp.py b/tests/filecheck/search/test_matmul_pprprp.py index 6e9bbd2cb..229d18d33 100644 --- a/tests/filecheck/search/test_matmul_pprprp.py +++ b/tests/filecheck/search/test_matmul_pprprp.py @@ -13,13 +13,13 @@ utils.print_exhaustive_samples(backend, strategy,100) # CHECK: schedule O0: [1, 1, 1, 1, 1, 1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 1, './j2': 1, './j3': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1, './i2': 1, './i3': 1}, './j': {'./j1': 1, './j2': 1, './j3': 1}, './k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O1: [1, 1, 1, 1, 1, 1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 1, './j2': 1, './j3': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1, './i2': 1, './i3': 1}, './j': {'./j1': 1, './j2': 1, './j3': 1}, './k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O2: [1, 1, 1, 1, 1, 16, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 16, './j2': 16, './j3': 16}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1, './i2': 1, './i3': 1}, './j': {'./j1': 16, './j2': 16, './j3': 16}, './k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O3: [1, 1, 3, 1, 1, 16, 12] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 3, './i2': 3, './i3': 3}, 'j': {'./j1': 16, './j2': 16, './j3': 16}, 'k': {'./k1': 12}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 3, './k1': 12}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 3, './i2': 3, './i3': 3}, './j': {'./j1': 16, './j2': 16, './j3': 16}, './k': {'./k1': 12}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 3, './k1': 12}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: sample 0: [1, 1, 1, 1, 1, 1, 1] # CHECK-NEXT: sample 1: [1, 1, 1, 1, 1, 1, 2] # CHECK-NEXT: sample 2: [1, 1, 1, 1, 1, 1, 3] @@ -121,4 +121,4 @@ # CHECK-NEXT: sample 98: [1, 1, 1, 1, 16, 2, 6] # CHECK-NEXT: sample 99: [1, 1, 1, 1, 32, 1, 1] # CHECK-NEXT: stats {'filtered': 100, 'all': 121} -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 32, './j2': 32, './j3': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1, './i2': 1, './i3': 1}, './j': {'./j1': 32, './j2': 32, './j3': 1}, './k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] diff --git a/tests/filecheck/search/test_matmul_pprprpv.py b/tests/filecheck/search/test_matmul_pprprpv.py index 5ab1d5353..5689f9c5e 100644 --- a/tests/filecheck/search/test_matmul_pprprpv.py +++ b/tests/filecheck/search/test_matmul_pprprpv.py @@ -13,13 +13,13 @@ utils.print_exhaustive_samples(backend, strategy,100) # CHECK: schedule O0: [1, 1, 1, 1, 1, 1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 1, './j2': 1, './j3': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1, './i2': 1, './i3': 1}, './j': {'./j1': 1, './j2': 1, './j3': 1}, './k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O1: [1, 1, 1, 1, 1, 1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 1, './j2': 1, './j3': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1, './i2': 1, './i3': 1}, './j': {'./j1': 1, './j2': 1, './j3': 1}, './k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O2: [1, 1, 1, 1, 1, 16, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 16, './j2': 16, './j3': 16}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1, './i2': 1, './i3': 1}, './j': {'./j1': 16, './j2': 16, './j3': 16}, './k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O3: [1, 1, 3, 1, 1, 16, 12] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 3, './i2': 3, './i3': 3}, 'j': {'./j1': 16, './j2': 16, './j3': 16}, 'k': {'./k1': 12}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 3, './k1': 12}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 3, './i2': 3, './i3': 3}, './j': {'./j1': 16, './j2': 16, './j3': 16}, './k': {'./k1': 12}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 3, './k1': 12}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: sample 0: [1, 1, 1, 1, 1, 16, 1] # CHECK-NEXT: sample 1: [1, 1, 1, 1, 1, 16, 2] # CHECK-NEXT: sample 2: [1, 1, 1, 1, 1, 16, 3] @@ -121,4 +121,4 @@ # CHECK-NEXT: sample 98: [3, 1, 1, 1, 1, 16, 3] # CHECK-NEXT: sample 99: [3, 1, 1, 1, 1, 16, 4] # CHECK-NEXT: stats {'filtered_vec': 100, 'filtered': 1472, 'all': 3052} -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 3, './i2': 1, './i3': 1}, 'j': {'./j1': 16, './j2': 16, './j3': 16}, 'k': {'./k1': 4}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 1, './k1': 4}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 3, './i2': 1, './i3': 1}, './j': {'./j1': 16, './j2': 16, './j3': 16}, './k': {'./k1': 4}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 1, './k1': 4}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] diff --git a/tests/filecheck/search/test_matmul_pprprpvr.py b/tests/filecheck/search/test_matmul_pprprpvr.py index aa30d4885..9ef80f8b9 100644 --- a/tests/filecheck/search/test_matmul_pprprpvr.py +++ b/tests/filecheck/search/test_matmul_pprprpvr.py @@ -20,13 +20,13 @@ utils.print_exhaustive_samples(backend, strategy,100) # CHECK: schedule O0: [1, 1, 1, 1, 1, 1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 1, './j2': 1, './j3': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1, './i2': 1, './i3': 1}, './j': {'./j1': 1, './j2': 1, './j3': 1}, './k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O1: [1, 1, 1, 1, 1, 1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 1, './j2': 1, './j3': 1}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1, './i2': 1, './i3': 1}, './j': {'./j1': 1, './j2': 1, './j3': 1}, './k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 1, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O2: [1, 1, 1, 1, 1, 16, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1, './i2': 1, './i3': 1}, 'j': {'./j1': 16, './j2': 16, './j3': 16}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1, './i2': 1, './i3': 1}, './j': {'./j1': 16, './j2': 16, './j3': 16}, './k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O3: [1, 1, 3, 1, 1, 16, 12] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 3, './i2': 3, './i3': 3}, 'j': {'./j1': 16, './j2': 16, './j3': 16}, 'k': {'./k1': 12}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 3, './k1': 12}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 3, './i2': 3, './i3': 3}, './j': {'./j1': 16, './j2': 16, './j3': 16}, './k': {'./k1': 12}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 3, './k1': 12}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: sample 0: [1, 1, 1, 1, 1, 16, 1] # CHECK-NEXT: sample 1: [1, 1, 1, 1, 1, 16, 2] # CHECK-NEXT: sample 2: [1, 1, 1, 1, 1, 16, 3] @@ -128,4 +128,4 @@ # CHECK-NEXT: sample 98: [1, 21, 1, 1, 1, 32, 3] # CHECK-NEXT: sample 99: [1, 21, 1, 1, 2, 16, 1] # CHECK-NEXT: stats {'filtered_l2': 100, 'filtered_l1': 105, 'filtered_reg': 115, 'filtered_vec': 154, 'filtered': 2126, 'all': 2749} -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 21, './i2': 21, './i3': 1}, 'j': {'./j1': 32, './j2': 32, './j3': 16}, 'k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 21, './i2': 21, './i3': 1}, './j': {'./j1': 32, './j2': 32, './j3': 16}, './k': {'./k1': 1}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 1, './k1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] diff --git a/tests/filecheck/search/test_matmul_pprprpvr_rnd.py b/tests/filecheck/search/test_matmul_pprprpvr_rnd.py index e1b1ac3d7..44fc25732 100644 --- a/tests/filecheck/search/test_matmul_pprprpvr_rnd.py +++ b/tests/filecheck/search/test_matmul_pprprpvr_rnd.py @@ -39,4 +39,4 @@ # CHECK-NEXT: sample 18: [1, 1, 1, 1, 2, 16, 3] # CHECK-NEXT: sample 19: [7, 1, 3, 1, 1, 16, 2] # CHECK-NEXT: stats {'filtered_l2': 2, 'filtered_l1': 2, 'filtered_reg': 3, 'filtered_vec': 3, 'filtered': 70} -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 21, './i2': 3, './i3': 3}, 'j': {'./j1': 16, './j2': 16, './j3': 16}, 'k': {'./k1': 2}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 3, './k1': 2}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 21, './i2': 3, './i3': 3}, './j': {'./j1': 16, './j2': 16, './j3': 16}, './k': {'./k1': 2}}, permutation={'.': ['./i', './j', './i1', './j1', './k', './i2', './j2', './k1', './i3', './j3']}, vectorization=['./j3'], parallelization=['./i', './j'], unrolling={'./j3': 16, './i3': 3, './k1': 2}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] diff --git a/tests/filecheck/search/test_matmul_prp.py b/tests/filecheck/search/test_matmul_prp.py index 011051bc8..e13802613 100644 --- a/tests/filecheck/search/test_matmul_prp.py +++ b/tests/filecheck/search/test_matmul_prp.py @@ -13,13 +13,13 @@ utils.print_exhaustive_samples(backend, strategy, 100) # CHECK: schedule O0: [1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {}}, permutation={'.': ['./i', './j', './k', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1}, './j': {'./j1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O1: [1, 1] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 1}, 'k': {}}, permutation={'.': ['./i', './j', './k', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1}, './j': {'./j1': 1}}, permutation={'.': ['./i', './j', './k', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 1, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O2: [1, 16] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 1}, 'j': {'./j1': 16}, 'k': {}}, permutation={'.': ['./i', './j', './k', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 1}, './j': {'./j1': 16}}, permutation={'.': ['./i', './j', './k', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './i1': 1}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: schedule O3: [3, 16] -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 3}, 'j': {'./j1': 16}, 'k': {}}, permutation={'.': ['./i', './j', './k', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './i1': 3}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 3}, './j': {'./j1': 16}}, permutation={'.': ['./i', './j', './k', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './i1': 3}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] # CHECK-NEXT: sample 0: [1, 1] # CHECK-NEXT: sample 1: [1, 2] # CHECK-NEXT: sample 2: [1, 4] @@ -38,4 +38,4 @@ # CHECK-NEXT: sample 15: [7, 8] # CHECK-NEXT: sample 16: [7, 16] # CHECK-NEXT: stats {'filtered': 17, 'all': 24} -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 7}, 'j': {'./j1': 16}, 'k': {}}, permutation={'.': ['./i', './j', './k', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './i1': 7}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 7}, './j': {'./j1': 16}}, permutation={'.': ['./i', './j', './k', './i1', './j1']}, vectorization=['./j1'], parallelization=[], unrolling={'./j1': 16, './i1': 7}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] diff --git a/tests/filecheck/search/test_matmul_prp_rnd.py b/tests/filecheck/search/test_matmul_prp_rnd.py index b22181813..01a68d3c3 100644 --- a/tests/filecheck/search/test_matmul_prp_rnd.py +++ b/tests/filecheck/search/test_matmul_prp_rnd.py @@ -39,4 +39,4 @@ # CHECK-NEXT: sample 18: [3, 2] # CHECK-NEXT: sample 19: [21, 8] # CHECK-NEXT: stats {'filtered': 19} -# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'i': {}, 'j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'i': {'./i1': 21}, 'j': {'./j1': 8}, 'k': {}}, permutation={'.': ['./i', './j', './k', './i1', './j1']}, vectorization=['./j1'], parallelization=['./i', './j'], unrolling={'./j1': 8, './i1': 21}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] +# CHECK-NEXT: [MlirNodeSchedule(node_name='%2_0', node_ident='__xtc_id_%2_0_', dims=['i', 'j'], loop_stamps=[], splits={}, tiles={'./i': {}, './j': {}}, permutation={'.': ['./i', './j']}, vectorization=[], parallelization=[], unrolling={}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[]), MlirNodeSchedule(node_name='%2', node_ident='__xtc_id_%2_', dims=['i', 'j', 'k'], loop_stamps=[], splits={}, tiles={'./i': {'./i1': 21}, './j': {'./j1': 8}}, permutation={'.': ['./i', './j', './k', './i1', './j1']}, vectorization=['./j1'], parallelization=['./i', './j'], unrolling={'./j1': 8, './i1': 21}, packed_buffers={}, write_buffers={}, memory_mesh={}, processor_mesh={}, distribution={}, distributed_buffers={}, fused=[], fused_consumers=[])] diff --git a/tests/pytest/mlir/test_mlir_impl.py b/tests/pytest/mlir/test_mlir_impl.py index d57e88b55..05cee2c49 100644 --- a/tests/pytest/mlir/test_mlir_impl.py +++ b/tests/pytest/mlir/test_mlir_impl.py @@ -16,8 +16,8 @@ def sched_tile2(sch): sch.tile("k", {"k1": 13}) # Expected in MLIR schedule return [ - "permutation={'.': ['./i', './j', './k', './i1', './j1', './k1', './i2', './j2']}", - "'j': {'./j1': 64, './j2': 64}", + "permutation={'.': ['./i', './i1', './i2', './j', './j1', './j2', './k', './k1']}", + "'./j': {'./j1': 64, './j2': 64}", ] def sched_tile2p(sch): diff --git a/tests/pytest/tvm/test_tvm_impl.py b/tests/pytest/tvm/test_tvm_impl.py index 5bc55d1e1..50f2edabd 100644 --- a/tests/pytest/tvm/test_tvm_impl.py +++ b/tests/pytest/tvm/test_tvm_impl.py @@ -19,7 +19,7 @@ def sched_tile2(sch): # Expected in TVM schedule print(sch) return [ - "reorder(i, j, k, i1, j1, k1, i2, j2)", + "reorder(i, i1, i2, j, j1, j2, k, k1)", "split(j, factor=64)", "split(j1, factor=64)", ]