Merge branch 'develop' into dpp-refactor-blockwise-reduce

Author: stefankoncarevic

.github/workflows/ci.yml

@@ -1,4 +1,4 @@
-name: Python Lint and Format Check
+name: rocMLIR GitHub Actions
 
 on:
   pull_request:
@@ -9,6 +9,8 @@ on:
       - "mlir/**"
       - "external/**"
       - "!external/llvm-project/**"
+      - ".github/workflows/**"
+      - "pip_requirements.txt"
   push:
     branches:
       - develop
@@ -17,8 +19,11 @@ on:
       - "mlir/**"
       - "external/**"
       - "!external/llvm-project/**"
+      - ".github/workflows/**"
+      - "pip_requirements.txt"
 jobs:
-  py-checks:
+  format-and-lint-checks:
+    name: Python format and lint checks
     runs-on: ubuntu-latest
     container:
       image: python:3.10
@@ -95,3 +100,30 @@ jobs:
       - name: No Python changes in mlir/
         if: steps.changes.outputs.files == ''
         run: echo "No changed *.py files under mlir/ – skipping."
+
+  python-tests:
+    name: Python performance script tests
+    runs-on: ubuntu-latest
+    container:
+      image: python:3.10
+      options: --user root
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Fix git ownership
+        run: |
+          git config --global --add safe.directory "$GITHUB_WORKSPACE"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r pip_requirements.txt
+
+      - name: Run performance script tests (no GPU)
+        run: |
+          cd mlir/utils/performance && python -m pytest tests/ -v
+        env:
+          # Tests mock HIP/GPU; no ROCm or GPU required
+          PYTHONPATH: ${{ github.workspace }}/mlir/utils/performance

.github/workflows/codecov-report.yml

@@ -0,0 +1,184 @@
+name: Codecov Report
+
+on:
+  schedule:
+    # Runs every Monday at 09:00 UTC.
+    # The job skips odd ISO weeks so the effective cadence is biweekly.
+    - cron: '0 9 * * 1'
+  workflow_dispatch:
+
+jobs:
+  codecov-teams-report:
+    name: Codecov coverage report to Teams
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+
+    permissions:
+      contents: read
+
+    steps:
+      - name: Biweekly gate
+        id: gate
+        run: |
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
+            echo "skip=false" >> "$GITHUB_OUTPUT"
+            echo "Manual trigger — always run."
+          else
+            WEEK=$(date +%V)
+            if [ $((10#$WEEK % 2)) -eq 0 ]; then
+              echo "skip=false" >> "$GITHUB_OUTPUT"
+              echo "Even ISO week ($WEEK) — running."
+            else
+              echo "skip=true"  >> "$GITHUB_OUTPUT"
+              echo "Odd ISO week ($WEEK) — skipping."
+            fi
+          fi
+
+      - name: Fetch Codecov data and notify Teams
+        if: steps.gate.outputs.skip != 'true'
+        env:
+          MLIR_TEAM_CONVERSATION: ${{ secrets.MLIR_TEAM_CONVERSATION }}
+          MLIR_CI_CHANNEL: ${{ secrets.MLIR_CI_CHANNEL }}
+        run: |
+          set -euo pipefail
+
+          OWNER="ROCm"
+          REPO="rocMLIR"
+          API="https://api.codecov.io/api/v2/github/${OWNER}/repos/${REPO}"
+
+          # ── 1. Fetch repo-level data from Codecov ─────────────────
+          echo "::group::Repository coverage"
+          repo_json=$(curl -sf "$API/") \
+            || { echo "::error::Failed to fetch repo data from Codecov API"; exit 1; }
+          echo "$repo_json" | jq .
+          echo "::endgroup::"
+
+          # ── 2. Parse overall totals ─────────────────────────────────
+          coverage=$(echo "$repo_json" | jq -r '.totals.coverage // "N/A"')
+          hits=$(echo "$repo_json"     | jq -r '.totals.hits     // "N/A"')
+          lines=$(echo "$repo_json"    | jq -r '.totals.lines    // "N/A"')
+          misses=$(echo "$repo_json"   | jq -r '.totals.misses   // "N/A"')
+          branches=$(echo "$repo_json" | jq -r '.totals.branches // "N/A"')
+          echo "Overall line coverage: ${coverage}%"
+
+          # ── 3. Determine colour for the headline number ─────────────
+          cov_color=$(echo "$coverage" | jq -Rr '
+            (tonumber? // 0) as $v |
+            if   $v >= 70 then "Good"
+            elif $v >= 50 then "Warning"
+            else               "Attention"
+            end')
+
+          TIMESTAMP=$(date -u '+%Y-%m-%d %H:%M UTC')
+          CODECOV_URL="https://app.codecov.io/gh/${OWNER}/${REPO}"
+          RUN_URL="${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}/actions/runs/${GITHUB_RUN_ID}"
+
+          # ── 4. Assemble the Adaptive Card ───────────────────────────
+          payload=$(jq -n \
+            --arg cov       "$coverage" \
+            --arg cov_color "$cov_color" \
+            --arg hits      "$hits" \
+            --arg lines     "$lines" \
+            --arg misses    "$misses" \
+            --arg branches  "$branches" \
+            --arg ts        "$TIMESTAMP" \
+            --arg cov_url   "$CODECOV_URL" \
+            --arg run_url   "$RUN_URL" \
+          '{
+            "attachments": [{
+              "contentType": "application/vnd.microsoft.card.adaptive",
+              "content": {
+                "type": "AdaptiveCard",
+                "$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
+                "version": "1.5",
+                "body": [
+                  {
+                    "type": "TextBlock",
+                    "text": "Codecov Report 📊",
+                    "weight": "bolder",
+                    "size": "extraLarge",
+                    "separator": true
+                  },
+                  {
+                    "type": "TextBlock",
+                    "text": "rocMLIR — \($ts)",
+                    "isSubtle": true
+                  },
+                  {
+                    "type": "ColumnSet",
+                    "columns": [
+                      {
+                        "type": "Column",
+                        "width": "auto",
+                        "items": [{
+                          "type": "TextBlock",
+                          "text": "\($cov)%",
+                          "size": "extraLarge",
+                          "weight": "bolder",
+                          "color": $cov_color
+                        }]
+                      },
+                      {
+                        "type": "Column",
+                        "width": "stretch",
+                        "items": [
+                          {
+                            "type": "TextBlock",
+                            "text": "Overall Line Coverage",
+                            "weight": "bolder"
+                          },
+                          {
+                            "type": "FactSet",
+                            "facts": [
+                              {"title": "Lines",    "value": $lines},
+                              {"title": "Hits",     "value": $hits},
+                              {"title": "Misses",   "value": $misses},
+                              {"title": "Branches", "value": $branches}
+                            ]
+                          }
+                        ]
+                      }
+                    ]
+                  },
+                  {
+                    "type": "TextBlock",
+                    "text": "Generated: \($ts)",
+                    "size": "small",
+                    "isSubtle": true,
+                    "spacing": "medium"
+                  }
+                ],
+                "actions": [
+                  {"type": "Action.OpenUrl", "url": $cov_url, "title": "Open Codecov Dashboard 📈"},
+                  {"type": "Action.OpenUrl", "url": $run_url, "title": "View Workflow Run 🔗"}
+                ]
+              }
+            }]
+          }')
+
+          echo "::group::Teams payload"
+          echo "$payload" | jq .
+          echo "::endgroup::"
+
+          # ── 5. POST to each configured Teams webhook ────────────────
+          send_to_teams() {
+            local url="$1" label="$2"
+            if [ -z "$url" ]; then
+              echo "Skipping ${label} (URL not set)."
+              return 0
+            fi
+            resp=$(curl -s -w '\n%{http_code}' -X POST "$url" \
+              -H 'Content-Type: application/json; charset=utf-8' \
+              -d "$payload")
+            http_code=$(echo "$resp" | tail -1)
+            body=$(echo "$resp" | sed '$d')
+            echo "Teams webhook (${label}): HTTP ${http_code}${body:+ body=${body}}"
+            if [ "$http_code" != "200" ] && [ "$http_code" != "202" ]; then
+              echo "::warning::Teams notification (${label}) may have failed (expected 200/202, got ${http_code})"
+              return 1
+            fi
+          }
+
+          send_to_teams "$MLIR_TEAM_CONVERSATION" "MLIR_TEAM_CONVERSATION"
+          send_to_teams "$MLIR_CI_CHANNEL"        "MLIR_CI_CHANNEL"
+          echo "Done."

mlir/include/mlir/Conversion/MIGraphXToLinalg/MIGraphXToLinalg.h

@@ -39,6 +39,10 @@ void populateMIGraphXToLinalgBoundaryDialectConversion(
 /// migraphx.mlir.as_logical_shape and migraphx.mlir.as_underlying_shape.
 void populateMIGraphXFuncBoundaryToLinalgConversionPatterns(
     RewritePatternSet &target, TypeConverter &typeConverter);
+
+/// Populates conversion patterns for function boundaries mhal.launcher
+void populateMIGraphXToLinalgMHALLauncherConversion(
+    RewritePatternSet &target, TypeConverter &typeConverter);
 } // namespace migraphx
 } // namespace mlir
 

mlir/include/mlir/Conversion/RocMLIRPasses.td

@@ -144,7 +144,7 @@ def MIGraphXToLinalgPass : Pass<"migraphx-to-linalg", "::mlir::func::FuncOp"> {
   }];
 
   let dependentDialects = ["arith::ArithDialect", "tensor::TensorDialect",
-                           "linalg::LinalgDialect"];
+                           "linalg::LinalgDialect", "rock::RockDialect"];
 }
 
 //===----------------------------------------------------------------------===//

mlir/include/mlir/Dialect/MIGraphX/IR/MIGraphX.td

@@ -162,6 +162,8 @@ def MIGraphX_ErfOp :
   let description = [{
     compute gauss error function
   }];
+  let arguments = (ins MIXRShapedOf<[AnyFloat]>:$inA);
+  let results = (outs MIXRShapedOf<[AnyFloat]>:$output);
 }
 def MIGraphX_ExpOp :
     MIGraphX_ElementwiseUnaryOp<"exp">;
@@ -184,6 +186,7 @@ def MIGraphX_SigmoidOp :
   let description = [{
     Sigmoid function, aka 1 / (1 + exp(-x)).
   }];
+  let hasVerifier = 1;
 }
 def MIGraphX_SqrtOp :
     MIGraphX_ElementwiseUnaryOp<"sqrt">;

mlir/include/mlir/Dialect/Rock/IR/MfmaInsnGroup.h

@@ -31,7 +31,13 @@ enum class MfmaTypeId : uint32_t {
   Fp8Fp8TyId,
   Fp8Bf8TyId,
   Bf8Fp8TyId,
-  Bf8Bf8TyId
+  Bf8Bf8TyId,
+  // FP8 via scaled MFMA (uses mfma_scale_f32_16x16x128_f8f6f4 with cbsz=0)
+  // These provide larger K dimension (128 for 16x16, 64 for 32x32)
+  Fp8Fp8ScaledTyId,
+  Fp8Bf8ScaledTyId,
+  Bf8Fp8ScaledTyId,
+  Bf8Bf8ScaledTyId
 };
 
 struct MfmaInsnInfo {
@@ -71,7 +77,8 @@ class MfmaInsn {
   MfmaInsnAttr getAttr() const;
   Type getArgTypeFor(Type elementTypeA);
   VectorType getRetType(Type elementType);
-  bool isCoherentWithK(int64_t kPack, int64_t kPerBlock);
+  bool isCoherentWithK(int64_t kPack, int64_t kPerBlock,
+                       int64_t scheduleVersion);
 };
 
 template <typename T>
@@ -138,7 +145,8 @@ class MfmaInsnGroup {
 public:
   static FailureOr<MfmaInsnGroup> select(Type elementTypeA, Type elementTypeB,
                                          StringRef arch, int64_t mnPerXdl,
-                                         int64_t kPack, int64_t kPackPerBlock);
+                                         int64_t kPack, int64_t kPackPerBlock,
+                                         int64_t scheduleVersion);
   MfmaInsnGroup(Type elementTypeA, Type elementTypeB, const MfmaInsn &insn,
                 const MfmaInsnGroupAttr &groupAttr);
   int64_t getMRepeats(int64_t mPerWave);
@@ -150,8 +158,13 @@ class MfmaInsnGroup {
   Type getArgTypeA();
   Type getArgTypeB();
   VectorType getRetType();
-  bool isCoherentWithK(int64_t kPack, int64_t kPerBlock);
+  bool isCoherentWithK(int64_t kPack, int64_t kPerBlock,
+                       int64_t scheduleVersion);
   SmallString<16> getROCDLIntrinsicName() { return groupAttr.insn; }
+
+  // Check if this is FP8 using scaled MFMA (mfma_scale with cbsz=0, blgp=0)
+  // These instructions have larger K dimension (128 for 16x16, 64 for 32x32)
+  bool isScaledFp8() const;
 };
 
 } // namespace rock

mlir/include/mlir/Dialect/Rock/IR/RockAttrDefs.td

@@ -59,6 +59,22 @@ def ConvOpBwdWeightType : I32EnumAttrCase<"BwdWeight", 2, "conv_bwd_weight">;
 def ConvOpTypes : Rock_I32Enum<"ConvOpType", "The type of a convolution operation",
   [ConvOpType, ConvOpBwdDataType, ConvOpBwdWeightType]>;
 
+/// LinalgConvType
+def LinalgConv_1D : I32EnumAttrCase<"Conv1dNgchGkch", 0, "conv1d_ngch_gkch">;
+def LinalgConv_2D
+    : I32EnumAttrCase<"Conv2dNgchwGkchw", 1, "conv2d_ngchw_gkchw">;
+def LinalgConv_3D
+    : I32EnumAttrCase<"Conv3dNgchwdGkchwd", 2, "conv3d_ngchwd_gkchwd">;
+
+def LinalgConvType
+    : Rock_I32Enum<"LinalgConvType",
+                   "Hints for the linalg.generic convolution ops used by "
+                   "linalg-to-rock lowering",
+                   [LinalgConv_1D, LinalgConv_2D, LinalgConv_3D]>;
+
+def LinalgConvTypeAttr
+    : EnumAttr<Rock_Dialect, LinalgConvType, "LinalgConvType">;
+
 /// Kerneltype
 def KernelTypeConv : I32EnumAttrCase<"Conv", 0>;
 def KernelTypeConvBwdData : I32EnumAttrCase<"ConvBwdData", 1>;

mlir/include/mlir/Dialect/Rock/Passes.h

@@ -42,6 +42,7 @@ namespace rock {
 #define GEN_PASS_DECL_ROCKVIEWTOTRANSFORMPASS
 #define GEN_PASS_DECL_ROCKDETECTFLASHDECODINGPASS
 #define GEN_PASS_DECL_ROCKLOWERREDUCEPASS
+#define GEN_PASS_DECL_ROCKREMOVEREDUNDANTCASTSPASS
 #define GEN_PASS_DECL_ROCKPREPARELLVMPASS
 #define GEN_PASS_DECL_ROCKCHECKRESIDENCYPASS
 #define GEN_PASS_DECL_ROCKVECTORIZEFUSIONSPASS

mlir/include/mlir/Dialect/Rock/Passes.td

@@ -182,6 +182,20 @@ def RockLowerReducePass : Pass<"rock-lower-reduce", "::mlir::func::FuncOp"> {
   let dependentDialects = ["rock::RockDialect", "func::FuncDialect", "gpu::GPUDialect"];
 }
 
+def RockRemoveRedundantCastsPass
+    : Pass<"rock-remove-redundant-casts", "::mlir::LLVM::LLVMFuncOp"> {
+  let summary = "Remove redundant fptrunc/fpext pairs through buffers at LLVM "
+                "dialect level";
+  let description = [{
+    Detects patterns at the LLVM dialect level where wider float values are
+    truncated (llvm.fptrunc) to a narrower type, stored to a buffer, then loaded
+    and extended (llvm.fpext) back to the original wider type. This pass
+    redirects the loads to read the wide values directly, eliminating the
+    fpext and preserving precision.
+  }];
+  let dependentDialects = ["LLVM::LLVMDialect"];
+}
+
 def RockPrepareLLVMPass : Pass<"rock-prepare-llvm", "::mlir::LLVM::LLVMFuncOp"> {
   let summary = "prepare the generated code for llvm";
   let dependentDialects = ["ROCDL::ROCDLDialect"];