Skip to content

Csl

csl

GetDsdAndOffsetFolding

Bases: RewritePattern

Folds a csl.get_mem_dsd immediately followed by a csl.increment_dsd_offset

Source code in xdsl/transforms/canonicalization_patterns/csl.py 
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
class GetDsdAndOffsetFolding(RewritePattern):
    """
    Folds a `csl.get_mem_dsd` immediately followed by a `csl.increment_dsd_offset`
    """

    @op_type_rewrite_pattern
    def match_and_rewrite(self, op: csl.GetMemDsdOp, rewriter: PatternRewriter) -> None:
        # single use that is `@increment_dsd_offset`
        if not isinstance(
            offset_op := op.result.get_user_of_unique_use(), csl.IncrementDsdOffsetOp
        ):
            return
        # only works on 1d
        if len(op.sizes) > 1:
            return

        # check if we can promote arith.const to property
        if (
            isinstance(offset_op.offset, OpResult)
            and isinstance(cnst := offset_op.offset.op, arith.ConstantOp)
            and isa(attr_val := cnst.value, IntegerAttr)
        ):
            tensor_access = AffineMap.from_callable(
                lambda x: (x + attr_val.value.data,)
            )
            if op.tensor_access:
                tensor_access = tensor_access.compose(op.tensor_access.data)
            rewriter.replace_op(
                op,
                new_op := csl.GetMemDsdOp.build(
                    operands=[op.base_addr, op.sizes],
                    result_types=op.result_types,
                    properties={
                        **op.properties,
                        "tensor_access": AffineMapAttr(tensor_access),
                    },
                ),
            )
            rewriter.replace_op(offset_op, [], new_results=[new_op.result])

match_and_rewrite(op: csl.GetMemDsdOp, rewriter: PatternRewriter) -> None

Source code in xdsl/transforms/canonicalization_patterns/csl.py 
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
@op_type_rewrite_pattern
def match_and_rewrite(self, op: csl.GetMemDsdOp, rewriter: PatternRewriter) -> None:
    # single use that is `@increment_dsd_offset`
    if not isinstance(
        offset_op := op.result.get_user_of_unique_use(), csl.IncrementDsdOffsetOp
    ):
        return
    # only works on 1d
    if len(op.sizes) > 1:
        return

    # check if we can promote arith.const to property
    if (
        isinstance(offset_op.offset, OpResult)
        and isinstance(cnst := offset_op.offset.op, arith.ConstantOp)
        and isa(attr_val := cnst.value, IntegerAttr)
    ):
        tensor_access = AffineMap.from_callable(
            lambda x: (x + attr_val.value.data,)
        )
        if op.tensor_access:
            tensor_access = tensor_access.compose(op.tensor_access.data)
        rewriter.replace_op(
            op,
            new_op := csl.GetMemDsdOp.build(
                operands=[op.base_addr, op.sizes],
                result_types=op.result_types,
                properties={
                    **op.properties,
                    "tensor_access": AffineMapAttr(tensor_access),
                },
            ),
        )
        rewriter.replace_op(offset_op, [], new_results=[new_op.result])

GetDsdAndLengthFolding

Bases: RewritePattern

Folds a csl.get_mem_dsd immediately followed by a csl.set_dsd_length

Source code in xdsl/transforms/canonicalization_patterns/csl.py 
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
class GetDsdAndLengthFolding(RewritePattern):
    """
    Folds a `csl.get_mem_dsd` immediately followed by a `csl.set_dsd_length`
    """

    @op_type_rewrite_pattern
    def match_and_rewrite(self, op: csl.GetMemDsdOp, rewriter: PatternRewriter) -> None:
        # single use that is `@set_dsd_length`
        if not isinstance(
            size_op := op.result.get_user_of_unique_use(), csl.SetDsdLengthOp
        ):
            return
        # only works on 1d
        if len(op.sizes) > 1:
            return

        rewriter.replace_op(
            size_op,
            csl.GetMemDsdOp.build(
                operands=[op.base_addr, [size_op.length]],
                result_types=op.result_types,
                properties=op.properties.copy(),
            ),
        )
        rewriter.erase_op(op)

match_and_rewrite(op: csl.GetMemDsdOp, rewriter: PatternRewriter) -> None

Source code in xdsl/transforms/canonicalization_patterns/csl.py 
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
@op_type_rewrite_pattern
def match_and_rewrite(self, op: csl.GetMemDsdOp, rewriter: PatternRewriter) -> None:
    # single use that is `@set_dsd_length`
    if not isinstance(
        size_op := op.result.get_user_of_unique_use(), csl.SetDsdLengthOp
    ):
        return
    # only works on 1d
    if len(op.sizes) > 1:
        return

    rewriter.replace_op(
        size_op,
        csl.GetMemDsdOp.build(
            operands=[op.base_addr, [size_op.length]],
            result_types=op.result_types,
            properties=op.properties.copy(),
        ),
    )
    rewriter.erase_op(op)

GetDsdAndStrideFolding

Bases: RewritePattern

Folds a csl.get_mem_dsd immediately followed by a csl.set_dsd_stride

Source code in xdsl/transforms/canonicalization_patterns/csl.py 
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
class GetDsdAndStrideFolding(RewritePattern):
    """
    Folds a `csl.get_mem_dsd` immediately followed by a `csl.set_dsd_stride`
    """

    @op_type_rewrite_pattern
    def match_and_rewrite(self, op: csl.GetMemDsdOp, rewriter: PatternRewriter) -> None:
        # single use that is `@set_dsd_stride`
        if not isinstance(
            stride_op := op.result.get_user_of_unique_use(), csl.SetDsdStrideOp
        ):
            return
        # only works on 1d and default (unspecified) tensor_access
        if len(op.sizes) > 1 or op.tensor_access:
            return

        # check if we can promote arith.const to property
        if (
            isinstance(stride_op.stride, OpResult)
            and isinstance(cnst := stride_op.stride.op, arith.ConstantOp)
            and isa(attr_val := cnst.value, IntegerAttr)
        ):
            tensor_access = AffineMap.from_callable(
                lambda x: (x * attr_val.value.data,)
            )
            rewriter.replace_op(
                op,
                new_op := csl.GetMemDsdOp.build(
                    operands=[op.base_addr, op.sizes],
                    result_types=op.result_types,
                    properties={
                        **op.properties,
                        "tensor_access": AffineMapAttr(tensor_access),
                    },
                ),
            )
            rewriter.replace_op(stride_op, [], new_results=[new_op.result])

match_and_rewrite(op: csl.GetMemDsdOp, rewriter: PatternRewriter) -> None

Source code in xdsl/transforms/canonicalization_patterns/csl.py 
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
@op_type_rewrite_pattern
def match_and_rewrite(self, op: csl.GetMemDsdOp, rewriter: PatternRewriter) -> None:
    # single use that is `@set_dsd_stride`
    if not isinstance(
        stride_op := op.result.get_user_of_unique_use(), csl.SetDsdStrideOp
    ):
        return
    # only works on 1d and default (unspecified) tensor_access
    if len(op.sizes) > 1 or op.tensor_access:
        return

    # check if we can promote arith.const to property
    if (
        isinstance(stride_op.stride, OpResult)
        and isinstance(cnst := stride_op.stride.op, arith.ConstantOp)
        and isa(attr_val := cnst.value, IntegerAttr)
    ):
        tensor_access = AffineMap.from_callable(
            lambda x: (x * attr_val.value.data,)
        )
        rewriter.replace_op(
            op,
            new_op := csl.GetMemDsdOp.build(
                operands=[op.base_addr, op.sizes],
                result_types=op.result_types,
                properties={
                    **op.properties,
                    "tensor_access": AffineMapAttr(tensor_access),
                },
            ),
        )
        rewriter.replace_op(stride_op, [], new_results=[new_op.result])

ChainedDsdOffsetFolding

Bases: RewritePattern

Folds a chain of csl.increment_dsd_offset

Source code in xdsl/transforms/canonicalization_patterns/csl.py 
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
class ChainedDsdOffsetFolding(RewritePattern):
    """
    Folds a chain of `csl.increment_dsd_offset`
    """

    @op_type_rewrite_pattern
    def match_and_rewrite(
        self, op: csl.IncrementDsdOffsetOp, rewriter: PatternRewriter
    ) -> None:
        # single use that is `@increment_dsd_offset`
        if not isinstance(
            next_op := op.result.get_user_of_unique_use(), csl.IncrementDsdOffsetOp
        ):
            return

        # check if we can promote arith.const to property
        if op.elem_type == next_op.elem_type:
            rewriter.replace_op(
                next_op,
                [
                    new_offset := arith.AddiOp(op.offset, next_op.offset),
                    csl.IncrementDsdOffsetOp(
                        operands=[op.op, new_offset.result],
                        properties=op.properties.copy(),
                        result_types=op.result_types,
                    ),
                ],
            )
            rewriter.erase_op(op)

match_and_rewrite(op: csl.IncrementDsdOffsetOp, rewriter: PatternRewriter) -> None

Source code in xdsl/transforms/canonicalization_patterns/csl.py 
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
@op_type_rewrite_pattern
def match_and_rewrite(
    self, op: csl.IncrementDsdOffsetOp, rewriter: PatternRewriter
) -> None:
    # single use that is `@increment_dsd_offset`
    if not isinstance(
        next_op := op.result.get_user_of_unique_use(), csl.IncrementDsdOffsetOp
    ):
        return

    # check if we can promote arith.const to property
    if op.elem_type == next_op.elem_type:
        rewriter.replace_op(
            next_op,
            [
                new_offset := arith.AddiOp(op.offset, next_op.offset),
                csl.IncrementDsdOffsetOp(
                    operands=[op.op, new_offset.result],
                    properties=op.properties.copy(),
                    result_types=op.result_types,
                ),
            ],
        )
        rewriter.erase_op(op)

ChainedDsdLengthFolding

Bases: RewritePattern

Folds a chain of csl.set_dsd_length

Source code in xdsl/transforms/canonicalization_patterns/csl.py 
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
class ChainedDsdLengthFolding(RewritePattern):
    """
    Folds a chain of `csl.set_dsd_length`
    """

    @op_type_rewrite_pattern
    def match_and_rewrite(
        self, op: csl.SetDsdLengthOp, rewriter: PatternRewriter
    ) -> None:
        # single use that is `@set_dsd_length`
        if not isinstance(
            next_op := op.result.get_user_of_unique_use(), csl.SetDsdLengthOp
        ):
            return

        # check if we can promote arith.const to property
        rewriter.replace_op(
            op,
            rebuilt := csl.SetDsdLengthOp(
                operands=[op.op, next_op.length],
                properties=op.properties.copy(),
                result_types=op.result_types,
            ),
        )
        rewriter.replace_op(next_op, [], new_results=[rebuilt.result])

match_and_rewrite(op: csl.SetDsdLengthOp, rewriter: PatternRewriter) -> None

Source code in xdsl/transforms/canonicalization_patterns/csl.py 
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
@op_type_rewrite_pattern
def match_and_rewrite(
    self, op: csl.SetDsdLengthOp, rewriter: PatternRewriter
) -> None:
    # single use that is `@set_dsd_length`
    if not isinstance(
        next_op := op.result.get_user_of_unique_use(), csl.SetDsdLengthOp
    ):
        return

    # check if we can promote arith.const to property
    rewriter.replace_op(
        op,
        rebuilt := csl.SetDsdLengthOp(
            operands=[op.op, next_op.length],
            properties=op.properties.copy(),
            result_types=op.result_types,
        ),
    )
    rewriter.replace_op(next_op, [], new_results=[rebuilt.result])

ChainedDsdStrideFolding

Bases: RewritePattern

Folds a chain of csl.set_dsd_stride

Source code in xdsl/transforms/canonicalization_patterns/csl.py 
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
class ChainedDsdStrideFolding(RewritePattern):
    """
    Folds a chain of `csl.set_dsd_stride`
    """

    @op_type_rewrite_pattern
    def match_and_rewrite(
        self, op: csl.SetDsdStrideOp, rewriter: PatternRewriter
    ) -> None:
        # single use that is `@set_dsd_stride`
        if not isinstance(
            next_op := op.result.get_user_of_unique_use(), csl.SetDsdStrideOp
        ):
            return

        # check if we can promote arith.const to property
        rewriter.replace_op(
            op,
            rebuilt := csl.SetDsdStrideOp(
                operands=[op.op, next_op.stride],
                properties=op.properties.copy(),
                result_types=op.result_types,
            ),
        )
        rewriter.replace_op(next_op, [], new_results=[rebuilt.result])

match_and_rewrite(op: csl.SetDsdStrideOp, rewriter: PatternRewriter) -> None

Source code in xdsl/transforms/canonicalization_patterns/csl.py 
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
@op_type_rewrite_pattern
def match_and_rewrite(
    self, op: csl.SetDsdStrideOp, rewriter: PatternRewriter
) -> None:
    # single use that is `@set_dsd_stride`
    if not isinstance(
        next_op := op.result.get_user_of_unique_use(), csl.SetDsdStrideOp
    ):
        return

    # check if we can promote arith.const to property
    rewriter.replace_op(
        op,
        rebuilt := csl.SetDsdStrideOp(
            operands=[op.op, next_op.stride],
            properties=op.properties.copy(),
            result_types=op.result_types,
        ),
    )
    rewriter.replace_op(next_op, [], new_results=[rebuilt.result])