File: dialect.py

package info (click to toggle)
swiftlang 6.0.3-2
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid, trixie
  • size: 2,519,992 kB
  • sloc: cpp: 9,107,863; ansic: 2,040,022; asm: 1,135,751; python: 296,500; objc: 82,456; f90: 60,502; lisp: 34,951; pascal: 19,946; sh: 18,133; perl: 7,482; ml: 4,937; javascript: 4,117; makefile: 3,840; awk: 3,535; xml: 914; fortran: 619; cs: 573; ruby: 573
file content (108 lines) | stat: -rw-r--r-- 3,849 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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
55
56
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
82
83
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
# RUN: %PYTHON %s | FileCheck %s

from mlir.ir import *
from mlir.dialects import sparse_tensor as st


def run(f):
    print("\nTEST:", f.__name__)
    f()
    return f


# CHECK-LABEL: TEST: testEncodingAttr1D
@run
def testEncodingAttr1D():
    with Context() as ctx:
        parsed = Attribute.parse(
            "#sparse_tensor.encoding<{"
            '  lvlTypes = [ "compressed" ],'
            "  posWidth = 16,"
            "  crdWidth = 32"
            "}>"
        )
        # CHECK: #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ], posWidth = 16, crdWidth = 32 }>
        print(parsed)

        casted = st.EncodingAttr(parsed)
        # CHECK: equal: True
        print(f"equal: {casted == parsed}")

        # CHECK: lvl_types: [<DimLevelType.compressed: 8>]
        print(f"lvl_types: {casted.lvl_types}")
        # CHECK: dim_to_lvl: None
        print(f"dim_to_lvl: {casted.dim_to_lvl}")
        # CHECK: pos_width: 16
        print(f"pos_width: {casted.pos_width}")
        # CHECK: crd_width: 32
        print(f"crd_width: {casted.crd_width}")

        created = st.EncodingAttr.get(casted.lvl_types, None, 0, 0)
        # CHECK: #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
        print(created)
        # CHECK: created_equal: False
        print(f"created_equal: {created == casted}")

        # Verify that the factory creates an instance of the proper type.
        # CHECK: is_proper_instance: True
        print(f"is_proper_instance: {isinstance(created, st.EncodingAttr)}")
        # CHECK: created_pos_width: 0
        print(f"created_pos_width: {created.pos_width}")


# CHECK-LABEL: TEST: testEncodingAttr2D
@run
def testEncodingAttr2D():
    with Context() as ctx:
        parsed = Attribute.parse(
            "#sparse_tensor.encoding<{"
            '  lvlTypes = [ "dense", "compressed" ],'
            "  dimToLvl = affine_map<(d0, d1) -> (d1, d0)>,"
            "  posWidth = 8,"
            "  crdWidth = 32"
            "}>"
        )
        # CHECK: #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimToLvl = affine_map<(d0, d1) -> (d1, d0)>, posWidth = 8, crdWidth = 32 }>
        print(parsed)

        casted = st.EncodingAttr(parsed)
        # CHECK: equal: True
        print(f"equal: {casted == parsed}")

        # CHECK: lvl_types: [<DimLevelType.dense: 4>, <DimLevelType.compressed: 8>]
        print(f"lvl_types: {casted.lvl_types}")
        # CHECK: dim_to_lvl: (d0, d1) -> (d1, d0)
        print(f"dim_to_lvl: {casted.dim_to_lvl}")
        # CHECK: pos_width: 8
        print(f"pos_width: {casted.pos_width}")
        # CHECK: crd_width: 32
        print(f"crd_width: {casted.crd_width}")

        created = st.EncodingAttr.get(
            casted.lvl_types, casted.dim_to_lvl, 8, 32
        )
        # CHECK: #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimToLvl = affine_map<(d0, d1) -> (d1, d0)>, posWidth = 8, crdWidth = 32 }>
        print(created)
        # CHECK: created_equal: True
        print(f"created_equal: {created == casted}")


# CHECK-LABEL: TEST: testEncodingAttrOnTensorType
@run
def testEncodingAttrOnTensorType():
    with Context() as ctx, Location.unknown():
        encoding = st.EncodingAttr(
            Attribute.parse(
                "#sparse_tensor.encoding<{"
                '  lvlTypes = [ "compressed" ], '
                "  posWidth = 64,"
                "  crdWidth = 32"
                "}>"
            )
        )
        tt = RankedTensorType.get((1024,), F32Type.get(), encoding=encoding)
        # CHECK: tensor<1024xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ], posWidth = 64, crdWidth = 32 }>>
        print(tt)
        # CHECK: #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ], posWidth = 64, crdWidth = 32 }>
        print(tt.encoding)
        assert tt.encoding == encoding