diff --git a/.basedpyright/baseline.json b/.basedpyright/baseline.json index fa11e913d..87b2aedc8 100644 --- a/.basedpyright/baseline.json +++ b/.basedpyright/baseline.json @@ -2424,8 +2424,8 @@ { "code": "reportUnknownMemberType", "range": { - "startColumn": 10, - "endColumn": 31, + "startColumn": 11, + "endColumn": 32, "lineCount": 1 } }, @@ -2552,8 +2552,8 @@ { "code": "reportUnknownArgumentType", "range": { - "startColumn": 29, - "endColumn": 33, + "startColumn": 30, + "endColumn": 34, "lineCount": 1 } }, @@ -22017,334 +22017,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownParameterType", - "range": { - "startColumn": 8, - "endColumn": 17, - "lineCount": 1 - } - }, - { - "code": "reportUnknownParameterType", - "range": { - "startColumn": 24, - "endColumn": 28, - "lineCount": 1 - } - }, - { - "code": "reportMissingParameterType", - "range": { - "startColumn": 24, - "endColumn": 28, - "lineCount": 1 - } - }, - { - "code": "reportMissingParameterType", - "range": { - "startColumn": 35, - "endColumn": 52, - "lineCount": 1 - } - }, - { - "code": "reportMissingParameterType", - "range": { - "startColumn": 60, - "endColumn": 74, - "lineCount": 1 - } - }, - { - "code": "reportMissingParameterType", - "range": { - "startColumn": 12, - "endColumn": 23, - "lineCount": 1 - } - }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 32, - "endColumn": 45, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 12, - "endColumn": 24, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 12, - "endColumn": 24, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 12, - "endColumn": 24, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 16, - "endColumn": 28, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 16, - "endColumn": 28, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 12, - "endColumn": 24, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 16, - "endColumn": 28, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 16, - "endColumn": 28, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 12, - "endColumn": 24, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 16, - "endColumn": 28, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 16, - "endColumn": 28, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 12, - "endColumn": 24, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 16, - "endColumn": 28, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 16, - "endColumn": 28, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 12, - "endColumn": 24, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 16, - "endColumn": 28, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 16, - "endColumn": 28, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 12, - "endColumn": 24, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 16, - "endColumn": 28, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 12, - "endColumn": 24, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 16, - "endColumn": 32, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 12, - "endColumn": 24, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 16, - "endColumn": 28, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 12, - "endColumn": 24, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 12, - "endColumn": 24, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 16, - "endColumn": 28, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 12, - "endColumn": 24, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 8, - "endColumn": 20, - "lineCount": 1 - } - }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 25, - "endColumn": 30, - "lineCount": 1 - } - }, - { - "code": "reportUnknownParameterType", - "range": { - "startColumn": 8, - "endColumn": 15, - "lineCount": 1 - } - }, - { - "code": "reportImplicitOverride", - "range": { - "startColumn": 8, - "endColumn": 15, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 15, - "endColumn": 29, - "lineCount": 1 - } - }, - { - "code": "reportUnknownParameterType", - "range": { - "startColumn": 8, - "endColumn": 19, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 15, - "endColumn": 29, - "lineCount": 1 - } - }, { "code": "reportUnknownParameterType", "range": { @@ -28536,16 +28208,8 @@ { "code": "reportUnknownMemberType", "range": { - "startColumn": 15, - "endColumn": 26, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 12, - "endColumn": 28, + "startColumn": 28, + "endColumn": 39, "lineCount": 1 } }, @@ -28557,14 +28221,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 37, - "endColumn": 46, - "lineCount": 1 - } - }, { "code": "reportUnknownMemberType", "range": { @@ -34827,14 +34483,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 8, - "endColumn": 17, - "lineCount": 1 - } - }, { "code": "reportUnannotatedClassAttribute", "range": { @@ -35123,30 +34771,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 16, - "endColumn": 25, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 16, - "endColumn": 31, - "lineCount": 1 - } - }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 16, - "endColumn": 37, - "lineCount": 1 - } - }, { "code": "reportUnknownParameterType", "range": { @@ -37393,7 +37017,7 @@ "code": "reportUnknownMemberType", "range": { "startColumn": 24, - "endColumn": 45, + "endColumn": 32, "lineCount": 1 } }, @@ -37465,31 +37089,31 @@ "code": "reportUnknownMemberType", "range": { "startColumn": 20, - "endColumn": 44, + "endColumn": 31, "lineCount": 1 } }, { "code": "reportUnknownMemberType", "range": { - "startColumn": 22, - "endColumn": 35, + "startColumn": 8, + "endColumn": 20, "lineCount": 1 } }, { - "code": "reportUnknownArgumentType", + "code": "reportUnknownMemberType", "range": { - "startColumn": 36, - "endColumn": 42, + "startColumn": 59, + "endColumn": 72, "lineCount": 1 } }, { - "code": "reportUnknownMemberType", + "code": "reportUnknownArgumentType", "range": { - "startColumn": 12, - "endColumn": 24, + "startColumn": 73, + "endColumn": 79, "lineCount": 1 } }, @@ -37640,48 +37264,16 @@ { "code": "reportUnknownParameterType", "range": { - "startColumn": 4, - "endColumn": 41, - "lineCount": 1 - } - }, - { - "code": "reportUnknownParameterType", - "range": { - "startColumn": 42, - "endColumn": 48, - "lineCount": 1 - } - }, - { - "code": "reportMissingParameterType", - "range": { - "startColumn": 42, - "endColumn": 48, - "lineCount": 1 - } - }, - { - "code": "reportUnknownParameterType", - "range": { - "startColumn": 50, - "endColumn": 54, + "startColumn": 12, + "endColumn": 16, "lineCount": 1 } }, { "code": "reportMissingParameterType", "range": { - "startColumn": 50, - "endColumn": 54, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 15, - "endColumn": 26, + "startColumn": 12, + "endColumn": 16, "lineCount": 1 } }, @@ -37704,8 +37296,8 @@ { "code": "reportUnknownMemberType", "range": { - "startColumn": 20, - "endColumn": 34, + "startColumn": 33, + "endColumn": 47, "lineCount": 1 } }, @@ -37790,18 +37382,10 @@ } }, { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 14, - "endColumn": 29, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", + "code": "reportUnknownArgumentType", "range": { - "startColumn": 14, - "endColumn": 33, + "startColumn": 34, + "endColumn": 42, "lineCount": 1 } }, @@ -37822,10 +37406,10 @@ } }, { - "code": "reportUnknownMemberType", + "code": "reportUnknownArgumentType", "range": { - "startColumn": 11, - "endColumn": 36, + "startColumn": 37, + "endColumn": 42, "lineCount": 1 } }, @@ -37853,46 +37437,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 14, - "endColumn": 29, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 14, - "endColumn": 33, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 11, - "endColumn": 23, - "lineCount": 1 - } - }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 17, - "endColumn": 54, - "lineCount": 2 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 46, - "endColumn": 54, - "lineCount": 1 - } - }, { "code": "reportUnknownArgumentType", "range": { @@ -37901,14 +37445,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 27, - "endColumn": 39, - "lineCount": 1 - } - }, { "code": "reportUnknownMemberType", "range": { @@ -37997,22 +37533,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 20, - "endColumn": 26, - "lineCount": 3 - } - }, - { - "code": "reportUnknownLambdaType", - "range": { - "startColumn": 27, - "endColumn": 32, - "lineCount": 1 - } - }, { "code": "reportUnknownLambdaType", "range": { @@ -38029,14 +37549,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 42, - "endColumn": 47, - "lineCount": 1 - } - }, { "code": "reportUnknownParameterType", "range": { @@ -38221,22 +37733,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 54, - "endColumn": 59, - "lineCount": 1 - } - }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 53, - "endColumn": 58, - "lineCount": 1 - } - }, { "code": "reportUnknownParameterType", "range": { @@ -39861,22 +39357,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 23, - "endColumn": 32, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 23, - "endColumn": 38, - "lineCount": 1 - } - }, { "code": "reportUnknownArgumentType", "range": { @@ -39885,14 +39365,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 26, - "endColumn": 27, - "lineCount": 1 - } - }, { "code": "reportUnknownParameterType", "range": { @@ -39989,62 +39461,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownParameterType", - "range": { - "startColumn": 4, - "endColumn": 28, - "lineCount": 1 - } - }, - { - "code": "reportUnknownParameterType", - "range": { - "startColumn": 29, - "endColumn": 35, - "lineCount": 1 - } - }, - { - "code": "reportMissingParameterType", - "range": { - "startColumn": 29, - "endColumn": 35, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 17, - "endColumn": 24, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 44, - "endColumn": 63, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 16, - "endColumn": 35, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 19, - "endColumn": 34, - "lineCount": 1 - } - }, { "code": "reportUnknownMemberType", "range": { @@ -40053,22 +39469,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 31, - "endColumn": 38, - "lineCount": 1 - } - }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 31, - "endColumn": 38, - "lineCount": 1 - } - }, { "code": "reportUnknownArgumentType", "range": { @@ -40077,30 +39477,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 42, - "endColumn": 49, - "lineCount": 1 - } - }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 51, - "endColumn": 57, - "lineCount": 1 - } - }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 52, - "endColumn": 60, - "lineCount": 1 - } - }, { "code": "reportUnknownMemberType", "range": { @@ -40109,27 +39485,11 @@ "lineCount": 1 } }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 24, - "endColumn": 36, - "lineCount": 1 - } - }, { "code": "reportUnknownMemberType", "range": { - "startColumn": 16, - "endColumn": 31, - "lineCount": 1 - } - }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 32, - "endColumn": 35, + "startColumn": 12, + "endColumn": 28, "lineCount": 1 } }, @@ -40141,14 +39501,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 24, - "endColumn": 27, - "lineCount": 1 - } - }, { "code": "reportUnknownMemberType", "range": { @@ -40157,54 +39509,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 25, - "endColumn": 28, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 25, - "endColumn": 42, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 25, - "endColumn": 58, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 16, - "endColumn": 28, - "lineCount": 1 - } - }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 29, - "endColumn": 34, - "lineCount": 1 - } - }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 17, - "endColumn": 25, - "lineCount": 1 - } - }, { "code": "reportUnknownParameterType", "range": { @@ -40285,22 +39589,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 11, - "endColumn": 31, - "lineCount": 1 - } - }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 39, - "endColumn": 59, - "lineCount": 1 - } - }, { "code": "reportUnknownParameterType", "range": { @@ -45408,8 +44696,8 @@ { "code": "reportAny", "range": { - "startColumn": 38, - "endColumn": 44, + "startColumn": 21, + "endColumn": 27, "lineCount": 1 } }, @@ -45733,22 +45021,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 14, - "endColumn": 30, - "lineCount": 1 - } - }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 14, - "endColumn": 54, - "lineCount": 1 - } - }, { "code": "reportUnknownMemberType", "range": { @@ -48642,8 +47914,8 @@ { "code": "reportUnknownMemberType", "range": { - "startColumn": 17, - "endColumn": 28, + "startColumn": 11, + "endColumn": 22, "lineCount": 1 } } @@ -49600,16 +48872,16 @@ { "code": "reportUnknownMemberType", "range": { - "startColumn": 24, - "endColumn": 38, + "startColumn": 28, + "endColumn": 42, "lineCount": 1 } }, { "code": "reportUnknownMemberType", "range": { - "startColumn": 24, - "endColumn": 44, + "startColumn": 28, + "endColumn": 48, "lineCount": 1 } }, @@ -49656,16 +48928,16 @@ { "code": "reportUnknownMemberType", "range": { - "startColumn": 34, - "endColumn": 48, + "startColumn": 38, + "endColumn": 52, "lineCount": 1 } }, { "code": "reportUnknownMemberType", "range": { - "startColumn": 34, - "endColumn": 54, + "startColumn": 38, + "endColumn": 58, "lineCount": 1 } }, @@ -55901,38 +55173,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownParameterType", - "range": { - "startColumn": 32, - "endColumn": 35, - "lineCount": 1 - } - }, - { - "code": "reportMissingParameterType", - "range": { - "startColumn": 32, - "endColumn": 35, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 18, - "endColumn": 28, - "lineCount": 1 - } - }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 25, - "endColumn": 28, - "lineCount": 1 - } - }, { "code": "reportUnknownParameterType", "range": { @@ -55949,46 +55189,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownParameterType", - "range": { - "startColumn": 32, - "endColumn": 55, - "lineCount": 1 - } - }, - { - "code": "reportMissingParameterType", - "range": { - "startColumn": 32, - "endColumn": 55, - "lineCount": 1 - } - }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 58, - "endColumn": 61, - "lineCount": 1 - } - }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 33, - "endColumn": 36, - "lineCount": 1 - } - }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 29, - "endColumn": 71, - "lineCount": 3 - } - }, { "code": "reportUnknownParameterType", "range": { @@ -57087,14 +56287,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownParameterType", - "range": { - "startColumn": 31, - "endColumn": 54, - "lineCount": 1 - } - }, { "code": "reportMissingParameterType", "range": { @@ -58595,14 +57787,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 36, - "endColumn": 60, - "lineCount": 1 - } - }, { "code": "reportUnknownParameterType", "range": { @@ -62157,22 +61341,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 12, - "endColumn": 28, - "lineCount": 1 - } - }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 26, - "endColumn": 35, - "lineCount": 1 - } - }, { "code": "reportUnknownMemberType", "range": { @@ -62490,8 +61658,8 @@ { "code": "reportUnknownMemberType", "range": { - "startColumn": 33, - "endColumn": 52, + "startColumn": 31, + "endColumn": 50, "lineCount": 1 } }, @@ -65803,6 +64971,14 @@ } ], "./loopy/target/c/compyte/dtypes.py": [ + { + "code": "reportUnnecessaryTypeIgnoreComment", + "range": { + "startColumn": 45, + "endColumn": 72, + "lineCount": 1 + } + }, { "code": "reportUnusedFunction", "range": { @@ -66261,14 +65437,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownParameterType", - "range": { - "startColumn": 4, - "endColumn": 27, - "lineCount": 1 - } - }, { "code": "reportUnknownParameterType", "range": { @@ -66743,22 +65911,6 @@ } ], "./loopy/target/execution.py": [ - { - "code": "reportPrivateLocalImportUsage", - "range": { - "startColumn": 62, - "endColumn": 66, - "lineCount": 1 - } - }, - { - "code": "reportPrivateLocalImportUsage", - "range": { - "startColumn": 25, - "endColumn": 35, - "lineCount": 1 - } - }, { "code": "reportUnannotatedClassAttribute", "range": { @@ -67695,22 +66847,6 @@ "lineCount": 1 } }, - { - "code": "reportUnannotatedClassAttribute", - "range": { - "startColumn": 13, - "endColumn": 19, - "lineCount": 1 - } - }, - { - "code": "reportUnannotatedClassAttribute", - "range": { - "startColumn": 13, - "endColumn": 23, - "lineCount": 1 - } - }, { "code": "reportUnannotatedClassAttribute", "range": { @@ -67719,38 +66855,6 @@ "lineCount": 1 } }, - { - "code": "reportUnannotatedClassAttribute", - "range": { - "startColumn": 13, - "endColumn": 30, - "lineCount": 1 - } - }, - { - "code": "reportUnannotatedClassAttribute", - "range": { - "startColumn": 13, - "endColumn": 35, - "lineCount": 1 - } - }, - { - "code": "reportUnannotatedClassAttribute", - "range": { - "startColumn": 13, - "endColumn": 32, - "lineCount": 1 - } - }, - { - "code": "reportUnannotatedClassAttribute", - "range": { - "startColumn": 13, - "endColumn": 21, - "lineCount": 1 - } - }, { "code": "reportUnknownParameterType", "range": { @@ -69379,14 +68483,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownParameterType", - "range": { - "startColumn": 4, - "endColumn": 29, - "lineCount": 1 - } - }, { "code": "reportUnknownParameterType", "range": { @@ -70309,46 +69405,6 @@ "lineCount": 1 } }, - { - "code": "reportOptionalMemberAccess", - "range": { - "startColumn": 17, - "endColumn": 27, - "lineCount": 1 - } - }, - { - "code": "reportOptionalMemberAccess", - "range": { - "startColumn": 24, - "endColumn": 34, - "lineCount": 1 - } - }, - { - "code": "reportOptionalMemberAccess", - "range": { - "startColumn": 24, - "endColumn": 34, - "lineCount": 1 - } - }, - { - "code": "reportOptionalMemberAccess", - "range": { - "startColumn": 20, - "endColumn": 30, - "lineCount": 1 - } - }, - { - "code": "reportOptionalMemberAccess", - "range": { - "startColumn": 52, - "endColumn": 62, - "lineCount": 1 - } - }, { "code": "reportOptionalSubscript", "range": { @@ -71509,14 +70565,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownParameterType", - "range": { - "startColumn": 8, - "endColumn": 27, - "lineCount": 1 - } - }, { "code": "reportImplicitOverride", "range": { @@ -72297,14 +71345,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownParameterType", - "range": { - "startColumn": 8, - "endColumn": 27, - "lineCount": 1 - } - }, { "code": "reportIncompatibleMethodOverride", "range": { @@ -72321,14 +71361,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 16, - "endColumn": 29, - "lineCount": 1 - } - }, { "code": "reportUnknownMemberType", "range": { @@ -72811,246 +71843,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownParameterType", - "range": { - "startColumn": 4, - "endColumn": 29, - "lineCount": 1 - } - }, - { - "code": "reportUnknownParameterType", - "range": { - "startColumn": 30, - "endColumn": 34, - "lineCount": 1 - } - }, - { - "code": "reportMissingParameterType", - "range": { - "startColumn": 30, - "endColumn": 34, - "lineCount": 1 - } - }, - { - "code": "reportMissingParameterType", - "range": { - "startColumn": 36, - "endColumn": 59, - "lineCount": 1 - } - }, - { - "code": "reportUnknownParameterType", - "range": { - "startColumn": 8, - "endColumn": 34, - "lineCount": 1 - } - }, - { - "code": "reportMissingParameterType", - "range": { - "startColumn": 8, - "endColumn": 34, - "lineCount": 1 - } - }, - { - "code": "reportMissingParameterType", - "range": { - "startColumn": 41, - "endColumn": 58, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 7, - "endColumn": 22, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 39, - "endColumn": 54, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 12, - "endColumn": 22, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 14, - "endColumn": 28, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 12, - "endColumn": 21, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 14, - "endColumn": 29, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 12, - "endColumn": 21, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 22, - "endColumn": 33, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 28, - "endColumn": 46, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 20, - "endColumn": 31, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 20, - "endColumn": 44, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 12, - "endColumn": 28, - "lineCount": 1 - } - }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 29, - "endColumn": 33, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 11, - "endColumn": 35, - "lineCount": 1 - } - }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 29, - "endColumn": 68, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 8, - "endColumn": 24, - "lineCount": 1 - } - }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 25, - "endColumn": 43, - "lineCount": 1 - } - }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 21, - "endColumn": 30, - "lineCount": 1 - } - }, - { - "code": "reportUnknownParameterType", - "range": { - "startColumn": 34, - "endColumn": 38, - "lineCount": 1 - } - }, - { - "code": "reportMissingParameterType", - "range": { - "startColumn": 34, - "endColumn": 38, - "lineCount": 1 - } - }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 21, - "endColumn": 76, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 38, - "endColumn": 48, - "lineCount": 1 - } - }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 62, - "endColumn": 66, - "lineCount": 1 - } - }, { "code": "reportUnknownParameterType", "range": { @@ -73406,7 +72198,7 @@ { "code": "reportUnknownMemberType", "range": { - "startColumn": 12, + "startColumn": 11, "endColumn": 32, "lineCount": 3 } @@ -74163,62 +72955,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownParameterType", - "range": { - "startColumn": 34, - "endColumn": 45, - "lineCount": 1 - } - }, - { - "code": "reportMissingParameterType", - "range": { - "startColumn": 34, - "endColumn": 45, - "lineCount": 1 - } - }, - { - "code": "reportUnknownParameterType", - "range": { - "startColumn": 47, - "endColumn": 55, - "lineCount": 1 - } - }, - { - "code": "reportMissingParameterType", - "range": { - "startColumn": 47, - "endColumn": 55, - "lineCount": 1 - } - }, - { - "code": "reportUnknownParameterType", - "range": { - "startColumn": 57, - "endColumn": 67, - "lineCount": 1 - } - }, - { - "code": "reportMissingParameterType", - "range": { - "startColumn": 57, - "endColumn": 67, - "lineCount": 1 - } - }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 9, - "endColumn": 20, - "lineCount": 1 - } - }, { "code": "reportUnknownArgumentType", "range": { @@ -75649,14 +74385,6 @@ "lineCount": 1 } }, - { - "code": "reportOptionalMemberAccess", - "range": { - "startColumn": 42, - "endColumn": 57, - "lineCount": 1 - } - }, { "code": "reportUnknownParameterType", "range": { @@ -78664,8 +77392,8 @@ { "code": "reportUnknownArgumentType", "range": { - "startColumn": 43, - "endColumn": 58, + "startColumn": 41, + "endColumn": 56, "lineCount": 1 } }, @@ -82158,32 +80886,16 @@ { "code": "reportUnknownMemberType", "range": { - "startColumn": 15, - "endColumn": 26, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 11, - "endColumn": 19, + "startColumn": 31, + "endColumn": 42, "lineCount": 1 } }, { "code": "reportUnknownMemberType", "range": { - "startColumn": 12, - "endColumn": 27, - "lineCount": 1 - } - }, - { - "code": "reportUnknownArgumentType", - "range": { - "startColumn": 28, - "endColumn": 31, + "startColumn": 46, + "endColumn": 54, "lineCount": 1 } }, @@ -84264,8 +82976,8 @@ { "code": "reportUnknownArgumentType", "range": { - "startColumn": 54, - "endColumn": 57, + "startColumn": 55, + "endColumn": 58, "lineCount": 1 } }, @@ -86550,87 +85262,47 @@ { "code": "reportUnknownParameterType", "range": { - "startColumn": 15, - "endColumn": 21, - "lineCount": 1 - } - }, - { - "code": "reportMissingParameterType", - "range": { - "startColumn": 15, - "endColumn": 21, - "lineCount": 1 - } - }, - { - "code": "reportUnknownParameterType", - "range": { - "startColumn": 23, - "endColumn": 28, + "startColumn": 12, + "endColumn": 17, "lineCount": 1 } }, { "code": "reportMissingParameterType", "range": { - "startColumn": 23, - "endColumn": 28, + "startColumn": 12, + "endColumn": 17, "lineCount": 1 } }, { "code": "reportUnknownParameterType", "range": { - "startColumn": 30, - "endColumn": 36, + "startColumn": 12, + "endColumn": 18, "lineCount": 1 } }, { "code": "reportMissingParameterType", "range": { - "startColumn": 30, - "endColumn": 36, + "startColumn": 12, + "endColumn": 18, "lineCount": 1 } }, { "code": "reportUnknownParameterType", "range": { - "startColumn": 38, - "endColumn": 42, - "lineCount": 1 - } - }, - { - "code": "reportMissingParameterType", - "range": { - "startColumn": 38, - "endColumn": 42, - "lineCount": 1 - } - }, - { - "code": "reportMissingParameterType", - "range": { - "startColumn": 44, - "endColumn": 57, - "lineCount": 1 - } - }, - { - "code": "reportMissingParameterType", - "range": { - "startColumn": 65, - "endColumn": 70, + "startColumn": 12, + "endColumn": 16, "lineCount": 1 } }, { "code": "reportMissingParameterType", "range": { - "startColumn": 8, + "startColumn": 12, "endColumn": 16, "lineCount": 1 } @@ -86667,38 +85339,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownParameterType", - "range": { - "startColumn": 36, - "endColumn": 44, - "lineCount": 1 - } - }, - { - "code": "reportMissingParameterType", - "range": { - "startColumn": 36, - "endColumn": 44, - "lineCount": 1 - } - }, - { - "code": "reportUnknownParameterType", - "range": { - "startColumn": 46, - "endColumn": 54, - "lineCount": 1 - } - }, - { - "code": "reportMissingParameterType", - "range": { - "startColumn": 46, - "endColumn": 54, - "lineCount": 1 - } - }, { "code": "reportUnknownMemberType", "range": { @@ -102389,14 +101029,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 14, - "endColumn": 29, - "lineCount": 1 - } - }, { "code": "reportUnknownMemberType", "range": { @@ -104003,22 +102635,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 14, - "endColumn": 36, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 14, - "endColumn": 29, - "lineCount": 1 - } - }, { "code": "reportUnknownMemberType", "range": { @@ -105923,22 +104539,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 14, - "endColumn": 29, - "lineCount": 1 - } - }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 14, - "endColumn": 29, - "lineCount": 1 - } - }, { "code": "reportUnknownMemberType", "range": { @@ -106813,14 +105413,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 10, - "endColumn": 40, - "lineCount": 1 - } - }, { "code": "reportUnknownMemberType", "range": { @@ -107149,14 +105741,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 10, - "endColumn": 40, - "lineCount": 1 - } - }, { "code": "reportUnknownMemberType", "range": { @@ -107589,14 +106173,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 12, - "endColumn": 39, - "lineCount": 1 - } - }, { "code": "reportUnknownMemberType", "range": { @@ -107605,14 +106181,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 8, - "endColumn": 35, - "lineCount": 1 - } - }, { "code": "reportUnknownMemberType", "range": { @@ -108585,14 +107153,6 @@ "lineCount": 1 } }, - { - "code": "reportUnknownMemberType", - "range": { - "startColumn": 14, - "endColumn": 29, - "lineCount": 1 - } - }, { "code": "reportUnknownMemberType", "range": { diff --git a/contrib/c-integer-semantics.py b/contrib/c-integer-semantics.py index 8b30415c2..1c676f747 100644 --- a/contrib/c-integer-semantics.py +++ b/contrib/c-integer-semantics.py @@ -1,5 +1,3 @@ -#!/usr/bin/env python - import ctypes from os import system diff --git a/contrib/mem-pattern-explorer/pattern_vis.py b/contrib/mem-pattern-explorer/pattern_vis.py index fdd9493e9..ee32ca899 100644 --- a/contrib/mem-pattern-explorer/pattern_vis.py +++ b/contrib/mem-pattern-explorer/pattern_vis.py @@ -43,8 +43,8 @@ def nsubgroups(self): return div_ceil(product(self.lsize), self.subgroup_size) def animate(self, f, interval=200): - import matplotlib.animation as animation import matplotlib.pyplot as plt + from matplotlib import animation fig = plt.figure() diff --git a/examples/fortran/matmul-driver.py b/examples/fortran/matmul-driver.py index 646629854..15e49800b 100644 --- a/examples/fortran/matmul-driver.py +++ b/examples/fortran/matmul-driver.py @@ -3,7 +3,7 @@ import pyopencl as cl import pyopencl.array as cla -import pyopencl.clrandom as clrandom +from pyopencl import clrandom import loopy as lp diff --git a/examples/python/call-external.py b/examples/python/call-external.py index a2c19b855..78258f237 100644 --- a/examples/python/call-external.py +++ b/examples/python/call-external.py @@ -81,7 +81,6 @@ def emit_call_insn(self, insn, target, expression_to_code_mapper): def generate_preambles(self, target): assert isinstance(target, CTarget) yield ("99_cblas", "#include ") - return # }}} diff --git a/examples/python/ispc-stream-harness.py b/examples/python/ispc-stream-harness.py index ad9a38483..88a0511ae 100644 --- a/examples/python/ispc-stream-harness.py +++ b/examples/python/ispc-stream-harness.py @@ -25,9 +25,7 @@ def transform(knl, vars, stream_dtype): knl = lp.add_and_infer_dtypes(knl, dict.fromkeys(vars, stream_dtype)) - knl = lp.set_argument_order(knl, [*vars, "n"]) - - return knl + return lp.set_argument_order(knl, [*vars, "n"]) def gen_code(knl): @@ -67,8 +65,7 @@ def make_knl(name, insn, vars): target=lp.ISPCTarget(), index_dtype=INDEX_DTYPE, name="stream_"+name+"_tasks") - knl = transform(knl, vars, STREAM_DTYPE) - return knl + return transform(knl, vars, STREAM_DTYPE) init_knl = make_knl("init", """ a[i] = 1 diff --git a/loopy/cli.py b/loopy/cli.py index 04cfd2eed..7ab76c6bb 100644 --- a/loopy/cli.py +++ b/loopy/cli.py @@ -142,14 +142,14 @@ def main(): if args.occa_defines: with open(args.occa_defines) as defines_fd: occa_define_code = defines_to_python_code(defines_fd.read()) - exec(compile(occa_define_code, args.occa_defines, "exec"), data_dic) + exec(compile(occa_define_code, args.occa_defines, "exec"), data_dic) # noqa: S102 with open(args.infile) as infile_fd: - exec(compile(infile_content, args.infile, "exec"), data_dic) + exec(compile(infile_content, args.infile, "exec"), data_dic) # noqa: S102 if args.transform: with open(args.transform) as xform_fd: - exec(compile(xform_fd.read(), + exec(compile(xform_fd.read(), # noqa: S102 args.transform, "exec"), data_dic) try: diff --git a/loopy/codegen/control.py b/loopy/codegen/control.py index 0dda9ba0a..17611f318 100644 --- a/loopy/codegen/control.py +++ b/loopy/codegen/control.py @@ -44,7 +44,13 @@ if TYPE_CHECKING: - from collections.abc import Callable, Collection, Hashable, Sequence, Set + from collections.abc import ( + Callable, + Collection, + Hashable, + Sequence, + Set as AbstractSet, + ) from pymbolic import Expression @@ -288,9 +294,9 @@ def build_loop_nest( @dataclass(frozen=True) class ScheduleIndexInfo: schedule_indices: Sequence[int] - admissible_cond_inames: Set[InameStr] + admissible_cond_inames: AbstractSet[InameStr] required_predicates: frozenset[Expression] - used_inames_within: Set[InameStr] + used_inames_within: AbstractSet[InameStr] from loopy.codegen.bounds import get_usable_inames_for_conditional from loopy.schedule import find_used_inames_within @@ -388,7 +394,9 @@ def build_insn_group( bounds_check_cache = BoundsCheckCache( kernel, codegen_state.implemented_domain) - found_hoists: list[tuple[int, Sequence[isl.Constraint], Set[Expression]]] = [] + found_hoists: list[ + tuple[int, Sequence[isl.Constraint], AbstractSet[Expression]] + ] = [] candidate_group_length = 1 while candidate_group_length <= len(sched_index_info_entries): diff --git a/loopy/codegen/instruction.py b/loopy/codegen/instruction.py index f88a9a959..2bd22b378 100644 --- a/loopy/codegen/instruction.py +++ b/loopy/codegen/instruction.py @@ -36,7 +36,7 @@ if TYPE_CHECKING: - from collections.abc import Collection, Set + from collections.abc import Collection, Set as AbstractSet from pymbolic import Expression @@ -75,7 +75,7 @@ def to_codegen_result( insn_id: InsnId, domain: isl.BasicSet, check_inames: Collection[str], - required_preds: Set[Expression], + required_preds: AbstractSet[Expression], ast: ASTType ) -> CodeGenerationResult[ASTType] | None: chk_domain = isl.Set.from_basic_set(domain) diff --git a/loopy/diagnostic.py b/loopy/diagnostic.py index 840f5fb3d..831e50df8 100644 --- a/loopy/diagnostic.py +++ b/loopy/diagnostic.py @@ -140,7 +140,6 @@ class ExpressionNotAffineError(LoopyError): `ISL manual `_ for then definition of a quasi-affine expression. """ - pass class ExpressionToAffineConversionError(LoopyError): diff --git a/loopy/frontend/fortran/__init__.py b/loopy/frontend/fortran/__init__.py index 1e6c3455a..d08a6f893 100644 --- a/loopy/frontend/fortran/__init__.py +++ b/loopy/frontend/fortran/__init__.py @@ -41,8 +41,7 @@ def c_preprocess(source, defines=None, filename=None, include_paths=None): :return: a string """ try: - import ply.cpp as cpp - import ply.lex as lex + from ply import cpp, lex except ImportError as err: raise LoopyError( "Using the C preprocessor requires PLY to be installed") from err @@ -226,11 +225,11 @@ def parse_transformed_fortran(source, free_form=True, strict=True, if pre_transform_code is not None: proc_dict["_MODULE_SOURCE_CODE"] = pre_transform_code - exec(compile(pre_transform_code, + exec(compile(pre_transform_code, # noqa: S102 "", "exec"), proc_dict) proc_dict["_MODULE_SOURCE_CODE"] = transform_code - exec(compile(transform_code, filename, "exec"), proc_dict) + exec(compile(transform_code, filename, "exec"), proc_dict) # noqa: S102 finally: sys.path = prev_sys_path @@ -291,7 +290,6 @@ def _add_assignees_to_calls(knl, all_kernels): insn.expression.function.name)(*new_params))) else: new_insns.append(insn) - pass elif isinstance(insn, (Assignment, CInstruction, _DataObliviousInstruction)): new_insns.append(insn) diff --git a/loopy/frontend/fortran/expression.py b/loopy/frontend/fortran/expression.py index 59091517a..bf0a52554 100644 --- a/loopy/frontend/fortran/expression.py +++ b/loopy/frontend/fortran/expression.py @@ -73,16 +73,16 @@ def tuple_to_complex_literal(expr): class FortranExpressionParser(ExpressionParserBase): lex_table: ClassVar[LexTable] = [ - (_less_than, pytools.lex.RE(r"\.lt\.", re.I)), - (_greater_than, pytools.lex.RE(r"\.gt\.", re.I)), - (_less_equal, pytools.lex.RE(r"\.le\.", re.I)), - (_greater_equal, pytools.lex.RE(r"\.ge\.", re.I)), - (_equal, pytools.lex.RE(r"\.eq\.", re.I)), - (_not_equal, pytools.lex.RE(r"\.ne\.", re.I)), - - (_not, pytools.lex.RE(r"\.not\.", re.I)), - (_and, pytools.lex.RE(r"\.and\.", re.I)), - (_or, pytools.lex.RE(r"\.or\.", re.I)), + (_less_than, pytools.lex.RE(r"\.lt\.", re.IGNORECASE)), + (_greater_than, pytools.lex.RE(r"\.gt\.", re.IGNORECASE)), + (_less_equal, pytools.lex.RE(r"\.le\.", re.IGNORECASE)), + (_greater_equal, pytools.lex.RE(r"\.ge\.", re.IGNORECASE)), + (_equal, pytools.lex.RE(r"\.eq\.", re.IGNORECASE)), + (_not_equal, pytools.lex.RE(r"\.ne\.", re.IGNORECASE)), + + (_not, pytools.lex.RE(r"\.not\.", re.IGNORECASE)), + (_and, pytools.lex.RE(r"\.and\.", re.IGNORECASE)), + (_or, pytools.lex.RE(r"\.or\.", re.IGNORECASE)), *ExpressionParserBase.lex_table, ] @@ -153,7 +153,7 @@ def parse_terminal(self, pstate): } def parse_prefix(self, pstate, min_precedence=0): - import pymbolic.primitives as primitives + from pymbolic import primitives from pymbolic.parser import _PREC_UNARY pstate.expect_not_end() diff --git a/loopy/frontend/fortran/translator.py b/loopy/frontend/fortran/translator.py index 54574d87d..d6111cfbb 100644 --- a/loopy/frontend/fortran/translator.py +++ b/loopy/frontend/fortran/translator.py @@ -243,9 +243,7 @@ def process_expression_for_loopy(self, expr): expr = submap(expr) subshift = SubscriptIndexAdjuster(self) - expr = subshift(expr) - - return expr + return subshift(expr) def written_vars(self): return frozenset().union(*(insn.write_dependency_names() diff --git a/loopy/kernel/__init__.py b/loopy/kernel/__init__.py index fa92560ed..554d17b1e 100644 --- a/loopy/kernel/__init__.py +++ b/loopy/kernel/__init__.py @@ -46,7 +46,7 @@ import numpy as np from constantdict import constantdict -from typing_extensions import overload +from typing_extensions import overload, override import islpy as isl from islpy import dim_type @@ -83,7 +83,7 @@ Hashable, Mapping, Sequence, - Set, + Set as AbstractSet, ) from pymbolic import ArithmeticExpression, Expression @@ -109,7 +109,7 @@ class KernelState(IntEnum): def _get_inames_from_domains( domains: Sequence[isl.Set | isl.BasicSet] - ) -> Set[InameStr]: + ) -> AbstractSet[InameStr]: return fset_union( frozenset(dom.get_var_names_not_none(dim_type.set)) for dom in domains) @@ -550,7 +550,7 @@ def iname_tags_of_type( tag_type_or_types: type[TagT] | tuple[type[TagT], ...], max_num: int | None = None, min_num: int | None = None - ) -> Set[TagT]: + ) -> AbstractSet[TagT]: """Return a subset of *tags* that matches type *tag_type*. Raises exception if the number of tags found were greater than *max_num* or less than *min_num*. @@ -609,7 +609,7 @@ def insn_inames(self, insn: str | InstructionBase) -> frozenset[InameStr]: return insn.within_inames @memoize_method - def iname_to_insns(self) -> Mapping[InameStr, Set[InsnId]]: + def iname_to_insns(self) -> Mapping[InameStr, AbstractSet[InsnId]]: result: dict[InameStr, set[InsnId]] = { iname: set() for iname in self.all_inames()} for insn in self.instructions: @@ -619,7 +619,7 @@ def iname_to_insns(self) -> Mapping[InameStr, Set[InsnId]]: return result @memoize_method - def _remove_inames_for_shared_hw_axes(self, cond_inames: Set[InameStr]): + def _remove_inames_for_shared_hw_axes(self, cond_inames: AbstractSet[InameStr]): """ See if cond_inames contains references to two (or more) inames that boil down to the same tag. If so, exclude them. (We shouldn't be writing @@ -689,7 +689,7 @@ def compute_deps(insn_id): # {{{ read and written variables @memoize_method - def reader_map(self) -> Mapping[str, Set[InsnId]]: + def reader_map(self) -> Mapping[str, AbstractSet[InsnId]]: """ :return: a dict that maps variable names to ids of insns that read that variable. @@ -707,7 +707,7 @@ def reader_map(self) -> Mapping[str, Set[InsnId]]: return result @memoize_method - def writer_map(self) -> Mapping[str, Set[InsnId]]: + def writer_map(self) -> Mapping[str, AbstractSet[InsnId]]: """ :return: a dict that maps variable names to ids of insns that write to that variable. @@ -721,7 +721,7 @@ def writer_map(self) -> Mapping[str, Set[InsnId]]: return result @memoize_method - def get_read_variables(self) -> Set[str]: + def get_read_variables(self) -> AbstractSet[str]: return fset_union( insn.read_dependency_names() for insn in self.instructions @@ -730,7 +730,7 @@ def get_read_variables(self) -> Set[str]: for domain in self.domains ) - def get_written_variables(self) -> Set[str]: + def get_written_variables(self) -> AbstractSet[str]: try: return self._cached_written_variables except AttributeError: @@ -1178,7 +1178,7 @@ def get_nosync_set(self, insn_id, scope): return frozenset( insn_id for insn_id, nosync_scope in self.id_to_insn[insn_id].no_sync_with - if nosync_scope == scope or nosync_scope == "any") + if nosync_scope in (scope, "any")) # }}} @@ -1201,8 +1201,11 @@ def _get_iname_order_for_printing(self): return embedding - def stringify(self, what=None, with_dependencies=False, use_separators=True, - show_labels=True): + def stringify(self, + what: str | set[str] | None = None, + with_dependencies: bool = False, + use_separators: bool = True, + show_labels: bool = True) -> str: all_what = { "name", "arguments", @@ -1226,7 +1229,7 @@ def stringify(self, what=None, with_dependencies=False, use_separators=True, if isinstance(what, str): if "," in what: - what = what.split(",") + what = set(what.split(",")) what = {s.strip() for s in what} else: what = { @@ -1237,7 +1240,7 @@ def stringify(self, what=None, with_dependencies=False, use_separators=True, raise LoopyError("invalid 'what' passed: %s" % ", ".join(what-all_what)) - lines = [] + lines: list[str] = [] kernel = self @@ -1252,8 +1255,7 @@ def stringify(self, what=None, with_dependencies=False, use_separators=True, if show_labels: lines.append("ARGUMENTS:") # Arguments are ordered, do not be tempted to sort them. - for arg in kernel.args: - lines.append(str(arg)) + lines.extend(str(arg) for arg in kernel.args) if "domains" in what: lines.extend(sep) @@ -1280,16 +1282,17 @@ def stringify(self, what=None, with_dependencies=False, use_separators=True, lines.extend(sep) if show_labels: lines.append("TEMPORARIES:") - for tv in natsorted(kernel.temporary_variables.values(), - key=lambda key_tv: key_tv.name): - lines.append(str(tv)) + lines.extend(str(tv) + for tv in natsorted( + kernel.temporary_variables.values(), + key=lambda key_tv: key_tv.name)) if "rules" in what and kernel.substitutions: lines.extend(sep) if show_labels: lines.append("SUBSTITUTION RULES:") - for rule_name in natsorted(kernel.substitutions.keys()): - lines.append(str(kernel.substitutions[rule_name])) + lines.extend(str(kernel.substitutions[rule_name]) + for rule_name in natsorted(kernel.substitutions.keys())) if "instructions" in what: lines.extend(sep) @@ -1299,11 +1302,8 @@ def stringify(self, what=None, with_dependencies=False, use_separators=True, from loopy.kernel.tools import stringify_instruction_list lines.extend(stringify_instruction_list(kernel)) - dep_lines = [] - for insn in kernel.instructions: - if insn.depends_on: - dep_lines.append("{} : {}".format( - insn.id, ",".join(insn.depends_on))) + dep_lines = ["{} : {}".format(insn.id, ",".join(insn.depends_on)) + for insn in kernel.instructions if insn.depends_on] if "Dependencies" in what and dep_lines: lines.extend(sep) @@ -1323,12 +1323,10 @@ def stringify(self, what=None, with_dependencies=False, use_separators=True, return "\n".join(lines) + @override def __str__(self): return self.stringify() - def __unicode__(self): - return self.stringify() - # }}} # {{{ direct execution diff --git a/loopy/kernel/creation.py b/loopy/kernel/creation.py index a1bdd8d95..c575367fb 100644 --- a/loopy/kernel/creation.py +++ b/loopy/kernel/creation.py @@ -995,11 +995,9 @@ def _find_inames_in_set(dom_str): if match is None: raise RuntimeError("invalid syntax for domain '%s'" % dom_str) - result = {iname.strip() for iname in match.group(1).split(",") + return {iname.strip() for iname in match.group(1).split(",") if iname.strip()} - return result - EX_QUANT_RE = re.compile(r"\bexists\s+([a-zA-Z0-9])\s*\:") @@ -1620,10 +1618,9 @@ def guess_arg_shape_if_requested(kernel, default_order): from loopy.kernel.array import ArrayBase from loopy.kernel.tools import guess_var_shape - var_names = [] - for arg in kernel.args: - if isinstance(arg, ArrayBase) and arg.shape is lp.auto: - var_names.append(arg.name) + var_names = [ + arg.name for arg in kernel.args + if isinstance(arg, ArrayBase) and arg.shape is lp.auto] shapes = guess_var_shape(kernel, var_names) if var_names else [] @@ -2096,7 +2093,7 @@ def make_function( substitutions: Mapping[str, SubstitutionRule] | None = None, preambles: Sequence[tuple[str, str]] = (), preamble_generators: Sequence[PreambleGenerator] = (), - default_order: Literal["C"] | Literal["F"] | type[auto] = "C", + default_order: Literal["C", "F"] | type[auto] = "C", default_offset: Literal[0] | type[auto] | None = None, symbol_manglers: Sequence[SymbolMangler] = (), assumptions: isl.BasicSet | str = "", @@ -2526,7 +2523,7 @@ def make_kernel( substitutions: Mapping[str, SubstitutionRule] | None = None, preambles: Sequence[tuple[str, str]] = (), preamble_generators: Sequence[PreambleGenerator] = (), - default_order: Literal["C"] | Literal["F"] | type[auto] = "C", + default_order: Literal["C", "F"] | type[auto] = "C", default_offset: Literal[0] | type[auto] | None = None, symbol_manglers: Sequence[SymbolMangler] = (), assumptions: isl.BasicSet | str = "", diff --git a/loopy/kernel/function_interface.py b/loopy/kernel/function_interface.py index 700e3ffb8..9f31abe28 100644 --- a/loopy/kernel/function_interface.py +++ b/loopy/kernel/function_interface.py @@ -39,7 +39,7 @@ if TYPE_CHECKING: - from collections.abc import Iterator, Mapping, Sequence, Set + from collections.abc import Iterator, Mapping, Sequence, Set as AbstractSet import islpy as isl from pymbolic.typing import ArithmeticExpression, Expression @@ -532,7 +532,8 @@ def get_hw_axes_sizes(self, @abstractmethod def get_used_hw_axes(self, - callables_table: CallablesTable) -> tuple[Set[int], Set[int]]: + callables_table: CallablesTable + ) -> tuple[AbstractSet[int], AbstractSet[int]]: """ Returns a tuple ``group_axes_used, local_axes_used``, where ``(group|local)_axes_used`` are :class:`frozenset` of hardware axes @@ -696,7 +697,8 @@ def get_hw_axes_sizes(self, @override def get_used_hw_axes(self, - callables_table: CallablesTable) -> tuple[Set[int], Set[int]]: + callables_table: CallablesTable + ) -> tuple[AbstractSet[int], AbstractSet[int]]: return frozenset(), frozenset() @override @@ -1044,7 +1046,8 @@ def with_packing_for_args(self) -> InKernelCallable: @override def get_used_hw_axes(self, - callables_table: CallablesTable) -> tuple[Set[int], Set[int]]: + callables_table: CallablesTable + ) -> tuple[AbstractSet[int], AbstractSet[int]]: gsize, lsize = self.subkernel.get_grid_size_upper_bounds(callables_table, return_dict=True) diff --git a/loopy/kernel/instruction.py b/loopy/kernel/instruction.py index 4e157be6f..81a665db3 100644 --- a/loopy/kernel/instruction.py +++ b/loopy/kernel/instruction.py @@ -28,7 +28,7 @@ Mapping, Mapping as abc_Mapping, Sequence, - Set as abc_Set, + Set as AbstractSet, ) from dataclasses import dataclass from functools import cached_property @@ -108,7 +108,6 @@ class UseStreamingStoreTag(Tag): continue to work. Whether this is safe is target-dependent and program-dependent. No promise of safety is made. """ - pass # }}} @@ -398,7 +397,7 @@ def __init__(self, if priority is None: priority = 0 - if not isinstance(tags, abc_Set): + if not isinstance(tags, AbstractSet): # was previously allowed to be tuple tags = frozenset(tags) @@ -413,10 +412,10 @@ def __init__(self, # assert all(is_interned(iname) for iname in within_inames) # assert all(is_interned(pred) for pred in predicates) - assert isinstance(within_inames, abc_Set) + assert isinstance(within_inames, AbstractSet) assert isinstance(happens_after, abc_Mapping) or happens_after is None - assert isinstance(groups, abc_Set) - assert isinstance(conflicts_with_groups, abc_Set) + assert isinstance(groups, AbstractSet) + assert isinstance(conflicts_with_groups, AbstractSet) from loopy.tools import is_hashable assert is_hashable(happens_after) @@ -454,7 +453,7 @@ def get_copy_kwargs(self, **kwargs): # {{{ abstract interface - def read_dependency_names(self) -> abc_Set[str]: + def read_dependency_names(self) -> AbstractSet[str]: from loopy.symbolic import get_dependencies result: frozenset[str] = frozenset() @@ -463,10 +462,10 @@ def read_dependency_names(self) -> abc_Set[str]: return result - def reduction_inames(self) -> abc_Set[str]: + def reduction_inames(self) -> AbstractSet[str]: raise NotImplementedError - def sub_array_ref_inames(self) -> abc_Set[str]: + def sub_array_ref_inames(self) -> AbstractSet[str]: raise NotImplementedError def assignee_var_names(self) -> Sequence[str]: diff --git a/loopy/kernel/tools.py b/loopy/kernel/tools.py index 8866c7d04..0cd7ac8d7 100644 --- a/loopy/kernel/tools.py +++ b/loopy/kernel/tools.py @@ -28,7 +28,7 @@ import itertools import logging import sys -from collections.abc import Set +from collections.abc import Set as AbstractSet from functools import reduce from sys import intern from typing import ( @@ -51,7 +51,7 @@ from loopy.diagnostic import LoopyError, warn_with_kernel from loopy.kernel import LoopKernel -from loopy.kernel.data import KernelArgument, TemporaryVariable +from loopy.kernel.data import ArrayArg, KernelArgument, TemporaryVariable from loopy.kernel.function_interface import CallableKernel from loopy.kernel.instruction import ( CInstruction, @@ -641,27 +641,26 @@ def get_dot_dependency_graph(kernel, callables_table, iname_cluster=True, while True: changed_something = False - for insn_1 in dep_graph: + for insn_1, deps in dep_graph.items(): for insn_2 in dep_graph.get(insn_1, set()).copy(): for insn_3 in dep_graph.get(insn_2, set()).copy(): if insn_3 not in dep_graph.get(insn_1, set()): changed_something = True - dep_graph[insn_1].add(insn_3) + deps.add(insn_3) if not changed_something: break - for insn_1 in dep_graph: + for insn_1, deps in dep_graph.items(): for insn_2 in dep_graph.get(insn_1, set()).copy(): for insn_3 in dep_graph.get(insn_2, set()).copy(): if insn_3 in dep_graph.get(insn_1, set()): - dep_graph[insn_1].remove(insn_3) + deps.remove(insn_3) # }}} for insn_1 in dep_graph: - for insn_2 in dep_graph.get(insn_1, set()): - lines.append(f"{insn_2} -> {insn_1}") + lines.extend(f"{insn_2} -> {insn_1}" for insn_2 in dep_graph.get(insn_1, set())) if iname_cluster: from loopy.schedule import ( @@ -726,7 +725,7 @@ def show_dependency_graph(*args, **kwargs): # {{{ is domain dependent on inames def is_domain_dependent_on_inames(kernel: LoopKernel, - domain_index: int, inames: Set[str]) -> bool: + domain_index: int, inames: AbstractSet[str]) -> bool: dom = kernel.domains[domain_index] dom_parameters = set(dom.get_var_names_not_none(dim_type.param)) @@ -764,7 +763,10 @@ def is_domain_dependent_on_inames(kernel: LoopKernel, # {{{ rank inames by stride -def get_auto_axis_iname_ranking_by_stride(kernel, insn): +def get_auto_axis_iname_ranking_by_stride( + kernel: LoopKernel, + insn + ) -> list[InameStr] | None: from loopy.kernel.data import ImageArg, ValueArg approximate_arg_values = {} @@ -783,9 +785,9 @@ def get_auto_axis_iname_ranking_by_stride(kernel, insn): from pymbolic.primitives import Subscript - for assignee in insn.assignees: - if isinstance(assignee, Subscript): - ary_acc_exprs.append(assignee) + ary_acc_exprs.extend( + assignee for assignee in insn.assignees + if isinstance(assignee, Subscript)) # }}} @@ -830,7 +832,8 @@ def get_auto_axis_iname_ranking_by_stride(kernel, insn): index_expr = (index_expr,) ary_name = aae.aggregate.name - arg = kernel.arg_dict.get(ary_name) + arg = kernel.arg_dict[ary_name] + assert isinstance(arg, ArrayArg) if arg.dim_tags is None: from warnings import warn @@ -1235,10 +1238,10 @@ def __init__(self, children=(), all_items=None): def descend(self, on_found=lambda prefix: None, prefix=frozenset()): on_found(prefix) - for prefix, child in sorted( + for ch_prefix, child in sorted( self.children.items(), key=lambda it: sorted(it[0])): - child.descend(on_found, prefix=prefix) + child.descend(on_found, prefix=ch_prefix) def check_consistent_insert(self, items_to_insert): if items_to_insert & self.all_items: @@ -1754,7 +1757,7 @@ def kernel_has_global_barriers(kernel): @memoize_on_first_arg -def get_global_barrier_order(kernel): +def get_global_barrier_order(kernel: LoopKernel): """Return a :class:`tuple` of the listing the ids of global barrier instructions as they appear in order in the kernel. @@ -1790,8 +1793,7 @@ def get_global_barrier_order(kernel): while stack: top = stack[-1] - if top in visiting: - visiting.remove(top) + visiting.discard(top) if top in visited: stack.pop() @@ -1804,8 +1806,7 @@ def get_global_barrier_order(kernel): visiting.clear() break - for child in kernel.id_to_insn[top].depends_on: - stack.append(child) + stack.extend(kernel.id_to_insn[top].depends_on) else: # Search exhausted and we did not find prev_barrier. raise LoopyError("barriers '%s' and '%s' are not ordered" @@ -2159,7 +2160,7 @@ def get_resolved_callable_ids_called_by_knl(knl, callables, recursive=True): def get_call_graph( t_unit: TranslationUnit, only_kernel_callables: bool = False - ) -> Mapping[CallableId, Set[CallableId]]: + ) -> Mapping[CallableId, AbstractSet[CallableId]]: """ Returns a mapping from a callable name to the calls seen in it. @@ -2228,15 +2229,14 @@ def get_hw_axis_base_for_codegen(kernel: LoopKernel, iname: str) -> isl.Aff: assert kernel.iname_tags_of_type(iname, HardwareConcurrentTag) bounds = kernel.get_iname_bounds(iname) - lower_bound = static_min_of_pw_aff(bounds.lower_bound_pw_aff, + return static_min_of_pw_aff(bounds.lower_bound_pw_aff, constants_only=False) - return lower_bound # {{{ get access map from an instruction @dataclasses.dataclass -class _IndexCollector(CombineMapper[Set[tuple[Expression, ...]], []]): +class _IndexCollector(CombineMapper[AbstractSet[tuple[Expression, ...]], []]): var: str def __post_init__(self) -> None: @@ -2244,12 +2244,12 @@ def __post_init__(self) -> None: @override def combine(self, - values: Iterable[Set[tuple[Expression, ...]]] - ) -> Set[tuple[Expression, ...]]: + values: Iterable[AbstractSet[tuple[Expression, ...]]] + ) -> AbstractSet[tuple[Expression, ...]]: return set_union(values) @override - def map_subscript(self, expr: p.Subscript) -> Set[tuple[Expression, ...]]: + def map_subscript(self, expr: p.Subscript) -> AbstractSet[tuple[Expression, ...]]: assert isinstance(expr.aggregate, p.Variable) if expr.aggregate.name == self.var: return (super().map_subscript(expr) | frozenset([expr.index_tuple])) diff --git a/loopy/library/random123.py b/loopy/library/random123.py index 12bd3989c..53f1d7996 100644 --- a/loopy/library/random123.py +++ b/loopy/library/random123.py @@ -279,8 +279,6 @@ def generate_preambles(self, target): rng_variant=rng_variant, )) - return - def get_random123_callables(target): return {id_: Random123Callable(id_, target=target) for id_ in FUNC_NAMES_TO_RNG} diff --git a/loopy/library/reduction.py b/loopy/library/reduction.py index cc7c56593..38ebc1c70 100644 --- a/loopy/library/reduction.py +++ b/loopy/library/reduction.py @@ -174,9 +174,7 @@ def __eq__(self, other: object): @override def __str__(self) -> str: - result = type(self).__name__.replace("ReductionOperation", "").lower() - - return result + return type(self).__name__.replace("ReductionOperation", "").lower() def update_persistent_hash(self, key_hash: Hash, key_builder: KeyBuilder) -> None: # They're all stateless. @@ -821,8 +819,6 @@ def generate_preambles(self, target): comp=op.update_comparison, )) - return - class SegmentOpCallable(ReductionCallable): @@ -851,7 +847,6 @@ def generate_preambles(self, target): combined=op.op % ("op1", "op2"), )) - return # }}} diff --git a/loopy/match.py b/loopy/match.py index febf588cf..03007bb33 100644 --- a/loopy/match.py +++ b/loopy/match.py @@ -551,7 +551,7 @@ class StackWildcardMatchComponent(StackMatchComponent): inner_match: StackMatchComponent def __call__(self, kernel: LoopKernel, stack: Sequence[Matchable]) -> bool: - return any(self.inner_match(kernel, stack[i:]) for i in range(0, len(stack))) + return any(self.inner_match(kernel, stack[i:]) for i in range(len(stack))) # }}} diff --git a/loopy/preprocess.py b/loopy/preprocess.py index 463ed7883..764c460b5 100644 --- a/loopy/preprocess.py +++ b/loopy/preprocess.py @@ -218,9 +218,8 @@ def make_arrays_for_sep_arrays(kernel: LoopKernel) -> LoopKernel: if not made_changes: return kernel - kernel = kernel.copy(args=new_args) + return kernel.copy(args=new_args) - return kernel # }}} @@ -883,7 +882,7 @@ def preprocess_program(t_unit: TranslationUnit) -> TranslationUnit: # Ordering restriction: # callees with gbarrier in them must be inlined after inferrring arg_descr. - t_unit = inline_kernels_with_gbarriers(t_unit) + return inline_kernels_with_gbarriers(t_unit) # {{{ prepare for caching @@ -894,8 +893,6 @@ def preprocess_program(t_unit: TranslationUnit) -> TranslationUnit: # }}} - return t_unit - # FIXME: Do we add a deprecation warning? preprocess_kernel = preprocess_program diff --git a/loopy/schedule/__init__.py b/loopy/schedule/__init__.py index 34861b153..eb7d3b444 100644 --- a/loopy/schedule/__init__.py +++ b/loopy/schedule/__init__.py @@ -30,10 +30,10 @@ TYPE_CHECKING, Any, Literal, - TypeVar, ) from constantdict import constantdict +from typing_extensions import Self import islpy as isl from pytools import MinRecursionLimit, ProcessLogger @@ -46,7 +46,13 @@ if TYPE_CHECKING: - from collections.abc import Hashable, Iterator, Mapping, Sequence, Set + from collections.abc import ( + Hashable, + Iterator, + Mapping, + Sequence, + Set as AbstractSet, + ) from loopy.kernel import LoopKernel from loopy.kernel.function_interface import InKernelCallable @@ -74,14 +80,11 @@ """ -_SchedItemSelfT = TypeVar("_SchedItemSelfT", bound="ScheduleItem") - - # {{{ schedule items @dataclass(frozen=True) class ScheduleItem: - def copy(self: _SchedItemSelfT, **kwargs: Any) -> _SchedItemSelfT: + def copy(self, **kwargs: Any) -> Self: return replace(self, **kwargs) @@ -291,8 +294,8 @@ def find_loop_nest_around_map(kernel: LoopKernel) -> Mapping[str, set[str]]: def find_loop_insn_dep_map( kernel: LoopKernel, - loop_nest_with_map: Mapping[str, Set[str]], - loop_nest_around_map: Mapping[str, Set[str]] + loop_nest_with_map: Mapping[str, AbstractSet[str]], + loop_nest_around_map: Mapping[str, AbstractSet[str]] ) -> Mapping[str, set[str]]: """Returns a dictionary mapping inames to other instruction ids that need to be scheduled before the iname should be eligible for scheduling. @@ -370,7 +373,7 @@ def group_insn_counts(kernel: LoopKernel) -> Mapping[str, int]: def gen_dependencies_except( - kernel: LoopKernel, insn_id: str, except_insn_ids: Set[str] + kernel: LoopKernel, insn_id: str, except_insn_ids: AbstractSet[str] ) -> Iterator[str]: insn = kernel.id_to_insn[insn_id] for dep_id in insn.depends_on: @@ -384,9 +387,9 @@ def gen_dependencies_except( def get_priority_tiers( - wanted: Set[InameStr], - priorities: Set[Sequence[InameStr]] - ) -> Iterator[Set[InameStr]]: + wanted: AbstractSet[InameStr], + priorities: AbstractSet[Sequence[InameStr]] + ) -> Iterator[AbstractSet[InameStr]]: # Get highest priority tier candidates: These are the first inames # of all the given priority constraints candidates = set() diff --git a/loopy/schedule/device_mapping.py b/loopy/schedule/device_mapping.py index 226757dea..f18bd5df5 100644 --- a/loopy/schedule/device_mapping.py +++ b/loopy/schedule/device_mapping.py @@ -146,6 +146,4 @@ def inner_mapper(start_idx, end_idx, new_schedule): elif isinstance(sched_item, ReturnFromKernel): new_schedule[idx] = sched_item.copy(kernel_name=last_kernel_name) - new_kernel = kernel.copy(linearization=new_schedule) - - return new_kernel + return kernel.copy(linearization=new_schedule) diff --git a/loopy/schedule/tools.py b/loopy/schedule/tools.py index e23e1d86d..cd7fc7a35 100644 --- a/loopy/schedule/tools.py +++ b/loopy/schedule/tools.py @@ -73,7 +73,13 @@ if TYPE_CHECKING: - from collections.abc import Callable, Collection, Mapping, Sequence, Set + from collections.abc import ( + Callable, + Collection, + Mapping, + Sequence, + Set as AbstractSet, + ) from pymbolic import Expression @@ -221,7 +227,7 @@ def _should_temp_var_be_passed(tv: TemporaryVariable) -> bool: class _SupportingNameTracker: def __init__(self, kernel: LoopKernel): self.kernel: LoopKernel = kernel - self.name_to_main_name: dict[str, Set[str]] = {} + self.name_to_main_name: dict[str, AbstractSet[str]] = {} def add_supporting_names_for(self, name: str): var_descr = self.kernel.get_var_descriptor(name) @@ -962,7 +968,7 @@ def _raise_loopy_err(x: str): @memoize_on_first_arg -def _get_parallel_inames(kernel: LoopKernel) -> Set[str]: +def _get_parallel_inames(kernel: LoopKernel) -> AbstractSet[str]: from loopy.kernel.data import ConcurrentTag, IlpBaseTag, VectorizeTag concurrent_inames = {iname for iname in kernel.all_inames() diff --git a/loopy/statistics.py b/loopy/statistics.py old mode 100755 new mode 100644 index af28eaaee..3fd6568eb --- a/loopy/statistics.py +++ b/loopy/statistics.py @@ -296,8 +296,6 @@ def filter_by(self, **kwargs): """ - new_count_map = {} - class _Sentinel: pass @@ -309,10 +307,10 @@ class _Sentinel: new_kwargs[arg_field] = allowable_vals - for key, val in self.count_map.items(): + new_count_map = {key: val + for key, val in self.count_map.items() if all(getattr(key, arg_field, _Sentinel) in allowable_vals - for arg_field, allowable_vals in new_kwargs.items()): - new_count_map[key] = val + for arg_field, allowable_vals in new_kwargs.items())} return self.copy(count_map=new_count_map) @@ -341,11 +339,9 @@ def filter_func(key): """ - new_count_map = {} - - for self_key, self_val in self.count_map.items(): - if func(self_key): - new_count_map[self_key] = self_val + new_count_map = {self_key: self_val + for self_key, self_val in self.count_map.items() + if func(self_key)} return self.copy(count_map=new_count_map) @@ -1807,30 +1803,13 @@ def get_op_map(program, count_redundant_work=False, # {{{ subgoup size finding -def _find_subgroup_size_for_knl(knl): - from loopy.target.pyopencl import PyOpenCLTarget - if isinstance(knl.target, PyOpenCLTarget) and knl.target.device is not None: - from pyopencl.characterize import get_simd_group_size - # type_size is unused in get_simd_group_size - subgroup_size_guess = get_simd_group_size(knl.target.device, type_size=4) - - warn_with_kernel(knl, "getting_subgroup_size_from_device", - "Device: %s. Using sub-group size given by " - "pyopencl.characterize.get_simd_group_size(): %s" - % (knl.target.device, subgroup_size_guess)) - return subgroup_size_guess - else: - return None - - @memoize_method -def _process_subgroup_size(knl, subgroup_size_requested): +def _process_subgroup_size(knl, subgroup_size_requested: int | None): if isinstance(subgroup_size_requested, int): return subgroup_size_requested else: - # try to find subgroup_size - subgroup_size_guess = _find_subgroup_size_for_knl(knl) + subgroup_size_guess = None if subgroup_size_requested is None: if subgroup_size_guess is None: diff --git a/loopy/symbolic.py b/loopy/symbolic.py index 3b35b63c8..aa5132077 100644 --- a/loopy/symbolic.py +++ b/loopy/symbolic.py @@ -28,7 +28,7 @@ import contextlib import re from collections import defaultdict -from collections.abc import Set +from collections.abc import Set as AbstractSet from dataclasses import dataclass, replace from functools import cached_property, reduce from sys import intern @@ -1189,42 +1189,43 @@ def get_reduction_inames(expr: Expression) -> frozenset[str]: return _get_dependencies_and_reduction_inames(expr)[1] -class SubArrayRefSweptInamesCollector(CombineMapper[Set[str], []]): +class SubArrayRefSweptInamesCollector(CombineMapper[AbstractSet[str], []]): @override - def combine(self, values: Iterable[Set[str]]) -> Set[str]: - result: Set[str] = set() + def combine(self, values: Iterable[AbstractSet[str]]) -> AbstractSet[str]: + result: AbstractSet[str] = set() for value in values: result |= value return frozenset(result) @override - def map_sub_array_ref(self, expr: SubArrayRef, /) -> Set[str]: + def map_sub_array_ref(self, expr: SubArrayRef, /) -> AbstractSet[str]: return frozenset({iname.name for iname in expr.swept_inames}) def _map_no_swept_inames( self, expr: ( object | p.Variable | p.FunctionSymbol | p.NaN - | TaggedVariable | TypeCast | ResolvedFunction), /) -> Set[str]: + | TaggedVariable | TypeCast | ResolvedFunction), + /) -> AbstractSet[str]: return frozenset() - map_constant: Callable[[Self, object], Set[str]] = _map_no_swept_inames - map_variable: Callable[[Self, p.Variable], Set[str]] = _map_no_swept_inames - map_function_symbol: Callable[[Self, p.FunctionSymbol], Set[str]] = _map_no_swept_inames # noqa: E501 - map_nan: Callable[[Self, p.NaN], Set[str]] = _map_no_swept_inames - map_tagged_variable: Callable[[Self, TaggedVariable], Set[str]] = _map_no_swept_inames # noqa: E501 - map_type_cast: Callable[[Self, TypeCast], Set[str]] = _map_no_swept_inames - map_resolved_function: Callable[[Self, ResolvedFunction], Set[str]] = _map_no_swept_inames # noqa: E501 + map_constant: Callable[[Self, object], AbstractSet[str]] = _map_no_swept_inames + map_variable: Callable[[Self, p.Variable], AbstractSet[str]] = _map_no_swept_inames + map_function_symbol: Callable[[Self, p.FunctionSymbol], AbstractSet[str]] = _map_no_swept_inames # noqa: E501 + map_nan: Callable[[Self, p.NaN], AbstractSet[str]] = _map_no_swept_inames + map_tagged_variable: Callable[[Self, TaggedVariable], AbstractSet[str]] = _map_no_swept_inames # noqa: E501 + map_type_cast: Callable[[Self, TypeCast], AbstractSet[str]] = _map_no_swept_inames + map_resolved_function: Callable[[Self, ResolvedFunction], AbstractSet[str]] = _map_no_swept_inames # noqa: E501 -def get_sub_array_ref_swept_inames(expr: SubArrayRef) -> Set[str]: +def get_sub_array_ref_swept_inames(expr: SubArrayRef) -> AbstractSet[str]: return SubArrayRefSweptInamesCollector()(expr) # {{{ rule-aware mappers -def parse_tagged_name(expr: Expression) -> tuple[str, Set[Tag] | None]: +def parse_tagged_name(expr: Expression) -> tuple[str, AbstractSet[Tag] | None]: from loopy.library.reduction import ArgExtOp, SegmentedOp if isinstance(expr, TaggedVariable): @@ -1524,7 +1525,7 @@ def make_new_arg_context( def map_subst_rule( self, name: str, - tags: Set[Tag] | None, + tags: AbstractSet[Tag] | None, arguments: Sequence[Expression], expn_state: ExpansionState, *args: P.args, **kwargs: P.kwargs @@ -1713,7 +1714,7 @@ def __init__(self, @override def map_subst_rule( self, name: str, - tags: Set[Tag] | None, + tags: AbstractSet[Tag] | None, arguments: Sequence[Expression], expn_state: ExpansionState ) -> Expression: @@ -2013,7 +2014,7 @@ def map_subscript(self, expr: p.Subscript, /) -> CoeffsT: # {{{ variable index expression collector -class ArrayAccessFinder(CombineMapper[Set[p.Subscript], []]): +class ArrayAccessFinder(CombineMapper[AbstractSet[p.Subscript], []]): tgt_vector_name: str | None def __init__(self, tgt_vector_name: str | None = None) -> None: @@ -2021,20 +2022,22 @@ def __init__(self, tgt_vector_name: str | None = None) -> None: super().__init__() @override - def combine(self, values: Iterable[Set[p.Subscript]]) -> Set[p.Subscript]: + def combine(self, + values: Iterable[AbstractSet[p.Subscript]] + ) -> AbstractSet[p.Subscript]: from pytools import flatten return set(flatten(values)) @override - def map_constant(self, expr: object, /) -> Set[p.Subscript]: + def map_constant(self, expr: object, /) -> AbstractSet[p.Subscript]: return set() @override - def map_algebraic_leaf(self, expr: p.AlgebraicLeaf, /) -> Set[p.Subscript]: + def map_algebraic_leaf(self, expr: p.AlgebraicLeaf, /) -> AbstractSet[p.Subscript]: return set() @override - def map_subscript(self, expr: p.Subscript, /) -> Set[p.Subscript]: + def map_subscript(self, expr: p.Subscript, /) -> AbstractSet[p.Subscript]: assert isinstance(expr.aggregate, p.Variable) if ( @@ -2669,9 +2672,9 @@ def condition_to_set(space: isl.Space, expr: Expression) -> isl.Set | None: # {{{ set_to_cond_expr def basic_set_to_cond_expr(isl_basicset: isl.BasicSet) -> Expression: - constrs: list[Expression] = [] - for constr in isl_basicset.get_constraints(): - constrs.append(constraint_to_cond_expr(constr)) + constrs: list[Expression] = [ + constraint_to_cond_expr(constr) + for constr in isl_basicset.get_constraints()] if len(constrs) == 0: raise ValueError("may not be called on universe") @@ -2683,9 +2686,9 @@ def basic_set_to_cond_expr(isl_basicset: isl.BasicSet) -> Expression: def set_to_cond_expr(isl_set: isl.Set) -> Expression: - conjs: list[Expression] = [] - for isl_basicset in isl_set.get_basic_sets(): - conjs.append(basic_set_to_cond_expr(isl_basicset)) + conjs: list[Expression] = [ + basic_set_to_cond_expr(isl_basicset) + for isl_basicset in isl_set.get_basic_sets()] if len(conjs) == 0: raise ValueError("may not be called on universe") @@ -2727,7 +2730,7 @@ def map_reduction(self, expr: Reduction, /, # {{{ index dependency finding -class IndexVariableFinder(CombineMapper[Set[str], []]): +class IndexVariableFinder(CombineMapper[AbstractSet[str], []]): include_reduction_inames: bool def __init__(self, include_reduction_inames: bool) -> None: @@ -2735,7 +2738,7 @@ def __init__(self, include_reduction_inames: bool) -> None: self.include_reduction_inames = include_reduction_inames @override - def combine(self, values: Iterable[Set[str]]) -> Set[str]: + def combine(self, values: Iterable[AbstractSet[str]]) -> AbstractSet[str]: result = set() for value in values: result |= value @@ -2743,15 +2746,15 @@ def combine(self, values: Iterable[Set[str]]) -> Set[str]: return result @override - def map_constant(self, expr: object, /) -> Set[str]: + def map_constant(self, expr: object, /) -> AbstractSet[str]: return set() @override - def map_algebraic_leaf(self, expr: p.AlgebraicLeaf, /) -> Set[str]: + def map_algebraic_leaf(self, expr: p.AlgebraicLeaf, /) -> AbstractSet[str]: return set() @override - def map_subscript(self, expr: p.Subscript, /) -> Set[str]: + def map_subscript(self, expr: p.Subscript, /) -> AbstractSet[str]: idx_vars = DependencyMapper()(expr.index) result: set[str] = set() @@ -2764,7 +2767,7 @@ def map_subscript(self, expr: p.Subscript, /) -> Set[str]: return result @override - def map_reduction(self, expr: Reduction, /) -> Set[str]: + def map_reduction(self, expr: Reduction, /) -> AbstractSet[str]: result = self.rec(expr.expr) if not (expr.inames_set & result): @@ -2943,9 +2946,9 @@ def get_access_map( # {{{ access range mapper -class BatchedAccessMapMapper(WalkMapper[[Set[str]]]): +class BatchedAccessMapMapper(WalkMapper[[AbstractSet[str]]]): kernel: LoopKernel - access_maps: defaultdict[str, defaultdict[Set[str], isl.Map | None]] + access_maps: defaultdict[str, defaultdict[AbstractSet[str], isl.Map | None]] bad_subscripts: defaultdict[str, list[p.Subscript | LinearSubscript]] _overestimate: bool _var_names: Collection[str] @@ -2973,7 +2976,7 @@ def get_access_range(self, var_name: str) -> isl.Set | None: (not_none(val).range() for val in loops_to_amaps.values())) @override - def map_subscript(self, expr: p.Subscript, /, inames: Set[str]) -> None: + def map_subscript(self, expr: p.Subscript, /, inames: AbstractSet[str]) -> None: domain = self.kernel.get_inames_domain(inames) super().map_subscript(expr, inames) @@ -3023,7 +3026,7 @@ def map_subscript(self, expr: p.Subscript, /, inames: Set[str]) -> None: @override def map_linear_subscript( self, - expr: LinearSubscript, /, inames: Set[str] + expr: LinearSubscript, /, inames: AbstractSet[str] ) -> None: self.rec(expr.index, inames) @@ -3032,11 +3035,11 @@ def map_linear_subscript( self.bad_subscripts[expr.aggregate.name].append(expr) @override - def map_reduction(self, expr: Reduction, /, inames: Set[str]) -> None: + def map_reduction(self, expr: Reduction, /, inames: AbstractSet[str]) -> None: return WalkMapper.map_reduction(self, expr, inames | set(expr.inames)) @override - def map_sub_array_ref(self, expr: SubArrayRef, /, inames: Set[str]) -> None: + def map_sub_array_ref(self, expr: SubArrayRef, /, inames: AbstractSet[str]) -> None: assert isinstance(expr.subscript.aggregate, p.Variable) arg_name = expr.subscript.aggregate.name if arg_name not in self._var_names: @@ -3090,7 +3093,7 @@ def __init__(self, self.var_name = var_name self.inner_mapper = BatchedAccessMapMapper(kernel, [var_name], overestimate) - def __call__(self, expr: Expression, inames: Set[str]) -> None: + def __call__(self, expr: Expression, inames: AbstractSet[str]) -> None: return self.inner_mapper(expr, inames) @property @@ -3113,14 +3116,14 @@ class AccessRangeOverlapChecker: kernel: LoopKernel @cached_property - def vars(self) -> Set[str]: + def vars(self) -> AbstractSet[str]: return (self.kernel.get_written_variables() | self.kernel.get_read_variables()) @memoize_method def _get_access_ranges(self, insn_id: InsnId, - access_dir: TypingLiteral["w"] | TypingLiteral["any"] + access_dir: TypingLiteral["w", "any"] ): insn = self.kernel.id_to_insn[insn_id] @@ -3147,7 +3150,7 @@ def _get_access_ranges(self, def _get_access_range_for_var(self, insn_id: str, - access_dir: TypingLiteral["w"] | TypingLiteral["any"], + access_dir: TypingLiteral["w", "any"], var_name: str ): assert access_dir in ["w", "any"] @@ -3166,9 +3169,9 @@ def _get_access_range_for_var(self, def do_access_ranges_overlap_conservative(self, insn1: InsnId, - insn1_dir: TypingLiteral["w"] | TypingLiteral["any"], + insn1_dir: TypingLiteral["w", "any"], insn2: InsnId, - insn2_dir: TypingLiteral["w"] | TypingLiteral["any"], + insn2_dir: TypingLiteral["w", "any"], var_name: str, ): """Determine whether the access ranges to *var_name* in the two diff --git a/loopy/target/__init__.py b/loopy/target/__init__.py index 5c147c0f6..9476c0e2a 100644 --- a/loopy/target/__init__.py +++ b/loopy/target/__init__.py @@ -193,7 +193,7 @@ def get_kernel_executor( @dataclass(frozen=True) -class ASTBuilderBase(Generic[ASTType], ABC): +class ASTBuilderBase(ABC, Generic[ASTType]): """An interface for generating (host or device) ASTs. """ diff --git a/loopy/target/c/__init__.py b/loopy/target/c/__init__.py index e9a297cc3..a2885b7bf 100644 --- a/loopy/target/c/__init__.py +++ b/loopy/target/c/__init__.py @@ -334,7 +334,7 @@ def _preamble_generator( static inline {res_ctype} {func.c_name}({base_ctype} x, {exp_ctype} n) {{ if (n == 0) return 1; - {re.sub(r"^", 14*" ", signed_exponent_preamble, flags=re.M)} + {re.sub(r"^", 14*" ", signed_exponent_preamble, flags=re.MULTILINE)} {res_ctype} y = 1; diff --git a/loopy/target/c/c_execution.py b/loopy/target/c/c_execution.py index d7409cfcb..dd8f500bf 100644 --- a/loopy/target/c/c_execution.py +++ b/loopy/target/c/c_execution.py @@ -102,7 +102,7 @@ def python_dtype_str_inner(self, dtype): if dtype.name == "bool": name = "bool_" return f"_lpy_np.dtype(_lpy_np.{name})" - raise Exception(f"dtype: {dtype} not recognized") + raise TypeError(f"dtype: {dtype} not recognized") # {{{ handle non numpy arguments @@ -193,7 +193,6 @@ def initialize_system_args(self, gen): """ Initializes possibly empty system arguments """ - pass # {{{ generate invocation @@ -511,7 +510,7 @@ def translation_unit_info(self, dev_code = codegen_result.device_code() host_code = codegen_result.host_code() - all_code = "\n".join([dev_code, "", host_code]) + all_code = f"{dev_code}\n\n{host_code}" if t_unit[self.entrypoint].options.write_code: output = all_code @@ -528,16 +527,13 @@ def translation_unit_info(self, from pytools import invoke_editor dev_code = invoke_editor(dev_code, "code.c") # update code from editor - all_code = "\n".join([dev_code, "", host_code]) - - c_kernels = [] + all_code = f"{dev_code}\n\n{host_code}" from loopy.schedule.tools import get_kernel_arg_info kai = get_kernel_arg_info(t_unit[self.entrypoint]) - for dp in codegen_result.device_programs: - c_kernels.append(CompiledCKernel( + c_kernels = [CompiledCKernel( t_unit[self.entrypoint], dp, kai.passed_names, all_code, - self.compiler)) + self.compiler) for dp in codegen_result.device_programs] return _KernelInfo( t_unit=t_unit, diff --git a/loopy/target/c/codegen/expression.py b/loopy/target/c/codegen/expression.py index 1d75ccd94..7bbee772e 100644 --- a/loopy/target/c/codegen/expression.py +++ b/loopy/target/c/codegen/expression.py @@ -213,12 +213,11 @@ def postproc(x): from loopy.symbolic import simplify_using_aff subscript = _apply_offset(0, arg) - result = self.make_subscript( + return self.make_subscript( arg, var(expr.name), simplify_using_aff( self.kernel, self.rec_arith(subscript, "i"))) - return result else: return var(expr.name)[0] else: diff --git a/loopy/target/c/compyte b/loopy/target/c/compyte index 2b168ca39..80ed45de9 160000 --- a/loopy/target/c/compyte +++ b/loopy/target/c/compyte @@ -1 +1 @@ -Subproject commit 2b168ca396aec2259da408f441f5e38ac9f95cb6 +Subproject commit 80ed45de98b5432341763b9fa52a00fdac870b89 diff --git a/loopy/target/execution.py b/loopy/target/execution.py index 20deb412d..818322c6b 100644 --- a/loopy/target/execution.py +++ b/loopy/target/execution.py @@ -54,7 +54,7 @@ if TYPE_CHECKING: - from collections.abc import Callable, Mapping, Sequence, Set + from collections.abc import Callable, Mapping, Sequence, Set as AbstractSet from pymbolic.typing import Expression @@ -771,7 +771,7 @@ class ExecutorBase: t_unit: TranslationUnit packing_controller: SeparateArrayPackingController | None entrypoint: str - input_array_names: Set[str] + input_array_names: AbstractSet[str] has_runtime_typed_args: bool separated_entry_knl: LoopKernel sep_info: dict[str, _ArraySeparationInfo] diff --git a/loopy/target/opencl.py b/loopy/target/opencl.py index 30e84d9ba..ed05c7628 100644 --- a/loopy/target/opencl.py +++ b/loopy/target/opencl.py @@ -597,11 +597,11 @@ def map_local_hw_index(self, expr, type_context: TypeContext): class OpenCLTarget(CFamilyTarget): """A target for the OpenCL C heterogeneous compute programming language. """ - atomics_flavor: Literal["cl1"] | Literal["cl2"] + atomics_flavor: Literal["cl1", "cl2"] use_int8_for_bool: bool def __init__(self, - atomics_flavor: Literal["cl1"] | Literal["cl2"] | None = None, + atomics_flavor: Literal["cl1", "cl2"] | None = None, use_int8_for_bool: bool = True ): """ diff --git a/loopy/target/pyopencl.py b/loopy/target/pyopencl.py index 69bbbb89c..9d88394c9 100644 --- a/loopy/target/pyopencl.py +++ b/loopy/target/pyopencl.py @@ -170,13 +170,9 @@ def with_types(self, def generate_preambles(self, target: PyOpenCLTarget) -> Iterator[tuple[str, str]]: name = self.name_in_target - if (name.startswith("_lpy_real") - or name.startswith("_lpy_conj") - or name.startswith("_lpy_imag")): - if name.startswith("_lpy_real") or name.startswith("_lpy_conj"): - ret = "x" - else: - ret = "0" + if (name is not None + and name.startswith(("_lpy_real", "_lpy_conj", "_lpy_imag"))): + ret = "x" if name.startswith(("_lpy_real", "_lpy_conj")) else "0" dtype = self.arg_id_to_dtype[-1] ctype = target.dtype_to_typename(dtype) @@ -579,13 +575,6 @@ def __init__( self.limit_arg_size_nbytes = limit_arg_size_nbytes self.pointer_size_nbytes = pointer_size_nbytes - @property - def device(self): - warn("PyOpenCLTarget.device is deprecated, it will stop working in 2022.", - DeprecationWarning, stacklevel=2) - return None - - # NB: Not including 'device', as that is handled specially here. hash_fields = (*OpenCLTarget.hash_fields, "pyopencl_module_name") comparison_fields = (*OpenCLTarget.comparison_fields, "pyopencl_module_name") @@ -618,7 +607,7 @@ def get_dtype_registry(self) -> DTypeRegistry: def is_vector_dtype(self, dtype): try: - import pyopencl.cltypes as cltypes + from pyopencl import cltypes vec_types = cltypes.vec_types except ImportError: from pyopencl.array import vec @@ -629,7 +618,7 @@ def is_vector_dtype(self, dtype): def vector_dtype(self, base, count): try: - import pyopencl.cltypes as cltypes + from pyopencl import cltypes vec_types = cltypes.vec_types except ImportError: from pyopencl.array import vec @@ -854,7 +843,7 @@ def _get_global_temporaries(self, codegen_state: CodeGenerationState): def get_temporary_decls(self, codegen_state: CodeGenerationState, schedule_index: int - ): + ) -> list[genpy.Generable]: from genpy import Assign, Comment, Line from pymbolic.mapper.stringifier import PREC_NONE ecm = self.get_expression_to_code_mapper(codegen_state) diff --git a/loopy/target/python.py b/loopy/target/python.py index 5700ff1a2..3b4b9795f 100644 --- a/loopy/target/python.py +++ b/loopy/target/python.py @@ -219,21 +219,14 @@ def get_function_declaration( @override def get_temporary_decls(self, codegen_state: CodeGenerationState, - schedule_index: int): + schedule_index: int) -> Sequence[Generable]: kernel = codegen_state.kernel ecm = codegen_state.expression_to_code_mapper - result = [] - from genpy import Assign from pymbolic.mapper.stringifier import PREC_NONE - for tv in sorted( - kernel.temporary_variables.values(), - key=lambda key_tv: key_tv.name): - if tv.shape: - result.append( - Assign( + return [Assign( tv.name, "_lpy_np.empty(%s, dtype=%s)" % ( @@ -242,9 +235,9 @@ def get_temporary_decls(self, tv.dtype.numpy_dtype.name if tv.dtype.numpy_dtype.name != "bool" else "bool_") - ))) - - return result + )) for tv in sorted( + kernel.temporary_variables.values(), + key=lambda key_tv: key_tv.name) if tv.shape] @override def get_expression_to_code_mapper(self, codegen_state: CodeGenerationState): diff --git a/loopy/tools.py b/loopy/tools.py index a12098f6d..8ab419585 100644 --- a/loopy/tools.py +++ b/loopy/tools.py @@ -22,8 +22,8 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. """ -import collections.abc as abc import logging +from collections import abc from functools import cached_property from sys import intern from typing import TYPE_CHECKING, ClassVar, Generic, Literal, TypeVar, cast, overload @@ -159,15 +159,17 @@ def hash_key(self): # {{{ remove common indentation -def remove_common_indentation(code, require_leading_newline=True, - ignore_lines_starting_with=None, strip_empty_lines=True): +def remove_common_indentation( + code: str, + require_leading_newline: bool = True, + ignore_lines_starting_with: str | None = None, + strip_empty_lines: bool = True): if "\n" not in code: return code # accommodate pyopencl-ish syntax highlighting cl_prefix = "//CL//" - if code.startswith(cl_prefix): - code = code[len(cl_prefix):] + code = code.removeprefix(cl_prefix) if require_leading_newline and not code.startswith("\n"): return code @@ -197,7 +199,7 @@ def remove_common_indentation(code, require_leading_newline=True, while test_line[base_indent] in " \t": base_indent += 1 - new_lines = [] + new_lines: list[str] = [] for line in lines: if (ignore_lines_starting_with and line.lstrip().startswith(ignore_lines_starting_with)): @@ -216,7 +218,7 @@ def remove_common_indentation(code, require_leading_newline=True, # {{{ remove_lines_with_only_spaces -def remove_lines_with_only_spaces(code): +def remove_lines_with_only_spaces(code: str): return "\n".join(line for line in code.split("\n") if set(line) != {" "}) # }}} @@ -327,11 +329,10 @@ def empty_aligned( # so it is correctly aligned array_aligned_offset = (n-address_from_numpy(base_ary)) % n - array = np.frombuffer( + return np.frombuffer( base_ary[array_aligned_offset:array_aligned_offset-n].data, dtype=dtype).reshape(*shape_tup, order=order) - return array # }}} @@ -647,16 +648,19 @@ def intern_frozenset_of_ids(fs: abc.Iterable[str]) -> frozenset[str]: # {{{ t_unit_to_python -def _is_generated_t_unit_the_same(python_code, var_name, ref_t_unit): +def _is_generated_t_unit_the_same( + python_code: str, + var_name: str, + ref_t_unit: TranslationUnit): """ Helper for :func:`kernel_to_python`. Returns *True* only if the variable referenced by *var_name* in *python_code* is equal to *kernel*, else returns *False*. """ reproducer_variables = {} - exec(python_code, reproducer_variables) + exec(python_code, reproducer_variables) # noqa: S102 t_unit = reproducer_variables[var_name] - return ref_t_unit == t_unit + return t_unit == ref_t_unit # {{{ CallablesUnresolver @@ -818,11 +822,10 @@ def _kernel_to_python( kernel=kernel, make_kernel=make_kernel, var_name=var_name) - python_code = remove_lines_with_only_spaces( + assert isinstance(python_code, str) + return remove_lines_with_only_spaces( remove_common_indentation(python_code)) - return python_code - @overload def t_unit_to_python( @@ -880,15 +883,13 @@ def t_unit_to_python( knl_args = ", ".join(f"{name}_knl" for name in t_unit.callables_table) merge_stmt = f"{var_name} = lp.merge([{knl_args}])" - preamble_str = "\n".join([ - "import loopy as lp", - "import numpy as np", - "from pymbolic.primitives import *", - "from constantdict import constantdict", - ]) + preamble_str = ("import loopy as lp\n" + "import numpy as np\n" + "from pymbolic.primitives import *\n" + "from constantdict import constantdict") body_str = "\n".join([*knl_python_code_srcs, "\n", merge_stmt]) - python_code = "\n".join([preamble_str, "\n", body_str]) + python_code = f"{preamble_str}\n\n\n{body_str}" assert _is_generated_t_unit_the_same(python_code, var_name, t_unit) if return_preamble_and_body_separately: diff --git a/loopy/transform/add_barrier.py b/loopy/transform/add_barrier.py index ebf8a3cf6..6ed57cab3 100644 --- a/loopy/transform/add_barrier.py +++ b/loopy/transform/add_barrier.py @@ -100,11 +100,10 @@ def add_barrier( mem_kind=mem_kind) new_kernel = kernel.copy(instructions=[*kernel.instructions, barrier_to_add]) - new_kernel = add_dependency( + return add_dependency( new_kernel, insn_match=insn_after, depends_on="id:" + id ) - return new_kernel # }}} diff --git a/loopy/transform/array_buffer_map.py b/loopy/transform/array_buffer_map.py index a94fb9033..323321223 100644 --- a/loopy/transform/array_buffer_map.py +++ b/loopy/transform/array_buffer_map.py @@ -166,14 +166,15 @@ def build_global_storage_to_sweep_map( else: global_stor2sweep = global_stor2sweep.union(stor2sweep) + assert global_stor2sweep is not None + if isinstance(global_stor2sweep, isl.BasicMap): global_stor2sweep = isl.Map.from_basic_map(global_stor2sweep) - global_stor2sweep = global_stor2sweep.intersect_range(domain_dup_sweep) + return global_stor2sweep.intersect_range(domain_dup_sweep) # space for global_stor2sweep: # [stor_axes'] -> [domain](dup_sweep_index)[dup_sweep](rn) - return global_stor2sweep # }}} diff --git a/loopy/transform/batch.py b/loopy/transform/batch.py index f4ec2c7e2..574a71702 100644 --- a/loopy/transform/batch.py +++ b/loopy/transform/batch.py @@ -195,12 +195,11 @@ def to_batched(kernel, nbatches, batch_varying_args, batch_iname_prefix="ibatch" bvc.map_kernel(kernel)) batch_iname_set = frozenset([batch_iname]) - kernel = kernel.copy( + return kernel.copy( instructions=[ insn.copy(within_inames=insn.within_inames | batch_iname_set) for insn in kernel.instructions]) - return kernel # }}} diff --git a/loopy/transform/buffer.py b/loopy/transform/buffer.py index 8fc910ea5..a2c7b5430 100644 --- a/loopy/transform/buffer.py +++ b/loopy/transform/buffer.py @@ -402,7 +402,6 @@ def buffer_array_for_single_kernel(kernel, callables_table, var_name, if init_expression is None: init_expression = init_base else: - init_expression = init_expression init_expression = SubstitutionMapper( make_subst_func({ "base": init_base, @@ -526,9 +525,7 @@ def none_to_empty_set(s): kernel = tag_inames(kernel, new_iname_to_tag) from loopy.kernel.tools import assign_automatic_axes - kernel = assign_automatic_axes(kernel, callables_table) - - return kernel + return assign_automatic_axes(kernel, callables_table) @memoize_on_disk diff --git a/loopy/transform/data.py b/loopy/transform/data.py index 67b99ec30..61ce45e7a 100644 --- a/loopy/transform/data.py +++ b/loopy/transform/data.py @@ -550,7 +550,6 @@ def set_array_axis_names(kernel, ary_names, dim_names): @for_each_kernel def remove_unused_arguments(kernel): - new_args = [] import loopy as lp exp_kernel = lp.expand_subst(kernel) @@ -580,9 +579,7 @@ def tolerant_get_deps(expr): refd_vars.update( tolerant_get_deps(dim_tag.stride)) - for arg in kernel.args: - if arg.name in refd_vars: - new_args.append(arg) + new_args = [arg for arg in kernel.args if arg.name in refd_vars] return kernel.copy(args=new_args) diff --git a/loopy/transform/diff.py b/loopy/transform/diff.py index ca17dbf1c..21f49bb7c 100644 --- a/loopy/transform/diff.py +++ b/loopy/transform/diff.py @@ -238,9 +238,7 @@ def get_new_kernel(self): del new_args del new_temp_vars - knl = self.rule_mapping_context.finish_kernel(knl) - - return knl + return self.rule_mapping_context.finish_kernel(knl) # {{{ kernel gen entrypoints diff --git a/loopy/transform/fusion.py b/loopy/transform/fusion.py index abf82272a..3fe8c842e 100644 --- a/loopy/transform/fusion.py +++ b/loopy/transform/fusion.py @@ -105,9 +105,7 @@ def _find_fusable_loop_domain_index(domain, other_domains): def _ordered_merge_lists(list_a: Sequence[T], list_b: Sequence[T]) -> list[T]: result = list(list_a) - for item in list_b: - if item not in list_b: - result.append(item) + result.extend(item for item in list_b if item not in list_b) return result @@ -169,7 +167,7 @@ def _fuse_two_kernels(kernela: LoopKernel, kernelb: LoopKernel): dom_a_s = dom_a.project_out_except(shared_inames, [dim_type.set]) dom_b_s = dom_a.project_out_except(shared_inames, [dim_type.set]) - if not (dom_a_s <= dom_b_s and dom_b_s <= dom_a_s): + if not (dom_a_s <= dom_b_s <= dom_a_s): raise LoopyError("kernels do not agree on domain of " "inames '%s'" % (",".join(shared_inames))) @@ -239,7 +237,7 @@ def _fuse_two_kernels(kernela: LoopKernel, kernelb: LoopKernel): assump_a_s = assump_a.project_out_except(shared_param_names, [dim_type.param]) assump_b_s = assump_a.project_out_except(shared_param_names, [dim_type.param]) - if not (assump_a_s <= assump_b_s and assump_b_s <= assump_a_s): + if not (assump_a_s <= assump_b_s <= assump_a_s): raise LoopyError("assumptions do not agree on kernels to be merged") new_assumptions = (assump_a & assump_b).params() diff --git a/loopy/transform/iname.py b/loopy/transform/iname.py index 33095d782..9d06d7a5a 100644 --- a/loopy/transform/iname.py +++ b/loopy/transform/iname.py @@ -31,7 +31,7 @@ Iterator, Mapping, Sequence, - Set, + Set as AbstractSet, ) from typing import TYPE_CHECKING, Any, Concatenate, Literal, TypeAlias, final from warnings import warn @@ -282,9 +282,7 @@ def _split_iname_in_set( var_length_iname: -fixed_length}))) dup_iname_dim_type, dup_name_idx = space.get_var_dict()[dup_iname_to_split] - s = s.project_out(dup_iname_dim_type, dup_name_idx, 1) - - return s + return s.project_out(dup_iname_dim_type, dup_name_idx, 1) def _split_iname_backend( @@ -547,9 +545,7 @@ def make_new_loop_index( ) if not ( - box_dom <= dom - and - dom <= box_dom): + box_dom <= dom <= box_dom): raise LoopyError( f"domain '{dom}' is not box-shape about iname " f"'{split_iname}', cannot use chunk_iname()") @@ -841,8 +837,7 @@ def parse_kv(s: str) -> tuple[InameStr, str]: unpack_iname_to_tag: list[tuple[InameStr, ToInameTagConvertible]] = [] for iname, tags in iname_to_tags_seq: if isinstance(tags, Iterable) and not isinstance(tags, str): - for tag in tags: - unpack_iname_to_tag.append((iname, tag)) + unpack_iname_to_tag.extend((iname, tag) for tag in tags) else: unpack_iname_to_tag.append((iname, tags)) @@ -1297,12 +1292,10 @@ def remove_unused_inames( domains = new_domains - kernel = kernel.copy(domains=domains) + return kernel.copy(domains=domains) # }}} - return kernel - def remove_any_newly_unused_inames( transformation_func: Callable[Concatenate[LoopKernel, P], LoopKernel] @@ -1867,11 +1860,10 @@ def make_reduction_inames_unique( for old_iname, new_iname in r_uniq.old_to_new: inames[new_iname] = inames[old_iname].copy(name=new_iname) - kernel = kernel.copy(inames=inames) + return kernel.copy(inames=inames) # }}} - return kernel # }}} @@ -2002,13 +1994,13 @@ def remove_predicates_from_insn( @final class _MapDomainMapper(RuleAwareIdentityMapper[[]]): - old_inames: Set[InameStr] - new_inames: Set[InameStr] + old_inames: AbstractSet[InameStr] + new_inames: AbstractSet[InameStr] substitutions: Mapping[str, ArithmeticExpression] def __init__(self, rule_mapping_context: SubstitutionRuleMappingContext, - new_inames: Set[InameStr], + new_inames: AbstractSet[InameStr], substitutions: Mapping[str, ArithmeticExpression] ) -> None: super().__init__(rule_mapping_context) @@ -2338,9 +2330,8 @@ def process_set(s: isl.BasicSet) -> isl.BasicSet: rule_mapping_context, transform_map_out_dims, substitutions) kernel = ins.map_kernel(kernel) - kernel = rule_mapping_context.finish_kernel(kernel) + return rule_mapping_context.finish_kernel(kernel) - return kernel # }}} @@ -2559,7 +2550,7 @@ def rename_inames( if old_idx < new_idx else old_idx - 1, 1) - if not (dom_old <= dom_new and dom_new <= dom_old): + if not (dom_old <= dom_new <= dom_old): raise LoopyError( f"inames {old_iname} and {new_iname} do not iterate over " "the same domain") diff --git a/loopy/transform/instruction.py b/loopy/transform/instruction.py index 97232dab0..08c192df4 100644 --- a/loopy/transform/instruction.py +++ b/loopy/transform/instruction.py @@ -46,6 +46,7 @@ from loopy.kernel.instruction import InstructionBase from loopy.match import ToMatchConvertible + from loopy.typing import InsnId # {{{ find_instructions @@ -365,8 +366,14 @@ def tag_instructions(kernel, new_tag, within: ToMatchConvertible = None): # {{{ add nosync @for_each_kernel -def add_nosync(kernel, scope, source, sink, bidirectional=False, force=False, - empty_ok=False): +def add_nosync( + kernel: LoopKernel, + scope, + source, + sink, + bidirectional: bool = False, + force: bool = False, + empty_ok: bool = False): """Add a *no_sync_with* directive between *source* and *sink*. *no_sync_with* is only added if *sink* depends on *source* or if the instruction pair is in a conflicting group. @@ -417,8 +424,10 @@ def add_nosync(kernel, scope, source, sink, bidirectional=False, force=False, raise LoopyError("No match found for source specification '%s'." % source) if not sinks and not empty_ok: raise LoopyError("No match found for sink specification '%s'." % sink) + del source + del sink - def insns_in_conflicting_groups(insn1_id, insn2_id): + def insns_in_conflicting_groups(insn1_id: InsnId, insn2_id: InsnId): insn1 = kernel.id_to_insn[insn1_id] insn2 = kernel.id_to_insn[insn2_id] return ( diff --git a/loopy/transform/loop_fusion.py b/loopy/transform/loop_fusion.py index d318a5455..3af8a3bc8 100644 --- a/loopy/transform/loop_fusion.py +++ b/loopy/transform/loop_fusion.py @@ -46,7 +46,14 @@ if TYPE_CHECKING: - from collections.abc import Callable, Collection, Iterable, Mapping, Sequence, Set + from collections.abc import ( + Callable, + Collection, + Iterable, + Mapping, + Sequence, + Set as AbstractSet, + ) from loopy.kernel.instruction import InstructionBase from loopy.match import RuleStack @@ -91,13 +98,13 @@ class LoopDependenceGraph: add edge, etc.). """ - successors: Mapping[InameStr, Set[InameStr]] + successors: Mapping[InameStr, AbstractSet[InameStr]] predecessors: Mapping[InameStr, frozenset[InameStr]] is_infusible: Mapping[tuple[InameStr, InameStr], bool] @classmethod def new(cls, - successors: Mapping[InameStr, Set[InameStr]], + successors: Mapping[InameStr, AbstractSet[InameStr]], is_infusible: Mapping[tuple[InameStr, InameStr], bool] ): predecessors = {node: cast("set[InameStr]", set()) for node in successors} @@ -123,7 +130,7 @@ def get_loops_with_no_predecessors(self): loop for loop, preds in self.predecessors.items() if len(preds) == 0 } - def remove_nodes(self, nodes_to_remove: Set[InameStr]): + def remove_nodes(self, nodes_to_remove: AbstractSet[InameStr]): """ Returns a copy of *self* after removing *nodes_to_remove* in the graph. This routine adds necessary edges after removing *nodes_to_remove* to @@ -482,12 +489,10 @@ def _compute_isinfusible_via_access_map( prim.Variable(candidate_pred), ">", prim.Variable(candidate_succ) ), ) - result = not ( + return not ( set_pred & set_succ & accesses_same_index_set & candidates_not_equal ).is_empty() - return result - def _build_ldg( kernel: LoopKernel, candidates: frozenset[str], outer_inames: frozenset[str] @@ -789,8 +794,7 @@ def _get_partial_loop_nest_tree_for_fusion(kernel: LoopKernel): from loopy.schedule.tools import get_partial_loop_nest_tree tree = get_partial_loop_nest_tree(kernel) - tree = _add_reduction_loops_in_partial_loop_nest_tree(kernel, tree) - return tree + return _add_reduction_loops_in_partial_loop_nest_tree(kernel, tree) def get_kennedy_unweighted_fusion_candidates( diff --git a/loopy/transform/padding.py b/loopy/transform/padding.py index cb029eb67..4f9fb29b9 100644 --- a/loopy/transform/padding.py +++ b/loopy/transform/padding.py @@ -69,7 +69,7 @@ def map_kernel(self, kernel, within=lambda *args: True): # {{{ split_array_dim (deprecated since June 2016) -SplitSpec: TypeAlias = tuple[str, int] | tuple[str, int, Literal["C"] | Literal["F"]] +SplitSpec: TypeAlias = tuple[str, int] | tuple[str, int, Literal["C", "F"]] @for_each_kernel @@ -111,7 +111,7 @@ def split_array_dim( # where "rest" is the non-argument-name part of the input tuples # in args_and_axes - def normalize_rest(rest: tuple[int, Literal["C"] | Literal["F"]] | tuple[int]): + def normalize_rest(rest: tuple[int, Literal["C", "F"]] | tuple[int]): if len(rest) == 1: return (rest[0], "C") elif len(rest) == 2: diff --git a/loopy/transform/parameter.py b/loopy/transform/parameter.py index 9f19e5729..505e0fa9e 100644 --- a/loopy/transform/parameter.py +++ b/loopy/transform/parameter.py @@ -80,7 +80,7 @@ def assume(kernel: LoopKernel, assumptions: str | isl.Set | isl.BasicSet) -> Loo def _fix_parameter( kernel: LoopKernel, name: str, - value: int | float, + value: float, within: ToStackMatchConvertible = None): def process_set(s: isl.BasicSet): var_dict = s.get_var_dict() @@ -98,13 +98,11 @@ def process_set(s: isl.BasicSet): from loopy.isl_helpers import iname_rel_aff name_equal_value_aff = iname_rel_aff(s.space, name, "==", value_aff) - s = (s + return (s .add_constraint( isl.Constraint.equality_from_aff(name_equal_value_aff)) .project_out(dt, idx, 1)) - return s - new_domains = [process_set(dom) for dom in kernel.domains] from pymbolic.mapper.substitutor import make_subst_func @@ -157,7 +155,7 @@ def map_expr(expr): def fix_parameters( kernel: LoopKernel, *, within: ToStackMatchConvertible = None, - **value_dict: int | float, + **value_dict: float, ): """Fix the values of the arguments to specific constants. diff --git a/loopy/transform/subst.py b/loopy/transform/subst.py index 3d2ee0f21..b8cb08844 100644 --- a/loopy/transform/subst.py +++ b/loopy/transform/subst.py @@ -98,8 +98,7 @@ def extract_subst(kernel, subst_name, template, parameters=(), def get_unique_var_name(): based_on = subst_name+"_wc" - result = var_name_gen(based_on) - return result + return var_name_gen(based_on) from loopy.symbolic import WildcardToUniqueVariableMapper wc_map = WildcardToUniqueVariableMapper(get_unique_var_name) diff --git a/loopy/translation_unit.py b/loopy/translation_unit.py index 10f4a06c2..a102be9c1 100644 --- a/loopy/translation_unit.py +++ b/loopy/translation_unit.py @@ -24,7 +24,7 @@ """ import collections -from collections.abc import Callable, Mapping, Set as abc_Set +from collections.abc import Callable, Mapping, Set as AbstractSet from dataclasses import dataclass, field, replace from functools import wraps from typing import ( @@ -239,7 +239,7 @@ class TranslationUnit: entrypoints: frozenset[str] def __post_init__(self): - assert isinstance(self.entrypoints, abc_Set) + assert isinstance(self.entrypoints, AbstractSet) assert isinstance(self.callables_table, constantdict) def copy(self, **kwargs: Any) -> Self: @@ -277,7 +277,7 @@ def with_entrypoints(self, entrypoints: str | frozenset[str]) -> Self: entrypoints = frozenset([e.strip() for e in entrypoints.split(",")]) - assert isinstance(entrypoints, abc_Set) + assert isinstance(entrypoints, AbstractSet) return self.copy(entrypoints=entrypoints) @@ -504,7 +504,7 @@ def rename_resolved_functions_in_a_single_kernel(kernel, def get_reachable_resolved_callable_ids( callables: CallablesTable, - entrypoints: abc_Set[CallableId] + entrypoints: AbstractSet[CallableId] ) -> frozenset[CallableId]: """ Returns a :class:`frozenset` of callables ids that are resolved and diff --git a/loopy/type_inference.py b/loopy/type_inference.py index 7d8b3c6fc..258717472 100644 --- a/loopy/type_inference.py +++ b/loopy/type_inference.py @@ -439,8 +439,7 @@ def map_constant(self, expr: object): if iinfo.min <= expr <= iinfo.max: return [NumpyType(np.dtype(tp))] - else: - raise TypeInferenceFailure("integer constant '%s' too large" % expr) + raise TypeInferenceFailure("integer constant '%s' too large" % expr) dt = np.asarray(expr).dtype if hasattr(expr, "dtype"): diff --git a/pyproject.toml b/pyproject.toml index d03f31730..78b98f8fc 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -116,22 +116,25 @@ extend-ignore = [ "N817", # CamelCase `SubstitutionRuleMappingContext` imported as acronym `SRMC` "SIM102", # combine if statements "RUF067", # no code in __init__ *shrug* + "TRY004", + "TRY300", # FIXME "UP031", # .format instead of %s + "BLE001", ] [tool.ruff.lint.per-file-ignores] "test/test_loopy.py" = ["B023"] -"loopy/target/c/compyte/ndarray/**/*.py" = ["Q", "B", "E", "F", "N", "C4"] "loopy/frontend/fortran/translator.py" = ["N802", "B028"] "proto-tests/*.py" = ["B"] "contrib/**/*.py" = ["I002"] -"doc/conf.py" = ["I002"] +"doc/conf.py" = ["I002", "S102"] "*.ipynb" = ["I002"] "examples/**/*.py" = ["I002"] -"proto-tests/**/*.py" = ["I002"] +"proto-tests/**/*.py" = ["I002", "S102"] "test/**/*.py" = ["I002"] +"test/test_*.py" = ["S102"] [tool.ruff.lint.flake8-quotes] docstring-quotes = "double" diff --git a/test/gnuma_loopy_transforms.py b/test/gnuma_loopy_transforms.py index afffb6724..63c6a4851 100644 --- a/test/gnuma_loopy_transforms.py +++ b/test/gnuma_loopy_transforms.py @@ -27,9 +27,7 @@ def set_q_storage_format(kernel, name): kernel = lp.split_array_dim( kernel, (name, 3, "F"), 4, auto_split_inames=False) - kernel = lp.tag_array_axes(kernel, name, "N0,N1,N2,vec,N4,N3") - - return kernel + return lp.tag_array_axes(kernel, name, "N0,N1,N2,vec,N4,N3") def set_D_storage_format(kernel): # noqa: N802 @@ -40,5 +38,4 @@ def set_up_volume_loop(kernel, Nq): # noqa: N803 kernel = lp.fix_parameters(kernel, Nq=Nq) kernel = lp.prioritize_loops(kernel, "e,k,j,i") kernel = lp.tag_inames(kernel, {"e": "g.0", "j": "l.1", "i": "l.0"}) - kernel = lp.assume(kernel, "elements >= 1") - return kernel + return lp.assume(kernel, "elements >= 1") diff --git a/test/test_apps.py b/test/test_apps.py index d81848315..5355642cf 100644 --- a/test/test_apps.py +++ b/test/test_apps.py @@ -73,13 +73,11 @@ def test_convolution(ctx_factory: cl.CtxFactory): def variant_0(knl): # knl = lp.split_iname(knl, "im_x", 16, inner_tag="l.0") - knl = lp.prioritize_loops(knl, "iimg,im_x,im_y,ifeat,f_x,f_y") - return knl + return lp.prioritize_loops(knl, "iimg,im_x,im_y,ifeat,f_x,f_y") def variant_1(knl): knl = lp.split_iname(knl, "im_x", 16, inner_tag="l.0") - knl = lp.prioritize_loops(knl, "iimg,im_x_outer,im_y,ifeat,f_x,f_y") - return knl + return lp.prioritize_loops(knl, "iimg,im_x_outer,im_y,ifeat,f_x,f_y") def variant_2(knl): knl = lp.split_iname(knl, "im_x", 16, outer_tag="g.0", inner_tag="l.0") @@ -88,10 +86,9 @@ def variant_2(knl): knl = lp.add_prefetch(knl, "f[ifeat,:,:,:]", fetch_outer_inames="im_x_outer, im_y_outer, ifeat", default_tag="l.auto") - knl = lp.add_prefetch(knl, "img", "im_x_inner, im_y_inner, f_x, f_y", + return lp.add_prefetch(knl, "img", "im_x_inner, im_y_inner, f_x, f_y", fetch_outer_inames="iimg, im_x_outer, im_y_outer, ifeat, icolor", default_tag="l.auto") - return knl for variant in [ # variant_0, @@ -144,13 +141,11 @@ def test_convolution_with_nonzero_base(ctx_factory: cl.CtxFactory): def variant_0(knl): # knl = lp.split_iname(knl, "im_x", 16, inner_tag="l.0") - knl = lp.prioritize_loops(knl, "iimg,im_x,im_y,ifeat,f_x,f_y") - return knl + return lp.prioritize_loops(knl, "iimg,im_x,im_y,ifeat,f_x,f_y") def variant_1(knl): knl = lp.split_iname(knl, "im_x", 16, inner_tag="l.0") - knl = lp.prioritize_loops(knl, "iimg,im_x_outer,im_y,ifeat,f_x,f_y") - return knl + return lp.prioritize_loops(knl, "iimg,im_x_outer,im_y,ifeat,f_x,f_y") for variant in [ variant_0, @@ -331,16 +326,14 @@ def variant_1(knl): knl = lp.split_iname(knl, "i", 16, outer_tag="g.1", inner_tag="l.1") knl = lp.split_iname(knl, "j", 16, outer_tag="g.0", inner_tag="l.0") knl = lp.add_prefetch(knl, "a", ["i_inner", "j_inner"], default_tag="l.auto") - knl = lp.prioritize_loops(knl, ["a_dim_0_outer", "a_dim_1_outer"]) - return knl + return lp.prioritize_loops(knl, ["a_dim_0_outer", "a_dim_1_outer"]) def variant_2(knl): knl = lp.split_iname(knl, "i", 16, outer_tag="g.1", inner_tag="l.1") knl = lp.split_iname(knl, "j", 16, outer_tag="g.0", inner_tag="l.0") knl = lp.add_prefetch(knl, "a", ["i_inner", "j_inner"], fetch_bounding_box=True, default_tag="l.auto") - knl = lp.prioritize_loops(knl, ["a_dim_0_outer", "a_dim_1_outer"]) - return knl + return lp.prioritize_loops(knl, ["a_dim_0_outer", "a_dim_1_outer"]) for variant in [ # variant_1, @@ -386,8 +379,7 @@ def variant_overfetch(knl): slabs=(1, 1)) knl = lp.add_prefetch(knl, "a", ["i_inner", "j_inner"], fetch_bounding_box=True, default_tag="l.auto") - knl = lp.prioritize_loops(knl, ["a_dim_0_outer", "a_dim_1_outer"]) - return knl + return lp.prioritize_loops(knl, ["a_dim_0_outer", "a_dim_1_outer"]) for variant in [variant_overfetch]: n = 200 @@ -573,13 +565,11 @@ def test_poisson_fem(ctx_factory: cl.CtxFactory): def variant_1(knl): knl = lp.precompute(knl, "dpsi", "i,k,ell", default_tag="for") - knl = lp.prioritize_loops(knl, "c,i,j") - return knl + return lp.prioritize_loops(knl, "c,i,j") def variant_2(knl): knl = lp.precompute(knl, "dpsi", "i,ell", default_tag="for") - knl = lp.prioritize_loops(knl, "c,i,j") - return knl + return lp.prioritize_loops(knl, "c,i,j") def add_types(knl): return lp.add_and_infer_dtypes(knl, { diff --git a/test/test_dg.py b/test/test_dg.py index bcfc65271..a5949159b 100644 --- a/test/test_dg.py +++ b/test/test_dg.py @@ -80,27 +80,23 @@ def test_dg_volume(ctx_factory: cl.CtxFactory): seq_knl = knl def variant_basic(knl): - knl = lp.tag_inames(knl, {"k": "g.0", "n": "l.0"}) - return knl + return lp.tag_inames(knl, {"k": "g.0", "n": "l.0"}) def variant_more_per_work_group(knl): knl = lp.tag_inames(knl, {"n": "l.0"}) - knl = lp.split_iname(knl, "k", 3, outer_tag="g.0", inner_tag="l.1") - return knl + return lp.split_iname(knl, "k", 3, outer_tag="g.0", inner_tag="l.1") def variant_image_d(knl): knl = lp.tag_inames(knl, {"n": "l.0"}) knl = lp.split_iname(knl, "k", 3, outer_tag="g.0", inner_tag="l.1") - knl = lp.change_arg_to_image(knl, "DrDsDt") - return knl + return lp.change_arg_to_image(knl, "DrDsDt") def variant_prefetch_d(knl): knl = lp.tag_inames(knl, {"n": "l.0"}) knl = lp.split_iname(knl, "k", 3, outer_tag="g.0", inner_tag="l.1") - knl = lp.add_prefetch(knl, "DrDsDt[:,:]", + return lp.add_prefetch(knl, "DrDsDt[:,:]", fetch_outer_inames="k_outer", default_tag="l.auto") - return knl def variant_prefetch_fields(knl): knl = lp.tag_inames(knl, {"n": "l.0"}) @@ -115,8 +111,7 @@ def variant_k_ilp(knl): knl = lp.tag_inames(knl, {"n": "l.0"}) knl = lp.split_iname(knl, "k", 3, outer_tag="g.0", inner_tag="ilp") - knl = lp.tag_inames(knl, {"m": "unr"}) - return knl + return lp.tag_inames(knl, {"m": "unr"}) def variant_simple_padding(knl): knl = lp.tag_inames(knl, {"n": "l.0"}) @@ -131,9 +126,7 @@ def variant_simple_padding(knl): for name in arg_names: knl = lp.add_padding(knl, name, axis=0, align_bytes=32) - knl = lp.tag_inames(knl, {"m": "unr"}) - - return knl + return lp.tag_inames(knl, {"m": "unr"}) def variant_fancy_padding(knl): knl = lp.tag_inames(knl, {"n": "l.0"}) @@ -145,9 +138,7 @@ def variant_fancy_padding(knl): for name in ["u", "v", "w", "p"] for prefix in ["", "rhs"]] - knl = lp.split_array_dim(knl, [(nm, 0) for nm in arg_names], pad_mult) - - return knl + return lp.split_array_dim(knl, [(nm, 0) for nm in arg_names], pad_mult) parameters_dict = {"K": K} diff --git a/test/test_linalg.py b/test/test_linalg.py index 2ad37ace3..9d22add7d 100644 --- a/test/test_linalg.py +++ b/test/test_linalg.py @@ -28,7 +28,7 @@ import pytest import pyopencl as cl -import pyopencl.cltypes as cltypes +from pyopencl import cltypes from pyopencl.tools import ( # noqa: F401 pytest_generate_tests_for_pyopencl as pytest_generate_tests, ) @@ -103,17 +103,15 @@ def variant_cpu(knl: TranslationUnit): block_size = unroll*4096 knl = lp.split_iname(knl, "i", block_size, outer_tag="g.0", slabs=(0, 1)) knl = lp.split_iname(knl, "i_inner", unroll, inner_tag="unr") - knl = lp.prioritize_loops(knl, "i_outer, i_inner_outer, i_inner_inner") - return knl + return lp.prioritize_loops(knl, "i_outer, i_inner_outer, i_inner_inner") def variant_gpu(knl: TranslationUnit): unroll = 4 block_size = 256 knl = lp.split_iname(knl, "i", unroll*block_size, outer_tag="g.0", slabs=(0, 1)) - knl = lp.split_iname(knl, "i_inner", block_size, + return lp.split_iname(knl, "i_inner", block_size, outer_tag="unr", inner_tag="l.0") - return knl # for variant in [ variant_gpu]: for variant in [variant_cpu, variant_gpu]: @@ -308,8 +306,7 @@ def variant_1(knl): knl = lp.add_prefetch(knl, "a", default_tag="l.auto") knl = lp.add_prefetch(knl, "b", default_tag="l.auto") knl = lp.prioritize_loops(knl, ["i", "j"]) - knl = lp.add_inames_to_insn(knl, "i", "writes:b_fetch") - return knl + return lp.add_inames_to_insn(knl, "i", "writes:b_fetch") def variant_2(knl): knl = lp.split_iname(knl, "i", 16, @@ -319,9 +316,8 @@ def variant_2(knl): knl = lp.add_prefetch(knl, "a", fetch_outer_inames="i_outer, i_inner, j_outer, j_inner") - knl = lp.add_prefetch(knl, "b", + return lp.add_prefetch(knl, "b", fetch_outer_inames="i_outer, i_inner, j_outer, j_inner") - return knl def variant_3(knl): knl = lp.split_iname(knl, "i", 16, @@ -333,13 +329,11 @@ def variant_3(knl): fetch_outer_inames="i_outer, j_outer, j_inner", temporary_address_space=lp.AddressSpace.LOCAL, default_tag="l.auto") - knl = lp.add_prefetch(knl, "b", ["j_inner"], + return lp.add_prefetch(knl, "b", ["j_inner"], fetch_outer_inames="i_outer, j_outer, j_inner", temporary_address_space=lp.AddressSpace.LOCAL, default_tag="l.auto") - return knl - def variant_4(knl): knl = lp.split_iname(knl, "i", 256, outer_tag="g.0", slabs=(0, 1)) @@ -358,9 +352,8 @@ def variant_4(knl): knl = lp.split_iname(knl, "a_dim_0", 16, outer_tag="l.1", inner_tag="l.0") - knl = lp.split_iname(knl, "b_dim_0", 16, + return lp.split_iname(knl, "b_dim_0", 16, outer_tag="l.1", inner_tag="l.0") - return knl seq_knl = knl diff --git a/test/test_loopy.py b/test/test_loopy.py index 40b6268d8..52c9cee35 100644 --- a/test/test_loopy.py +++ b/test/test_loopy.py @@ -27,8 +27,7 @@ import pyopencl as cl import pyopencl.array as cl_array -import pyopencl.clmath as clmath -import pyopencl.clrandom as clrandom +from pyopencl import clmath, clrandom from pyopencl.tools import ( # noqa: F401 pytest_generate_tests_for_pyopencl as pytest_generate_tests, ) diff --git a/test/test_nbody.py b/test/test_nbody.py index 358f727eb..c12a41332 100644 --- a/test/test_nbody.py +++ b/test/test_nbody.py @@ -58,15 +58,13 @@ def variant_1(knl): knl = lp.split_iname(knl, "i", 256, outer_tag="g.0", inner_tag="l.0", slabs=(0, 1)) - knl = lp.split_iname(knl, "j", 256, slabs=(0, 1)) - return knl + return lp.split_iname(knl, "j", 256, slabs=(0, 1)) def variant_cpu(knl): knl = lp.expand_subst(knl) knl = lp.split_iname(knl, "i", 1024, outer_tag="g.0", slabs=(0, 1)) - knl = lp.add_prefetch(knl, "x[i,k]", ["k"], default_tag=None) - return knl + return lp.add_prefetch(knl, "x[i,k]", ["k"], default_tag=None) def variant_gpu(knl): knl = lp.expand_subst(knl) @@ -78,8 +76,7 @@ def variant_gpu(knl): fetch_outer_inames="i_outer, j_outer", default_tag=None) knl = lp.tag_inames(knl, {"x_fetch_k": "unr", "x_fetch_j": "l.0"}) knl = lp.add_prefetch(knl, "x[i,k]", ["k"], default_tag=None) - knl = lp.prioritize_loops(knl, ["j_outer", "j_inner"]) - return knl + return lp.prioritize_loops(knl, ["j_outer", "j_inner"]) n = 3000 diff --git a/test/test_numa_diff.py b/test/test_numa_diff.py index 0dc4f0ef8..751d537e8 100644 --- a/test/test_numa_diff.py +++ b/test/test_numa_diff.py @@ -149,8 +149,7 @@ def test_gnuma_horiz_kernel(ctx_factory: cl.CtxFactory, ilp_multiple, Nq, opt_le hsv = lp.tag_array_axes(hsv, flux_store_name, "N1,N0,N2?") n_iname = "n_"+flux_var.replace("_r", "").replace("_s", "") - if n_iname.endswith("_0"): - n_iname = n_iname[:-2] + n_iname = n_iname.removesuffix("_0") hsv = lp.rename_iname(hsv, "n", n_iname, within="id:"+reader.id, existing_ok=True) diff --git a/test/test_split_iname_slabs.py b/test/test_split_iname_slabs.py index 1582ee605..b3639a281 100644 --- a/test/test_split_iname_slabs.py +++ b/test/test_split_iname_slabs.py @@ -48,15 +48,13 @@ def vanilla(): lp.ValueArg("n", dtype="int32"), lp.GlobalArg("a", shape=(None, ), dtype="int32")]) - k = lp.assume(k, "k >= 0 and n >= k") - return k + return lp.assume(k, "k >= 0 and n >= k") @pytest.fixture def split(vanilla): k = lp.split_iname(vanilla, "i", 4, slabs=(1, 1)) - k = lp.prioritize_loops(k, "i_outer,i_inner") - return k + return lp.prioritize_loops(k, "i_outer,i_inner") @pytest.fixture(params=[(1, 4), (1, 5), (4, 8)], diff --git a/test/test_target.py b/test/test_target.py index 69c36620a..302d451b5 100644 --- a/test/test_target.py +++ b/test/test_target.py @@ -28,8 +28,8 @@ import pymbolic.primitives as prim import pyopencl as cl -import pyopencl.clrandom as clrandom import pyopencl.tools as cl_tools +from pyopencl import clrandom from pyopencl.tools import ( # noqa: F401 pytest_generate_tests_for_pyopencl as pytest_generate_tests, ) diff --git a/test/testlib.py b/test/testlib.py index f3c657f4e..5f340eba6 100644 --- a/test/testlib.py +++ b/test/testlib.py @@ -45,7 +45,6 @@ def with_types(self, arg_id_to_dtype, callables_table): name_in_target = "log2f" elif dtype.type == np.float64: name_in_target = "log2" - pass else: raise TypeError(f"log2: unexpected type {dtype}")